2015-07-30 21:01:53 +00:00
// Package daemon exposes the functions that occur on the host server
// that the Docker daemon is running.
//
// In implementing the various functions of the daemon, there is often
// a method-specific struct for configuring the runtime behavior.
2014-04-17 21:43:01 +00:00
package daemon
2013-01-19 00:13:39 +00:00
import (
2015-05-15 23:34:26 +00:00
"errors"
2013-01-19 00:13:39 +00:00
"fmt"
2014-04-28 21:36:04 +00:00
"io"
"io/ioutil"
"os"
2015-01-16 19:48:25 +00:00
"path/filepath"
2014-07-30 06:51:43 +00:00
"runtime"
2014-04-28 21:36:04 +00:00
"strings"
"sync"
"time"
2015-03-26 22:22:04 +00:00
"github.com/Sirupsen/logrus"
2015-11-18 22:20:54 +00:00
"github.com/docker/distribution/digest"
"github.com/docker/distribution/reference"
2014-11-17 19:23:41 +00:00
"github.com/docker/docker/api"
2015-09-28 22:00:45 +00:00
"github.com/docker/docker/api/types"
2015-10-08 23:16:36 +00:00
"github.com/docker/docker/cliconfig"
2015-11-12 19:55:17 +00:00
"github.com/docker/docker/container"
2015-04-03 22:17:49 +00:00
"github.com/docker/docker/daemon/events"
2015-11-20 22:35:16 +00:00
"github.com/docker/docker/daemon/exec"
2014-07-24 22:19:50 +00:00
"github.com/docker/docker/daemon/execdriver"
"github.com/docker/docker/daemon/execdriver/execdrivers"
"github.com/docker/docker/daemon/graphdriver"
2015-10-08 23:16:36 +00:00
_ "github.com/docker/docker/daemon/graphdriver/vfs" // register vfs
2015-04-09 04:23:30 +00:00
"github.com/docker/docker/daemon/logger"
2015-04-04 04:06:48 +00:00
"github.com/docker/docker/daemon/network"
2015-11-18 22:20:54 +00:00
"github.com/docker/docker/distribution"
dmetadata "github.com/docker/docker/distribution/metadata"
2015-10-08 23:16:36 +00:00
derr "github.com/docker/docker/errors"
2015-07-20 17:57:15 +00:00
"github.com/docker/docker/image"
2015-11-18 22:20:54 +00:00
"github.com/docker/docker/image/tarexport"
"github.com/docker/docker/layer"
"github.com/docker/docker/migrate/v1"
2015-07-25 00:49:43 +00:00
"github.com/docker/docker/pkg/archive"
2015-09-10 23:12:00 +00:00
"github.com/docker/docker/pkg/discovery"
2015-03-29 21:17:23 +00:00
"github.com/docker/docker/pkg/fileutils"
2014-07-24 22:19:50 +00:00
"github.com/docker/docker/pkg/graphdb"
2015-10-08 15:51:41 +00:00
"github.com/docker/docker/pkg/idtools"
2015-10-12 18:54:46 +00:00
"github.com/docker/docker/pkg/jsonmessage"
2015-10-30 18:55:52 +00:00
"github.com/docker/docker/pkg/mount"
2014-07-24 22:19:50 +00:00
"github.com/docker/docker/pkg/namesgenerator"
2015-07-30 22:28:11 +00:00
"github.com/docker/docker/pkg/nat"
2015-09-23 18:51:43 +00:00
"github.com/docker/docker/pkg/parsers/filters"
2015-08-25 01:42:58 +00:00
"github.com/docker/docker/pkg/signal"
2015-03-24 11:25:26 +00:00
"github.com/docker/docker/pkg/stringid"
2015-08-28 15:29:10 +00:00
"github.com/docker/docker/pkg/stringutils"
2014-07-24 22:19:50 +00:00
"github.com/docker/docker/pkg/sysinfo"
2015-05-15 23:34:26 +00:00
"github.com/docker/docker/pkg/system"
2014-07-24 22:19:50 +00:00
"github.com/docker/docker/pkg/truncindex"
2015-03-31 23:21:37 +00:00
"github.com/docker/docker/registry"
2014-07-24 22:19:50 +00:00
"github.com/docker/docker/runconfig"
2015-11-18 22:20:54 +00:00
"github.com/docker/docker/tag"
2015-10-16 15:54:05 +00:00
"github.com/docker/docker/utils"
2015-09-16 21:18:24 +00:00
volumedrivers "github.com/docker/docker/volume/drivers"
"github.com/docker/docker/volume/local"
2015-09-18 23:58:05 +00:00
"github.com/docker/docker/volume/store"
2015-05-15 23:34:26 +00:00
"github.com/docker/libnetwork"
2015-11-03 19:06:16 +00:00
lntypes "github.com/docker/libnetwork/types"
2015-11-18 22:20:54 +00:00
"github.com/docker/libtrust"
2015-11-03 19:06:16 +00:00
"github.com/opencontainers/runc/libcontainer"
2013-01-19 00:13:39 +00:00
)
2013-12-12 21:34:26 +00:00
var (
2015-10-20 17:09:48 +00:00
validContainerNameChars = utils . RestrictedNameChars
validContainerNamePattern = utils . RestrictedNamePattern
2015-05-15 23:34:26 +00:00
2015-07-30 21:01:53 +00:00
errSystemNotSupported = errors . New ( "The Docker daemon is not supported on this platform." )
2013-12-12 21:34:26 +00:00
)
2013-09-07 00:33:05 +00:00
2015-11-18 22:20:54 +00:00
// ErrImageDoesNotExist is error returned when no image can be found for a reference.
type ErrImageDoesNotExist struct {
RefOrID string
}
func ( e ErrImageDoesNotExist ) Error ( ) string {
return fmt . Sprintf ( "no such id: %s" , e . RefOrID )
}
2014-05-30 08:55:25 +00:00
type contStore struct {
2015-11-12 19:55:17 +00:00
s map [ string ] * container . Container
2014-05-30 08:55:25 +00:00
sync . Mutex
}
2015-11-12 19:55:17 +00:00
func ( c * contStore ) Add ( id string , cont * container . Container ) {
2014-05-30 08:55:25 +00:00
c . Lock ( )
c . s [ id ] = cont
c . Unlock ( )
}
2015-11-12 19:55:17 +00:00
func ( c * contStore ) Get ( id string ) * container . Container {
2014-05-30 08:55:25 +00:00
c . Lock ( )
res := c . s [ id ]
c . Unlock ( )
return res
}
func ( c * contStore ) Delete ( id string ) {
c . Lock ( )
delete ( c . s , id )
c . Unlock ( )
}
2015-11-12 19:55:17 +00:00
func ( c * contStore ) List ( ) [ ] * container . Container {
2014-05-30 08:55:25 +00:00
containers := new ( History )
2014-06-05 06:49:40 +00:00
c . Lock ( )
2014-05-30 08:55:25 +00:00
for _ , cont := range c . s {
containers . Add ( cont )
}
2014-06-05 06:49:40 +00:00
c . Unlock ( )
2015-07-30 21:01:53 +00:00
containers . sort ( )
2014-05-30 08:55:25 +00:00
return * containers
}
2015-07-30 21:01:53 +00:00
// Daemon holds information about the Docker daemon.
2014-04-17 21:43:01 +00:00
type Daemon struct {
2015-11-18 22:20:54 +00:00
ID string
repository string
containers * contStore
execCommands * exec . Store
tagStore tag . Store
distributionPool * distribution . Pool
distributionMetadataStore dmetadata . Store
trustKey libtrust . PrivateKey
idIndex * truncindex . TruncIndex
configStore * Config
containerGraphDB * graphdb . Database
driver graphdriver . Driver
execDriver execdriver . Driver
statsCollector * statsCollector
defaultLogConfig runconfig . LogConfig
RegistryService * registry . Service
EventsService * events . Events
netController libnetwork . NetworkController
volumes * store . VolumeStore
discoveryWatcher discovery . Watcher
root string
shutdown bool
uidMaps [ ] idtools . IDMap
gidMaps [ ] idtools . IDMap
layerStore layer . Store
imageStore image . Store
2013-03-21 07:25:00 +00:00
}
2015-02-13 20:14:38 +00:00
// Get looks for a container using the provided information, which could be
// one of the following inputs from the caller:
// - A full container ID, which will exact match a container in daemon's list
// - A container name, which will only exact match via the GetByName() function
// - A partial container ID prefix (e.g. short ID) of any length that is
// unique enough to only return a single container object
// If none of these searches succeed, an error is returned
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) Get ( prefixOrName string ) ( * container . Container , error ) {
2015-02-13 20:14:38 +00:00
if containerByID := daemon . containers . Get ( prefixOrName ) ; containerByID != nil {
2014-12-16 23:06:35 +00:00
// prefix is an exact match to a full container ID
return containerByID , nil
2014-08-06 15:54:13 +00:00
}
2014-11-03 00:25:44 +00:00
2015-02-13 20:14:38 +00:00
// GetByName will match only an exact name provided; we ignore errors
2015-09-29 17:51:40 +00:00
if containerByName , _ := daemon . GetByName ( prefixOrName ) ; containerByName != nil {
2014-12-16 23:06:35 +00:00
// prefix is an exact match to a full container Name
return containerByName , nil
2013-10-05 02:25:15 +00:00
}
2014-11-03 00:25:44 +00:00
2015-07-30 21:01:53 +00:00
containerID , indexError := daemon . idIndex . Get ( prefixOrName )
2015-06-09 05:47:31 +00:00
if indexError != nil {
2015-07-21 20:30:32 +00:00
// When truncindex defines an error type, use that instead
2015-11-04 01:19:18 +00:00
if indexError == truncindex . ErrNotExist {
2015-07-21 20:30:32 +00:00
return nil , derr . ErrorCodeNoSuchContainer . WithArgs ( prefixOrName )
}
2015-06-09 05:47:31 +00:00
return nil , indexError
2014-11-03 00:25:44 +00:00
}
2015-07-30 21:01:53 +00:00
return daemon . containers . Get ( containerID ) , nil
2013-01-19 00:13:39 +00:00
}
2013-09-07 00:43:34 +00:00
// Exists returns a true if a container of the specified ID or name exists,
// false otherwise.
2015-09-29 17:51:40 +00:00
func ( daemon * Daemon ) Exists ( id string ) bool {
c , _ := daemon . Get ( id )
2014-12-16 23:06:35 +00:00
return c != nil
2013-01-19 00:13:39 +00:00
}
2015-10-29 01:00:09 +00:00
// IsPaused returns a bool indicating if the specified container is paused.
func ( daemon * Daemon ) IsPaused ( id string ) bool {
c , _ := daemon . Get ( id )
2015-11-12 19:55:17 +00:00
return c . State . IsPaused ( )
2015-10-29 01:00:09 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) containerRoot ( id string ) string {
2015-05-15 23:34:26 +00:00
return filepath . Join ( daemon . repository , id )
2013-03-21 07:25:00 +00:00
}
2013-10-05 02:25:15 +00:00
// Load reads the contents of a container from disk
2013-09-07 00:43:34 +00:00
// This is typically done at startup.
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) load ( id string ) ( * container . Container , error ) {
2015-07-16 21:14:58 +00:00
container := daemon . newBaseContainer ( id )
2015-04-29 22:53:35 +00:00
2015-11-12 19:55:17 +00:00
if err := container . FromDisk ( ) ; err != nil {
2013-03-21 07:25:00 +00:00
return nil , err
}
2014-08-06 17:40:43 +00:00
2013-06-04 18:00:22 +00:00
if container . ID != id {
2015-10-27 16:05:25 +00:00
return container , fmt . Errorf ( "Container %s is stored at %s" , container . ID , id )
2013-03-21 07:25:00 +00:00
}
2014-08-06 17:40:43 +00:00
2015-10-27 16:05:25 +00:00
return container , nil
2013-01-19 00:13:39 +00:00
}
2014-04-17 21:43:01 +00:00
// Register makes a container object usable by the daemon as <container.ID>
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) Register ( container * container . Container ) error {
2015-11-03 19:25:22 +00:00
if daemon . Exists ( container . ID ) {
2013-03-21 07:25:00 +00:00
return fmt . Errorf ( "Container is already loaded" )
}
2013-06-04 18:00:22 +00:00
if err := validateID ( container . ID ) ; err != nil {
2013-03-21 07:25:00 +00:00
return err
}
2014-04-17 21:43:01 +00:00
if err := daemon . ensureName ( container ) ; err != nil {
2013-11-04 17:28:40 +00:00
return err
}
2013-04-01 00:40:39 +00:00
2013-03-21 07:25:00 +00:00
// Attach to stdout and stderr
if container . Config . OpenStdin {
2015-11-18 00:21:44 +00:00
container . NewInputPipes ( )
2013-03-21 07:25:00 +00:00
} else {
2015-11-18 00:21:44 +00:00
container . NewNopInputPipe ( )
2013-03-21 07:25:00 +00:00
}
2014-05-30 08:55:25 +00:00
daemon . containers . Add ( container . ID , container )
2014-05-14 14:58:37 +00:00
// don't update the Suffixarray if we're starting up
// we'll waste time if we update it for every container
2014-06-24 22:24:02 +00:00
daemon . idIndex . Add ( container . ID )
2013-04-19 19:08:43 +00:00
2014-08-31 15:20:35 +00:00
if container . IsRunning ( ) {
2015-03-26 22:22:04 +00:00
logrus . Debugf ( "killing old running container %s" , container . ID )
2015-06-12 08:20:23 +00:00
// Set exit code to 128 + SIGKILL (9) to properly represent unsuccessful exit
2015-11-12 19:55:17 +00:00
container . SetStoppedLocking ( & execdriver . ExitStatus { ExitCode : 137 } )
2015-05-04 17:49:28 +00:00
// use the current driver and ensure that the container is dead x.x
cmd := & execdriver . Command {
2015-10-05 21:27:39 +00:00
CommonCommand : execdriver . CommonCommand {
ID : container . ID ,
} ,
2014-04-18 03:42:57 +00:00
}
2015-05-04 17:49:28 +00:00
daemon . execDriver . Terminate ( cmd )
2014-07-22 02:59:44 +00:00
2015-11-12 19:55:17 +00:00
container . UnmountIpcMounts ( mount . Unmount )
2015-10-30 23:00:01 +00:00
2015-11-18 22:20:54 +00:00
daemon . Unmount ( container )
2015-11-12 19:55:17 +00:00
if err := container . ToDiskLocking ( ) ; err != nil {
2015-07-02 10:24:35 +00:00
logrus . Errorf ( "Error saving stopped state to disk: %v" , err )
2014-03-06 22:14:25 +00:00
}
2013-04-19 19:08:43 +00:00
}
2015-04-16 00:39:34 +00:00
2015-11-03 16:42:08 +00:00
if err := daemon . prepareMountPoints ( container ) ; err != nil {
2015-08-21 03:29:53 +00:00
return err
}
2013-03-21 07:25:00 +00:00
return nil
}
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) ensureName ( container * container . Container ) error {
2013-11-04 17:28:40 +00:00
if container . Name == "" {
2014-05-24 00:51:16 +00:00
name , err := daemon . generateNewName ( container . ID )
2013-11-04 17:28:40 +00:00
if err != nil {
2014-05-24 00:51:16 +00:00
return err
2013-11-04 17:28:40 +00:00
}
container . Name = name
2015-11-12 19:55:17 +00:00
if err := container . ToDiskLocking ( ) ; err != nil {
2015-07-02 10:24:35 +00:00
logrus . Errorf ( "Error saving container name to disk: %v" , err )
2013-11-04 17:28:40 +00:00
}
}
return nil
}
2015-09-29 17:51:40 +00:00
func ( daemon * Daemon ) restore ( ) error {
2015-05-19 20:05:25 +00:00
type cr struct {
2015-11-12 19:55:17 +00:00
container * container . Container
2015-05-19 20:05:25 +00:00
registered bool
}
2014-06-06 00:31:58 +00:00
var (
2015-08-01 13:08:04 +00:00
debug = os . Getenv ( "DEBUG" ) != ""
2014-08-06 17:40:43 +00:00
currentDriver = daemon . driver . String ( )
2015-05-19 20:05:25 +00:00
containers = make ( map [ string ] * cr )
2014-06-06 00:31:58 +00:00
)
2014-05-30 18:03:56 +00:00
if ! debug {
2015-03-26 22:22:04 +00:00
logrus . Info ( "Loading containers: start." )
2013-08-16 13:31:50 +00:00
}
2014-04-17 21:43:01 +00:00
dir , err := ioutil . ReadDir ( daemon . repository )
2013-01-19 00:13:39 +00:00
if err != nil {
return err
}
2013-10-24 23:49:28 +00:00
2013-12-18 18:43:42 +00:00
for _ , v := range dir {
2013-03-21 07:25:00 +00:00
id := v . Name ( )
2014-04-17 21:43:01 +00:00
container , err := daemon . load ( id )
2015-03-26 22:22:04 +00:00
if ! debug && logrus . GetLevel ( ) == logrus . InfoLevel {
2013-12-18 18:43:42 +00:00
fmt . Print ( "." )
2013-08-16 13:31:50 +00:00
}
2013-01-19 00:13:39 +00:00
if err != nil {
2015-03-26 22:22:04 +00:00
logrus . Errorf ( "Failed to load container %v: %v" , id , err )
2013-01-19 00:13:39 +00:00
continue
}
2013-11-15 06:52:08 +00:00
// Ignore the container if it does not support the current driver being used by the graph
2014-08-06 17:40:43 +00:00
if ( container . Driver == "" && currentDriver == "aufs" ) || container . Driver == currentDriver {
2015-03-26 22:22:04 +00:00
logrus . Debugf ( "Loaded container %v" , container . ID )
2014-08-06 17:40:43 +00:00
2015-05-19 20:05:25 +00:00
containers [ container . ID ] = & cr { container : container }
2013-11-15 06:52:08 +00:00
} else {
2015-03-26 22:22:04 +00:00
logrus . Debugf ( "Cannot load container %s because it was created with another graph driver." , container . ID )
2013-11-15 06:52:08 +00:00
}
2013-10-05 02:25:15 +00:00
}
2015-07-30 21:01:53 +00:00
if entities := daemon . containerGraphDB . List ( "/" , - 1 ) ; entities != nil {
2013-10-24 23:49:28 +00:00
for _ , p := range entities . Paths ( ) {
2015-03-26 22:22:04 +00:00
if ! debug && logrus . GetLevel ( ) == logrus . InfoLevel {
2013-12-18 18:43:42 +00:00
fmt . Print ( "." )
}
2014-08-06 17:40:43 +00:00
2013-10-24 23:49:28 +00:00
e := entities [ p ]
2014-08-06 17:40:43 +00:00
2015-05-19 20:05:25 +00:00
if c , ok := containers [ e . ID ( ) ] ; ok {
c . registered = true
2013-10-24 23:49:28 +00:00
}
2013-10-05 02:25:15 +00:00
}
2013-10-24 23:49:28 +00:00
}
2013-10-24 17:25:07 +00:00
2015-05-19 20:05:25 +00:00
group := sync . WaitGroup { }
for _ , c := range containers {
group . Add ( 1 )
2014-08-06 17:40:43 +00:00
2015-11-12 19:55:17 +00:00
go func ( container * container . Container , registered bool ) {
2015-05-19 20:05:25 +00:00
defer group . Done ( )
2014-08-06 17:40:43 +00:00
2015-05-19 20:05:25 +00:00
if ! registered {
// Try to set the default name for a container if it exists prior to links
container . Name , err = daemon . generateNewName ( container . ID )
if err != nil {
logrus . Debugf ( "Setting default id - %s" , err )
}
}
2013-10-24 23:49:28 +00:00
2015-09-29 17:51:40 +00:00
if err := daemon . Register ( container ) ; err != nil {
2015-09-14 02:52:56 +00:00
logrus . Errorf ( "Failed to register container %s: %s" , container . ID , err )
// The container register failed should not be started.
return
2015-05-19 20:05:25 +00:00
}
2014-08-06 17:40:43 +00:00
2015-05-19 20:05:25 +00:00
// check the restart policy on the containers and restart any container with
// the restart policy of "always"
2015-11-12 19:55:17 +00:00
if daemon . configStore . AutoRestart && container . ShouldRestart ( ) {
2015-03-26 22:22:04 +00:00
logrus . Debugf ( "Starting container %s" , container . ID )
2014-08-06 17:40:43 +00:00
2015-11-03 01:06:09 +00:00
if err := daemon . containerStart ( container ) ; err != nil {
2015-09-14 02:52:56 +00:00
logrus . Errorf ( "Failed to start container %s: %s" , container . ID , err )
2014-08-06 17:40:43 +00:00
}
}
2015-05-19 20:05:25 +00:00
} ( c . container , c . registered )
2014-06-06 00:31:58 +00:00
}
2015-05-19 20:05:25 +00:00
group . Wait ( )
2014-06-06 00:31:58 +00:00
2014-05-30 18:03:56 +00:00
if ! debug {
2015-03-26 22:22:04 +00:00
if logrus . GetLevel ( ) == logrus . InfoLevel {
2015-03-18 00:27:53 +00:00
fmt . Println ( )
}
2015-03-26 22:22:04 +00:00
logrus . Info ( "Loading containers: done." )
2013-08-16 13:31:50 +00:00
}
2013-10-05 02:25:15 +00:00
2013-01-19 00:13:39 +00:00
return nil
}
2015-07-20 17:57:15 +00:00
func ( daemon * Daemon ) mergeAndVerifyConfig ( config * runconfig . Config , img * image . Image ) error {
2014-10-28 21:06:23 +00:00
if img != nil && img . Config != nil {
2014-02-12 04:04:39 +00:00
if err := runconfig . Merge ( config , img . Config ) ; err != nil {
2015-05-24 13:17:29 +00:00
return err
2013-10-30 18:13:10 +00:00
}
}
2015-04-11 00:05:21 +00:00
if config . Entrypoint . Len ( ) == 0 && config . Cmd . Len ( ) == 0 {
2015-05-24 13:17:29 +00:00
return fmt . Errorf ( "No command specified" )
2013-09-07 00:33:05 +00:00
}
2015-05-24 13:17:29 +00:00
return nil
2014-04-07 19:20:23 +00:00
}
2013-09-07 00:33:05 +00:00
2015-09-29 17:51:40 +00:00
func ( daemon * Daemon ) generateIDAndName ( name string ) ( string , string , error ) {
2014-04-07 19:20:23 +00:00
var (
err error
2015-07-29 00:19:17 +00:00
id = stringid . GenerateNonCryptoID ( )
2014-04-07 19:20:23 +00:00
)
2013-10-05 02:25:15 +00:00
2013-10-28 23:58:59 +00:00
if name == "" {
2014-05-24 00:51:16 +00:00
if name , err = daemon . generateNewName ( id ) ; err != nil {
return "" , "" , err
2013-12-12 21:34:26 +00:00
}
2014-05-24 00:51:16 +00:00
return id , name , nil
}
2015-09-29 17:51:40 +00:00
if name , err = daemon . reserveName ( id , name ) ; err != nil {
2014-05-24 00:51:16 +00:00
return "" , "" , err
}
return id , name , nil
}
2015-09-29 17:51:40 +00:00
func ( daemon * Daemon ) reserveName ( id , name string ) ( string , error ) {
2014-05-24 00:51:16 +00:00
if ! validContainerNamePattern . MatchString ( name ) {
return "" , fmt . Errorf ( "Invalid container name (%s), only %s are allowed" , name , validContainerNameChars )
2013-10-28 23:58:59 +00:00
}
2014-05-24 00:51:16 +00:00
2013-10-28 23:58:59 +00:00
if name [ 0 ] != '/' {
name = "/" + name
}
2014-05-24 00:51:16 +00:00
2015-07-30 21:01:53 +00:00
if _ , err := daemon . containerGraphDB . Set ( name , id ) ; err != nil {
2014-02-18 10:41:11 +00:00
if ! graphdb . IsNonUniqueNameError ( err ) {
2014-05-24 00:51:16 +00:00
return "" , err
2013-12-05 23:22:21 +00:00
}
2015-09-29 17:51:40 +00:00
conflictingContainer , err := daemon . GetByName ( name )
2013-12-05 23:22:21 +00:00
if err != nil {
2015-10-26 23:57:50 +00:00
return "" , err
2013-10-30 18:24:50 +00:00
}
2015-10-26 23:57:50 +00:00
return "" , fmt . Errorf (
"Conflict. The name %q is already in use by container %s. You have to remove (or rename) that container to be able to reuse that name." , strings . TrimPrefix ( name , "/" ) ,
stringid . TruncateID ( conflictingContainer . ID ) )
2013-10-05 02:25:15 +00:00
}
2014-05-24 00:51:16 +00:00
return name , nil
}
func ( daemon * Daemon ) generateNewName ( id string ) ( string , error ) {
var name string
2014-05-30 19:08:21 +00:00
for i := 0 ; i < 6 ; i ++ {
2014-05-24 00:51:16 +00:00
name = namesgenerator . GetRandomName ( i )
if name [ 0 ] != '/' {
name = "/" + name
}
2015-07-30 21:01:53 +00:00
if _ , err := daemon . containerGraphDB . Set ( name , id ) ; err != nil {
2014-05-24 00:51:16 +00:00
if ! graphdb . IsNonUniqueNameError ( err ) {
return "" , err
}
continue
}
return name , nil
}
2015-03-24 11:25:26 +00:00
name = "/" + stringid . TruncateID ( id )
2015-07-30 21:01:53 +00:00
if _ , err := daemon . containerGraphDB . Set ( name , id ) ; err != nil {
2014-05-24 00:51:16 +00:00
return "" , err
}
return name , nil
2014-04-07 19:20:23 +00:00
}
2013-10-05 02:25:15 +00:00
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) generateHostname ( id string , config * runconfig . Config ) {
2013-09-07 00:33:05 +00:00
// Generate default hostname
if config . Hostname == "" {
config . Hostname = id [ : 12 ]
}
2014-04-07 19:20:23 +00:00
}
2013-09-07 00:33:05 +00:00
2015-08-28 15:29:10 +00:00
func ( daemon * Daemon ) getEntrypointAndArgs ( configEntrypoint * stringutils . StrSlice , configCmd * stringutils . StrSlice ) ( string , [ ] string ) {
2015-04-11 00:05:21 +00:00
cmdSlice := configCmd . Slice ( )
if configEntrypoint . Len ( ) != 0 {
eSlice := configEntrypoint . Slice ( )
2015-10-27 16:36:08 +00:00
return eSlice [ 0 ] , append ( eSlice [ 1 : ] , cmdSlice ... )
2013-09-07 00:33:05 +00:00
}
2015-10-27 16:36:08 +00:00
return cmdSlice [ 0 ] , cmdSlice [ 1 : ]
2014-04-07 19:20:23 +00:00
}
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) newContainer ( name string , config * runconfig . Config , imgID image . ID ) ( * container . Container , error ) {
2014-09-30 19:10:03 +00:00
var (
2015-10-21 16:08:19 +00:00
id string
err error
noExplicitName = name == ""
2014-04-07 19:20:23 +00:00
)
2015-09-29 17:51:40 +00:00
id , name , err = daemon . generateIDAndName ( name )
2014-04-07 19:20:23 +00:00
if err != nil {
return nil , err
}
2014-04-17 21:43:01 +00:00
daemon . generateHostname ( id , config )
2014-09-09 04:19:32 +00:00
entrypoint , args := daemon . getEntrypointAndArgs ( config . Entrypoint , config . Cmd )
2013-09-07 00:33:05 +00:00
2015-06-03 16:26:41 +00:00
base := daemon . newBaseContainer ( id )
base . Created = time . Now ( ) . UTC ( )
base . Path = entrypoint
base . Args = args //FIXME: de-duplicate from config
base . Config = config
2015-11-12 19:55:17 +00:00
base . HostConfig = & runconfig . HostConfig { }
2015-06-03 16:26:41 +00:00
base . ImageID = imgID
2015-10-21 16:08:19 +00:00
base . NetworkSettings = & network . Settings { IsAnonymousEndpoint : noExplicitName }
2015-06-03 16:26:41 +00:00
base . Name = name
base . Driver = daemon . driver . String ( )
2015-10-27 16:05:25 +00:00
return base , err
2014-04-07 19:20:23 +00:00
}
2015-07-30 21:01:53 +00:00
// GetFullContainerName returns a constructed container name. I think
2015-09-07 06:43:17 +00:00
// it has to do with the fact that a container is a file on disk and
2015-07-30 21:01:53 +00:00
// this is sort of just creating a file name.
2014-03-08 02:42:29 +00:00
func GetFullContainerName ( name string ) ( string , error ) {
2013-11-04 17:28:40 +00:00
if name == "" {
return "" , fmt . Errorf ( "Container name cannot be empty" )
}
2013-10-24 23:49:28 +00:00
if name [ 0 ] != '/' {
name = "/" + name
}
2013-11-04 17:28:40 +00:00
return name , nil
2013-10-24 23:49:28 +00:00
}
2015-07-30 21:01:53 +00:00
// GetByName returns a container given a name.
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) GetByName ( name string ) ( * container . Container , error ) {
2014-03-08 02:42:29 +00:00
fullName , err := GetFullContainerName ( name )
2013-11-04 17:28:40 +00:00
if err != nil {
return nil , err
}
2015-07-30 21:01:53 +00:00
entity := daemon . containerGraphDB . Get ( fullName )
2013-10-05 02:25:15 +00:00
if entity == nil {
return nil , fmt . Errorf ( "Could not find entity for %s" , name )
}
2014-05-30 08:55:25 +00:00
e := daemon . containers . Get ( entity . ID ( ) )
2013-10-05 02:25:15 +00:00
if e == nil {
return nil , fmt . Errorf ( "Could not find container for entity id %s" , entity . ID ( ) )
}
2014-05-30 08:55:25 +00:00
return e , nil
2013-10-05 02:25:15 +00:00
}
2015-11-26 02:03:10 +00:00
// getEventFilter returns a filters.Filter for a set of filters
func ( daemon * Daemon ) getEventFilter ( filter filters . Args ) * events . Filter {
2015-09-23 18:51:43 +00:00
// incoming container filter can be name, id or partial id, convert to
// a full container id
2015-11-26 01:27:11 +00:00
for _ , cn := range filter . Get ( "container" ) {
2015-09-23 18:51:43 +00:00
c , err := daemon . Get ( cn )
2015-11-26 01:27:11 +00:00
filter . Del ( "container" , cn )
if err == nil {
filter . Add ( "container" , c . ID )
2015-09-23 18:51:43 +00:00
}
}
return events . NewFilter ( filter , daemon . GetLabels )
}
2015-10-12 18:54:46 +00:00
// SubscribeToEvents returns the currently record of events, a channel to stream new events from, and a function to cancel the stream of events.
2015-11-26 02:03:10 +00:00
func ( daemon * Daemon ) SubscribeToEvents ( since , sinceNano int64 , filter filters . Args ) ( [ ] * jsonmessage . JSONMessage , chan interface { } ) {
ef := daemon . getEventFilter ( filter )
return daemon . EventsService . SubscribeTopic ( since , sinceNano , ef )
}
// UnsubscribeFromEvents stops the event subscription for a client by closing the
// channel where the daemon sends events to.
func ( daemon * Daemon ) UnsubscribeFromEvents ( listener chan interface { } ) {
daemon . EventsService . Evict ( listener )
2015-10-12 18:54:46 +00:00
}
2015-09-23 18:51:43 +00:00
// GetLabels for a container or image id
func ( daemon * Daemon ) GetLabels ( id string ) map [ string ] string {
// TODO: TestCase
container := daemon . containers . Get ( id )
if container != nil {
return container . Config . Labels
}
2015-11-18 22:20:54 +00:00
img , err := daemon . GetImage ( id )
2015-09-23 18:51:43 +00:00
if err == nil {
return img . ContainerConfig . Labels
}
return nil
}
2015-07-30 21:01:53 +00:00
// children returns all child containers of the container with the
// given name. The containers are returned as a map from the container
// name to a pointer to Container.
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) children ( name string ) ( map [ string ] * container . Container , error ) {
2014-03-08 02:42:29 +00:00
name , err := GetFullContainerName ( name )
2013-11-04 17:28:40 +00:00
if err != nil {
return nil , err
}
2015-11-12 19:55:17 +00:00
children := make ( map [ string ] * container . Container )
2013-10-05 02:25:15 +00:00
2015-07-30 21:01:53 +00:00
err = daemon . containerGraphDB . Walk ( name , func ( p string , e * graphdb . Entity ) error {
2015-09-29 17:51:40 +00:00
c , err := daemon . Get ( e . ID ( ) )
2014-12-16 23:06:35 +00:00
if err != nil {
return err
2013-10-05 02:25:15 +00:00
}
children [ p ] = c
return nil
} , 0 )
if err != nil {
return nil , err
}
return children , nil
}
2015-07-30 21:01:53 +00:00
// parents returns the names of the parent containers of the container
// with the given name.
func ( daemon * Daemon ) parents ( name string ) ( [ ] string , error ) {
2014-07-14 23:19:37 +00:00
name , err := GetFullContainerName ( name )
if err != nil {
return nil , err
}
2015-07-30 21:01:53 +00:00
return daemon . containerGraphDB . Parents ( name )
2014-07-14 23:19:37 +00:00
}
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) registerLink ( parent , child * container . Container , alias string ) error {
2015-05-15 23:34:26 +00:00
fullName := filepath . Join ( parent . Name , alias )
2015-07-30 21:01:53 +00:00
if ! daemon . containerGraphDB . Exists ( fullName ) {
_ , err := daemon . containerGraphDB . Set ( fullName , child . ID )
2013-10-05 02:25:15 +00:00
return err
}
2013-10-28 23:58:59 +00:00
return nil
2013-10-05 02:25:15 +00:00
}
2015-07-30 21:01:53 +00:00
// NewDaemon sets up everything for the daemon to be able to service
// requests from the webserver.
2015-09-29 17:51:40 +00:00
func NewDaemon ( config * Config , registryService * registry . Service ) ( daemon * Daemon , err error ) {
2015-06-15 23:33:02 +00:00
setDefaultMtu ( config )
2015-05-15 23:34:26 +00:00
// Ensure we have compatible configuration options
if err := checkConfigOptions ( config ) ; err != nil {
return nil , err
2014-09-17 03:00:15 +00:00
}
2015-05-15 23:34:26 +00:00
// Do we have a disabled network?
2015-06-30 17:34:15 +00:00
config . DisableBridge = isBridgeNetworkDisabled ( config )
2014-08-10 01:18:32 +00:00
2015-07-11 19:32:08 +00:00
// Verify the platform is supported as a daemon
2015-08-07 16:33:29 +00:00
if ! platformSupported {
2015-07-30 21:01:53 +00:00
return nil , errSystemNotSupported
2015-07-11 19:32:08 +00:00
}
// Validate platform-specific requirements
2015-05-15 23:34:26 +00:00
if err := checkSystem ( ) ; err != nil {
2014-09-16 17:42:59 +00:00
return nil , err
2014-07-30 06:51:43 +00:00
}
2015-07-07 01:58:53 +00:00
// set up SIGUSR1 handler on Unix-like systems, or a Win32 global event
// on Windows to dump Go routine stacks
setupDumpStackTrap ( )
2015-04-21 04:24:24 +00:00
2015-10-08 15:51:41 +00:00
uidMaps , gidMaps , err := setupRemappedRoot ( config )
if err != nil {
return nil , err
}
rootUID , rootGID , err := idtools . GetRootUIDGID ( uidMaps , gidMaps )
if err != nil {
return nil , err
}
2014-07-30 06:51:03 +00:00
// get the canonical path to the Docker root directory
var realRoot string
if _ , err := os . Stat ( config . Root ) ; err != nil && os . IsNotExist ( err ) {
realRoot = config . Root
} else {
2015-03-29 21:17:23 +00:00
realRoot , err = fileutils . ReadSymlinkedDirectory ( config . Root )
2014-07-30 06:51:03 +00:00
if err != nil {
2014-09-16 17:42:59 +00:00
return nil , fmt . Errorf ( "Unable to get the full path to root (%s): %s" , config . Root , err )
2014-07-30 06:51:03 +00:00
}
}
2015-10-08 15:51:41 +00:00
if err = setupDaemonRoot ( config , realRoot , rootUID , rootGID ) ; err != nil {
2014-05-10 01:05:54 +00:00
return nil , err
}
2015-06-23 12:53:18 +00:00
// set up the tmpDir to use a canonical path
2015-10-08 15:51:41 +00:00
tmp , err := tempDir ( config . Root , rootUID , rootGID )
2015-06-23 12:53:18 +00:00
if err != nil {
return nil , fmt . Errorf ( "Unable to get the TempDir under %s: %s" , config . Root , err )
}
realTmp , err := fileutils . ReadSymlinkedDirectory ( tmp )
if err != nil {
return nil , fmt . Errorf ( "Unable to get the full path to the TempDir (%s): %s" , tmp , err )
}
os . Setenv ( "TMPDIR" , realTmp )
2013-11-15 07:02:09 +00:00
// Set the default driver
graphdriver . DefaultDriver = config . GraphDriver
2013-11-07 20:34:01 +00:00
// Load storage driver
2015-10-08 15:51:41 +00:00
driver , err := graphdriver . New ( config . Root , config . GraphOptions , uidMaps , gidMaps )
2013-11-07 20:34:01 +00:00
if err != nil {
2015-04-27 20:33:30 +00:00
return nil , fmt . Errorf ( "error initializing graphdriver: %v" , err )
2013-11-07 20:34:01 +00:00
}
2015-03-26 22:22:04 +00:00
logrus . Debugf ( "Using graph driver %s" , driver )
2015-04-27 21:11:29 +00:00
d := & Daemon { }
d . driver = driver
2015-05-15 23:34:26 +00:00
// Ensure the graph driver is shutdown at a later point
2015-04-27 21:11:29 +00:00
defer func ( ) {
if err != nil {
2015-09-29 17:51:40 +00:00
if err := d . Shutdown ( ) ; err != nil {
2015-04-27 21:11:29 +00:00
logrus . Error ( err )
}
2015-03-11 14:33:06 +00:00
}
2015-04-27 21:11:29 +00:00
} ( )
2013-11-07 20:34:01 +00:00
2015-04-09 04:23:30 +00:00
// Verify logging driver type
if config . LogConfig . Type != "none" {
if _ , err := logger . GetLogDriver ( config . LogConfig . Type ) ; err != nil {
return nil , fmt . Errorf ( "error finding the logging driver: %v" , err )
}
}
logrus . Debugf ( "Using default logging driver %s" , config . LogConfig . Type )
2015-05-15 23:34:26 +00:00
// Configure and validate the kernels security support
if err := configureKernelSecuritySupport ( config , d . driver . String ( ) ) ; err != nil {
return nil , err
2014-06-04 20:38:06 +00:00
}
2015-05-15 23:34:26 +00:00
daemonRepo := filepath . Join ( config . Root , "containers" )
2013-03-14 01:48:50 +00:00
2015-10-08 15:51:41 +00:00
if err := idtools . MkdirAllAs ( daemonRepo , 0700 , rootUID , rootGID ) ; err != nil && ! os . IsExist ( err ) {
2013-03-14 01:48:50 +00:00
return nil , err
}
2014-03-14 18:23:54 +00:00
// Migrate the container if it is aufs and aufs is enabled
2015-05-15 23:34:26 +00:00
if err := migrateIfDownlevel ( d . driver , config . Root ) ; err != nil {
2014-03-14 18:23:54 +00:00
return nil , err
2013-11-16 01:16:30 +00:00
}
2015-11-18 22:20:54 +00:00
imageRoot := filepath . Join ( config . Root , "image" , d . driver . String ( ) )
fms , err := layer . NewFSMetadataStore ( filepath . Join ( imageRoot , "layerdb" ) )
if err != nil {
return nil , err
}
d . layerStore , err = layer . NewStore ( fms , d . driver )
if err != nil {
return nil , err
}
distributionPool := distribution . NewPool ( )
ifs , err := image . NewFSStoreBackend ( filepath . Join ( imageRoot , "imagedb" ) )
if err != nil {
return nil , err
}
d . imageStore , err = image . NewImageStore ( ifs , d . layerStore )
2013-02-27 01:45:46 +00:00
if err != nil {
return nil , err
}
2013-11-15 10:30:28 +00:00
2015-05-15 23:34:26 +00:00
// Configure the volumes driver
2015-10-08 15:51:41 +00:00
volStore , err := configureVolumes ( config , rootUID , rootGID )
2015-06-12 13:25:32 +00:00
if err != nil {
2013-04-06 01:00:10 +00:00
return nil , err
}
2014-08-28 14:18:08 +00:00
2015-01-07 22:59:12 +00:00
trustKey , err := api . LoadOrCreateTrustKey ( config . TrustKeyPath )
if err != nil {
return nil , err
}
2015-05-15 23:34:26 +00:00
trustDir := filepath . Join ( config . Root , "trust" )
Simplify and fix os.MkdirAll() usage
TL;DR: check for IsExist(err) after a failed MkdirAll() is both
redundant and wrong -- so two reasons to remove it.
Quoting MkdirAll documentation:
> MkdirAll creates a directory named path, along with any necessary
> parents, and returns nil, or else returns an error. If path
> is already a directory, MkdirAll does nothing and returns nil.
This means two things:
1. If a directory to be created already exists, no error is returned.
2. If the error returned is IsExist (EEXIST), it means there exists
a non-directory with the same name as MkdirAll need to use for
directory. Example: we want to MkdirAll("a/b"), but file "a"
(or "a/b") already exists, so MkdirAll fails.
The above is a theory, based on quoted documentation and my UNIX
knowledge.
3. In practice, though, current MkdirAll implementation [1] returns
ENOTDIR in most of cases described in #2, with the exception when
there is a race between MkdirAll and someone else creating the
last component of MkdirAll argument as a file. In this very case
MkdirAll() will indeed return EEXIST.
Because of #1, IsExist check after MkdirAll is not needed.
Because of #2 and #3, ignoring IsExist error is just plain wrong,
as directory we require is not created. It's cleaner to report
the error now.
Note this error is all over the tree, I guess due to copy-paste,
or trying to follow the same usage pattern as for Mkdir(),
or some not quite correct examples on the Internet.
[v2: a separate aufs commit is merged into this one]
[1] https://github.com/golang/go/blob/f9ed2f75/src/os/path.go
Signed-off-by: Kir Kolyshkin <kir@openvz.org>
2015-07-29 23:49:05 +00:00
if err := system . MkdirAll ( trustDir , 0700 ) ; err != nil {
2014-10-02 01:26:06 +00:00
return nil , err
}
2015-11-18 22:20:54 +00:00
distributionMetadataStore , err := dmetadata . NewFSMetadataStore ( filepath . Join ( imageRoot , "distribution" ) )
if err != nil {
return nil , err
}
2015-04-20 19:48:33 +00:00
eventsService := events . New ( )
2015-11-18 22:20:54 +00:00
tagStore , err := tag . NewTagStore ( filepath . Join ( imageRoot , "repositories.json" ) )
2015-04-20 19:48:33 +00:00
if err != nil {
2015-11-18 22:20:54 +00:00
return nil , fmt . Errorf ( "Couldn't create Tag store repositories: %s" , err )
2015-04-20 19:48:33 +00:00
}
2015-11-18 22:20:54 +00:00
if err := restoreCustomImage ( d . driver , d . imageStore , d . layerStore , tagStore ) ; err != nil {
return nil , fmt . Errorf ( "Couldn't restore custom images: %s" , err )
}
if err := v1 . Migrate ( config . Root , d . driver . String ( ) , d . layerStore , d . imageStore , tagStore , distributionMetadataStore ) ; err != nil {
return nil , err
2015-07-25 00:49:43 +00:00
}
2015-09-21 12:04:36 +00:00
// Discovery is only enabled when the daemon is launched with an address to advertise. When
// initialized, the daemon is registered and we can store the discovery backend as its read-only
// DiscoveryWatcher version.
if config . ClusterStore != "" && config . ClusterAdvertise != "" {
2015-10-26 00:12:22 +00:00
advertise , err := discovery . ParseAdvertise ( config . ClusterStore , config . ClusterAdvertise )
if err != nil {
return nil , fmt . Errorf ( "discovery advertise parsing failed (%v)" , err )
}
config . ClusterAdvertise = advertise
d . discoveryWatcher , err = initDiscovery ( config . ClusterStore , config . ClusterAdvertise , config . ClusterOpts )
if err != nil {
2015-09-21 12:04:36 +00:00
return nil , fmt . Errorf ( "discovery initialization failed (%v)" , err )
}
2015-10-26 00:12:22 +00:00
} else if config . ClusterAdvertise != "" {
return nil , fmt . Errorf ( "invalid cluster configuration. --cluster-advertise must be accompanied by --cluster-store configuration" )
2015-09-21 12:04:36 +00:00
}
d . netController , err = d . initNetworkController ( config )
2015-06-30 17:34:15 +00:00
if err != nil {
return nil , fmt . Errorf ( "Error initializing network controller: %v" , err )
2013-04-04 12:33:28 +00:00
}
2013-10-05 02:25:15 +00:00
2015-05-15 23:34:26 +00:00
graphdbPath := filepath . Join ( config . Root , "linkgraph.db" )
2013-12-19 05:14:16 +00:00
graph , err := graphdb . NewSqliteConn ( graphdbPath )
2013-02-25 22:06:22 +00:00
if err != nil {
return nil , err
}
2015-04-27 21:11:29 +00:00
2015-07-30 21:01:53 +00:00
d . containerGraphDB = graph
2013-10-05 02:25:15 +00:00
2014-03-05 09:40:55 +00:00
sysInfo := sysinfo . New ( false )
2015-06-19 22:29:47 +00:00
// Check if Devices cgroup is mounted, it is hard requirement for container security,
// on Linux/FreeBSD.
if runtime . GOOS != "windows" && ! sysInfo . CgroupDevicesEnabled {
2015-06-17 02:36:20 +00:00
return nil , fmt . Errorf ( "Devices cgroup isn't mounted" )
}
2015-11-30 09:04:13 +00:00
ed , err := execdrivers . NewDriver ( config . ExecOptions , config . ExecRoot , config . Root , sysInfo )
2014-01-10 00:03:22 +00:00
if err != nil {
return nil , err
}
2015-04-27 21:11:29 +00:00
d . ID = trustKey . PublicKey ( ) . KeyID ( )
d . repository = daemonRepo
2015-11-12 19:55:17 +00:00
d . containers = & contStore { s : make ( map [ string ] * container . Container ) }
2015-11-20 22:35:16 +00:00
d . execCommands = exec . NewStore ( )
2015-11-18 22:20:54 +00:00
d . tagStore = tagStore
d . distributionPool = distributionPool
d . distributionMetadataStore = distributionMetadataStore
d . trustKey = trustKey
2015-04-27 21:11:29 +00:00
d . idIndex = truncindex . NewTruncIndex ( [ ] string { } )
2015-07-30 21:01:53 +00:00
d . configStore = config
2015-04-27 21:11:29 +00:00
d . execDriver = ed
2015-11-03 19:06:16 +00:00
d . statsCollector = d . newStatsCollector ( 1 * time . Second )
2015-04-27 21:11:29 +00:00
d . defaultLogConfig = config . LogConfig
d . RegistryService = registryService
d . EventsService = eventsService
2015-06-12 13:25:32 +00:00
d . volumes = volStore
2015-05-19 20:05:25 +00:00
d . root = config . Root
2015-10-08 15:51:41 +00:00
d . uidMaps = uidMaps
d . gidMaps = gidMaps
2015-04-27 21:11:29 +00:00
2015-08-26 12:00:01 +00:00
if err := d . cleanupMounts ( ) ; err != nil {
2015-03-06 20:44:31 +00:00
return nil , err
}
2015-07-08 18:13:47 +00:00
go d . execCommandGC ( )
2015-04-27 21:11:29 +00:00
2015-09-29 17:51:40 +00:00
if err := d . restore ( ) ; err != nil {
2015-03-06 20:44:31 +00:00
return nil , err
}
2015-05-06 22:39:29 +00:00
return d , nil
}
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) shutdownContainer ( c * container . Container ) error {
2015-10-29 22:11:35 +00:00
// TODO(windows): Handle docker restart with paused containers
2015-11-12 19:55:17 +00:00
if c . IsPaused ( ) {
2015-10-29 22:11:35 +00:00
// To terminate a process in freezer cgroup, we should send
// SIGTERM to this process then unfreeze it, and the process will
// force to terminate immediately.
logrus . Debugf ( "Found container %s is paused, sending SIGTERM before unpause it" , c . ID )
sig , ok := signal . SignalMap [ "TERM" ]
if ! ok {
return fmt . Errorf ( "System doesn not support SIGTERM" )
}
2015-11-02 23:39:39 +00:00
if err := daemon . kill ( c , int ( sig ) ) ; err != nil {
2015-10-29 22:11:35 +00:00
return fmt . Errorf ( "sending SIGTERM to container %s with error: %v" , c . ID , err )
}
2015-11-02 23:39:39 +00:00
if err := daemon . containerUnpause ( c ) ; err != nil {
2015-10-29 22:11:35 +00:00
return fmt . Errorf ( "Failed to unpause container %s with error: %v" , c . ID , err )
}
if _ , err := c . WaitStop ( 10 * time . Second ) ; err != nil {
logrus . Debugf ( "container %s failed to exit in 10 second of SIGTERM, sending SIGKILL to force" , c . ID )
sig , ok := signal . SignalMap [ "KILL" ]
if ! ok {
return fmt . Errorf ( "System does not support SIGKILL" )
}
2015-11-02 23:39:39 +00:00
if err := daemon . kill ( c , int ( sig ) ) ; err != nil {
2015-10-29 22:11:35 +00:00
logrus . Errorf ( "Failed to SIGKILL container %s" , c . ID )
}
c . WaitStop ( - 1 * time . Second )
return err
}
}
// If container failed to exit in 10 seconds of SIGTERM, then using the force
2015-11-02 23:25:26 +00:00
if err := daemon . containerStop ( c , 10 ) ; err != nil {
2015-10-29 22:11:35 +00:00
return fmt . Errorf ( "Stop container %s with error: %v" , c . ID , err )
}
c . WaitStop ( - 1 * time . Second )
return nil
}
2015-07-30 21:01:53 +00:00
// Shutdown stops the daemon.
2015-09-29 17:51:40 +00:00
func ( daemon * Daemon ) Shutdown ( ) error {
2015-08-05 21:09:08 +00:00
daemon . shutdown = true
2015-04-27 21:11:29 +00:00
if daemon . containers != nil {
group := sync . WaitGroup { }
logrus . Debug ( "starting clean shutdown of all containers..." )
2015-11-12 19:55:17 +00:00
for _ , cont := range daemon . List ( ) {
if ! cont . IsRunning ( ) {
2015-10-29 22:11:35 +00:00
continue
2015-04-27 21:11:29 +00:00
}
2015-11-12 19:55:17 +00:00
logrus . Debugf ( "stopping %s" , cont . ID )
2015-10-29 22:11:35 +00:00
group . Add ( 1 )
2015-11-12 19:55:17 +00:00
go func ( c * container . Container ) {
2015-10-29 22:11:35 +00:00
defer group . Done ( )
2015-11-02 23:25:26 +00:00
if err := daemon . shutdownContainer ( c ) ; err != nil {
2015-10-29 22:11:35 +00:00
logrus . Errorf ( "Stop container error: %v" , err )
return
}
logrus . Debugf ( "container stopped %s" , c . ID )
2015-11-12 19:55:17 +00:00
} ( cont )
2015-04-27 21:11:29 +00:00
}
group . Wait ( )
2015-10-29 22:11:35 +00:00
}
2015-06-05 22:02:56 +00:00
2015-10-29 22:11:35 +00:00
// trigger libnetwork Stop only if it's initialized
if daemon . netController != nil {
daemon . netController . Stop ( )
2015-04-27 21:11:29 +00:00
}
2014-03-25 23:21:07 +00:00
2015-07-30 21:01:53 +00:00
if daemon . containerGraphDB != nil {
if err := daemon . containerGraphDB . Close ( ) ; err != nil {
2015-06-10 23:07:53 +00:00
logrus . Errorf ( "Error during container graph.Close(): %v" , err )
}
}
if daemon . driver != nil {
if err := daemon . driver . Cleanup ( ) ; err != nil {
logrus . Errorf ( "Error during graph storage driver.Cleanup(): %v" , err )
}
}
2015-08-03 22:05:34 +00:00
if err := daemon . cleanupMounts ( ) ; err != nil {
return err
}
2014-03-25 23:21:07 +00:00
return nil
}
2015-11-12 19:55:17 +00:00
// Mount sets container.BaseFS
2015-07-30 21:01:53 +00:00
// (is it not set coming in? why is it unset?)
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) Mount ( container * container . Container ) error {
2015-11-18 22:20:54 +00:00
var layerID layer . ChainID
if container . ImageID != "" {
img , err := daemon . imageStore . Get ( container . ImageID )
if err != nil {
return err
}
layerID = img . RootFS . ChainID ( )
}
2015-11-12 19:55:17 +00:00
rwlayer , err := daemon . layerStore . Mount ( container . ID , layerID , container . GetMountLabel ( ) , daemon . setupInitLayer )
2013-11-01 01:07:54 +00:00
if err != nil {
2015-11-18 22:20:54 +00:00
return err
2013-11-07 20:34:01 +00:00
}
2015-11-18 22:20:54 +00:00
dir , err := rwlayer . Path ( )
if err != nil {
return err
}
logrus . Debugf ( "container mounted via layerStore: %v" , dir )
2015-05-15 23:34:26 +00:00
2015-11-12 19:55:17 +00:00
if container . BaseFS != dir {
2015-05-15 23:34:26 +00:00
// The mount path reported by the graph driver should always be trusted on Windows, since the
// volume path for a given mounted layer may change over time. This should only be an error
// on non-Windows operating systems.
2015-11-12 19:55:17 +00:00
if container . BaseFS != "" && runtime . GOOS != "windows" {
2015-11-18 22:20:54 +00:00
daemon . Unmount ( container )
2015-05-15 23:34:26 +00:00
return fmt . Errorf ( "Error: driver %s is returning inconsistent paths for container %s ('%s' then '%s')" ,
2015-11-12 19:55:17 +00:00
daemon . driver , container . ID , container . BaseFS , dir )
2015-05-15 23:34:26 +00:00
}
2013-11-01 01:07:54 +00:00
}
2015-11-12 19:55:17 +00:00
container . BaseFS = dir // TODO: combine these fields
container . RWLayer = rwlayer
2013-11-07 20:34:01 +00:00
return nil
2013-11-01 01:07:54 +00:00
}
2015-11-03 01:06:09 +00:00
// Unmount unsets the container base filesystem
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) Unmount ( container * container . Container ) {
2015-11-18 22:20:54 +00:00
if err := daemon . layerStore . Unmount ( container . ID ) ; err != nil {
logrus . Errorf ( "Error unmounting container %s: %s" , container . ID , err )
}
2013-11-01 01:07:54 +00:00
}
2015-11-03 19:25:22 +00:00
// Run uses the execution driver to run a given container
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) Run ( c * container . Container , pipes * execdriver . Pipes , startCallback execdriver . DriverCallback ) ( execdriver . ExitStatus , error ) {
2015-09-11 19:05:57 +00:00
hooks := execdriver . Hooks {
Start : startCallback ,
}
2015-09-29 17:51:40 +00:00
hooks . PreStart = append ( hooks . PreStart , func ( processConfig * execdriver . ProcessConfig , pid int , chOOM <- chan struct { } ) error {
2015-11-03 18:25:09 +00:00
return daemon . setNetworkNamespaceKey ( c . ID , pid )
2015-09-11 19:05:57 +00:00
} )
2015-11-12 19:55:17 +00:00
return daemon . execDriver . Run ( c . Command , pipes , hooks )
2014-01-10 22:26:29 +00:00
}
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) kill ( c * container . Container , sig int ) error {
return daemon . execDriver . Kill ( c . Command , sig )
2014-01-10 22:26:29 +00:00
}
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) stats ( c * container . Container ) ( * execdriver . ResourceStats , error ) {
2015-01-07 22:43:04 +00:00
return daemon . execDriver . Stats ( c . ID )
}
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) subscribeToContainerStats ( c * container . Container ) chan interface { } {
2015-10-28 22:15:22 +00:00
return daemon . statsCollector . collect ( c )
2015-01-07 22:43:04 +00:00
}
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) unsubscribeToContainerStats ( c * container . Container , ch chan interface { } ) {
2015-01-08 02:02:08 +00:00
daemon . statsCollector . unsubscribe ( c , ch )
}
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) changes ( container * container . Container ) ( [ ] archive . Change , error ) {
2015-11-18 22:20:54 +00:00
return daemon . layerStore . Changes ( container . ID )
2015-07-25 00:49:43 +00:00
}
2015-11-18 22:20:54 +00:00
// TagImage creates a tag in the repository reponame, pointing to the image named
2015-12-01 22:02:02 +00:00
// imageName.
func ( daemon * Daemon ) TagImage ( newTag reference . Named , imageName string ) error {
2015-11-18 22:20:54 +00:00
imageID , err := daemon . GetImageID ( imageName )
2015-07-25 00:49:43 +00:00
if err != nil {
return err
}
2015-11-25 20:42:40 +00:00
newTag = registry . NormalizeLocalReference ( newTag )
2015-12-01 22:02:02 +00:00
if err := daemon . tagStore . AddTag ( newTag , imageID , true ) ; err != nil {
2015-11-25 20:42:40 +00:00
return err
}
2015-11-18 22:20:54 +00:00
daemon . EventsService . Log ( "tag" , newTag . String ( ) , "" )
2015-11-25 20:42:40 +00:00
return nil
2015-09-28 22:00:45 +00:00
}
// PullImage initiates a pull operation. image is the repository name to pull, and
// tag may be either empty, or indicate a specific tag to pull.
2015-11-18 22:20:54 +00:00
func ( daemon * Daemon ) PullImage ( ref reference . Named , metaHeaders map [ string ] [ ] string , authConfig * cliconfig . AuthConfig , outStream io . Writer ) error {
imagePullConfig := & distribution . ImagePullConfig {
MetaHeaders : metaHeaders ,
AuthConfig : authConfig ,
OutStream : outStream ,
RegistryService : daemon . RegistryService ,
EventsService : daemon . EventsService ,
MetadataStore : daemon . distributionMetadataStore ,
LayerStore : daemon . layerStore ,
ImageStore : daemon . imageStore ,
TagStore : daemon . tagStore ,
Pool : daemon . distributionPool ,
}
return distribution . Pull ( ref , imagePullConfig )
2015-09-28 22:00:45 +00:00
}
// ExportImage exports a list of images to the given output stream. The
// exported images are archived into a tar when written to the output
// stream. All images with the given tag and all versions containing
// the same tag are exported. names is the set of tags to export, and
// outStream is the writer which the images are written to.
func ( daemon * Daemon ) ExportImage ( names [ ] string , outStream io . Writer ) error {
2015-11-18 22:20:54 +00:00
imageExporter := tarexport . NewTarExporter ( daemon . imageStore , daemon . layerStore , daemon . tagStore )
return imageExporter . Save ( names , outStream )
2015-09-28 22:00:45 +00:00
}
// PushImage initiates a push operation on the repository named localName.
2015-11-18 22:20:54 +00:00
func ( daemon * Daemon ) PushImage ( ref reference . Named , metaHeaders map [ string ] [ ] string , authConfig * cliconfig . AuthConfig , outStream io . Writer ) error {
imagePushConfig := & distribution . ImagePushConfig {
MetaHeaders : metaHeaders ,
AuthConfig : authConfig ,
OutStream : outStream ,
RegistryService : daemon . RegistryService ,
EventsService : daemon . EventsService ,
MetadataStore : daemon . distributionMetadataStore ,
LayerStore : daemon . layerStore ,
ImageStore : daemon . imageStore ,
TagStore : daemon . tagStore ,
TrustKey : daemon . trustKey ,
}
return distribution . Push ( ref , imagePushConfig )
2015-09-28 22:00:45 +00:00
}
// LookupImage looks up an image by name and returns it as an ImageInspect
// structure.
func ( daemon * Daemon ) LookupImage ( name string ) ( * types . ImageInspect , error ) {
2015-11-18 22:20:54 +00:00
img , err := daemon . GetImage ( name )
if err != nil {
return nil , fmt . Errorf ( "No such image: %s" , name )
}
refs := daemon . tagStore . References ( img . ID ( ) )
repoTags := [ ] string { }
repoDigests := [ ] string { }
for _ , ref := range refs {
switch ref . ( type ) {
case reference . Tagged :
repoTags = append ( repoTags , ref . String ( ) )
case reference . Digested :
repoDigests = append ( repoDigests , ref . String ( ) )
}
}
var size int64
var layerMetadata map [ string ] string
layerID := img . RootFS . ChainID ( )
if layerID != "" {
l , err := daemon . layerStore . Get ( layerID )
if err != nil {
return nil , err
}
defer layer . ReleaseAndLog ( daemon . layerStore , l )
size , err = l . Size ( )
if err != nil {
return nil , err
}
layerMetadata , err = l . Metadata ( )
if err != nil {
return nil , err
}
}
imageInspect := & types . ImageInspect {
ID : img . ID ( ) . String ( ) ,
RepoTags : repoTags ,
RepoDigests : repoDigests ,
Parent : img . Parent . String ( ) ,
Comment : img . Comment ,
Created : img . Created . Format ( time . RFC3339Nano ) ,
Container : img . Container ,
ContainerConfig : & img . ContainerConfig ,
DockerVersion : img . DockerVersion ,
Author : img . Author ,
Config : img . Config ,
Architecture : img . Architecture ,
Os : img . OS ,
Size : size ,
VirtualSize : size , // TODO: field unused, deprecate
}
imageInspect . GraphDriver . Name = daemon . driver . String ( )
imageInspect . GraphDriver . Data = layerMetadata
return imageInspect , nil
2015-09-28 22:00:45 +00:00
}
// LoadImage uploads a set of images into the repository. This is the
// complement of ImageExport. The input stream is an uncompressed tar
// ball containing images and metadata.
func ( daemon * Daemon ) LoadImage ( inTar io . ReadCloser , outStream io . Writer ) error {
2015-11-18 22:20:54 +00:00
imageExporter := tarexport . NewTarExporter ( daemon . imageStore , daemon . layerStore , daemon . tagStore )
return imageExporter . Load ( inTar , outStream )
2015-09-28 22:00:45 +00:00
}
// ImageHistory returns a slice of ImageHistory structures for the specified image
// name by walking the image lineage.
func ( daemon * Daemon ) ImageHistory ( name string ) ( [ ] * types . ImageHistory , error ) {
2015-11-18 22:20:54 +00:00
img , err := daemon . GetImage ( name )
if err != nil {
return nil , err
}
history := [ ] * types . ImageHistory { }
layerCounter := 0
rootFS := * img . RootFS
rootFS . DiffIDs = nil
for _ , h := range img . History {
var layerSize int64
if ! h . EmptyLayer {
if len ( img . RootFS . DiffIDs ) <= layerCounter {
return nil , errors . New ( "too many non-empty layers in History section" )
}
rootFS . Append ( img . RootFS . DiffIDs [ layerCounter ] )
l , err := daemon . layerStore . Get ( rootFS . ChainID ( ) )
if err != nil {
return nil , err
}
layerSize , err = l . DiffSize ( )
layer . ReleaseAndLog ( daemon . layerStore , l )
if err != nil {
return nil , err
}
layerCounter ++
}
history = append ( [ ] * types . ImageHistory { {
ID : "<missing>" ,
Created : h . Created . Unix ( ) ,
CreatedBy : h . CreatedBy ,
Comment : h . Comment ,
Size : layerSize ,
} } , history ... )
}
// Fill in image IDs and tags
histImg := img
id := img . ID ( )
for _ , h := range history {
h . ID = id . String ( )
var tags [ ] string
for _ , r := range daemon . tagStore . References ( id ) {
if _ , ok := r . ( reference . NamedTagged ) ; ok {
tags = append ( tags , r . String ( ) )
}
}
h . Tags = tags
id = histImg . Parent
if id == "" {
break
}
histImg , err = daemon . GetImage ( id . String ( ) )
if err != nil {
break
}
}
return history , nil
2015-09-28 22:00:45 +00:00
}
2015-11-18 22:20:54 +00:00
// GetImageID returns an image ID corresponding to the image referred to by
// refOrID.
func ( daemon * Daemon ) GetImageID ( refOrID string ) ( image . ID , error ) {
// Treat as an ID
if id , err := digest . ParseDigest ( refOrID ) ; err == nil {
return image . ID ( id ) , nil
}
// Treat it as a possible tag or digest reference
if ref , err := reference . ParseNamed ( refOrID ) ; err == nil {
ref = registry . NormalizeLocalReference ( ref )
if id , err := daemon . tagStore . Get ( ref ) ; err == nil {
return id , nil
}
if tagged , ok := ref . ( reference . Tagged ) ; ok {
if id , err := daemon . imageStore . Search ( tagged . Tag ( ) ) ; err == nil {
for _ , namedRef := range daemon . tagStore . References ( id ) {
if namedRef . Name ( ) == ref . Name ( ) {
return id , nil
}
}
}
}
}
// Search based on ID
if id , err := daemon . imageStore . Search ( refOrID ) ; err == nil {
return id , nil
}
return "" , ErrImageDoesNotExist { refOrID }
}
// GetImage returns an image corresponding to the image referred to by refOrID.
func ( daemon * Daemon ) GetImage ( refOrID string ) ( * image . Image , error ) {
imgID , err := daemon . GetImageID ( refOrID )
if err != nil {
return nil , err
}
return daemon . imageStore . Get ( imgID )
2015-10-01 21:51:36 +00:00
}
2015-07-30 21:01:53 +00:00
// GraphDriver returns the currently used driver for processing
// container layers.
2015-09-29 17:51:40 +00:00
func ( daemon * Daemon ) GraphDriver ( ) graphdriver . Driver {
2014-04-17 21:43:01 +00:00
return daemon . driver
2014-03-08 02:42:29 +00:00
}
2015-07-30 21:01:53 +00:00
// ExecutionDriver returns the currently used driver for creating and
// starting execs in a container.
2015-09-29 17:51:40 +00:00
func ( daemon * Daemon ) ExecutionDriver ( ) execdriver . Driver {
2014-04-17 21:43:01 +00:00
return daemon . execDriver
2014-03-08 02:42:29 +00:00
}
2015-07-30 21:01:53 +00:00
func ( daemon * Daemon ) containerGraph ( ) * graphdb . Database {
return daemon . containerGraphDB
2014-03-08 02:42:29 +00:00
}
2015-10-08 15:51:41 +00:00
// GetUIDGIDMaps returns the current daemon's user namespace settings
// for the full uid and gid maps which will be applied to containers
// started in this instance.
func ( daemon * Daemon ) GetUIDGIDMaps ( ) ( [ ] idtools . IDMap , [ ] idtools . IDMap ) {
return daemon . uidMaps , daemon . gidMaps
}
// GetRemappedUIDGID returns the current daemon's uid and gid values
// if user namespaces are in use for this daemon instance. If not
// this function will return "real" root values of 0, 0.
func ( daemon * Daemon ) GetRemappedUIDGID ( ) ( int , int ) {
uid , gid , _ := idtools . GetRootUIDGID ( daemon . uidMaps , daemon . gidMaps )
return uid , gid
}
2015-07-30 21:01:53 +00:00
// ImageGetCached returns the earliest created image that is a child
// of the image with imgID, that had the same config when it was
// created. nil is returned if a child cannot be found. An error is
// returned if the parent image cannot be found.
2015-11-18 22:20:54 +00:00
func ( daemon * Daemon ) ImageGetCached ( imgID image . ID , config * runconfig . Config ) ( * image . Image , error ) {
2014-07-29 05:22:58 +00:00
// Retrieve all images
2015-11-18 22:20:54 +00:00
imgs := daemon . Map ( )
2014-07-29 05:22:58 +00:00
2015-11-18 22:20:54 +00:00
var siblings [ ] image . ID
for id , img := range imgs {
if img . Parent == imgID {
siblings = append ( siblings , id )
2014-07-29 05:22:58 +00:00
}
}
// Loop on the children of the given image and check the config
2015-07-20 17:57:15 +00:00
var match * image . Image
2015-11-18 22:20:54 +00:00
for _ , id := range siblings {
img , ok := imgs [ id ]
2014-11-11 20:15:00 +00:00
if ! ok {
2015-11-18 22:20:54 +00:00
return nil , fmt . Errorf ( "unable to find image %q" , id )
2014-07-29 05:22:58 +00:00
}
if runconfig . Compare ( & img . ContainerConfig , config ) {
if match == nil || match . Created . Before ( img . Created ) {
match = img
}
}
}
return match , nil
}
2014-07-30 06:51:43 +00:00
2015-03-29 18:51:17 +00:00
// tempDir returns the default directory to use for temporary files.
2015-10-08 15:51:41 +00:00
func tempDir ( rootDir string , rootUID , rootGID int ) ( string , error ) {
2015-03-29 18:51:17 +00:00
var tmpDir string
if tmpDir = os . Getenv ( "DOCKER_TMPDIR" ) ; tmpDir == "" {
tmpDir = filepath . Join ( rootDir , "tmp" )
}
2015-10-08 15:51:41 +00:00
return tmpDir , idtools . MkdirAllAs ( tmpDir , 0700 , rootUID , rootGID )
2015-04-16 06:31:52 +00:00
}
2015-04-23 02:23:02 +00:00
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) setHostConfig ( container * container . Container , hostConfig * runconfig . HostConfig ) error {
2015-11-18 22:20:54 +00:00
container . Lock ( )
if err := parseSecurityOpt ( container , hostConfig ) ; err != nil {
container . Unlock ( )
return err
}
container . Unlock ( )
2015-05-19 20:05:25 +00:00
2015-05-27 19:29:49 +00:00
// Do not lock while creating volumes since this could be calling out to external plugins
// Don't want to block other actions, like `docker ps` because we're waiting on an external plugin
2015-09-29 17:51:40 +00:00
if err := daemon . registerMountPoints ( container , hostConfig ) ; err != nil {
2015-04-23 02:23:02 +00:00
return err
}
2015-05-27 19:29:49 +00:00
container . Lock ( )
defer container . Unlock ( )
2015-06-12 00:34:20 +00:00
2015-04-23 02:23:02 +00:00
// Register any links from the host config before starting the container
2015-09-29 17:51:40 +00:00
if err := daemon . registerLinks ( container , hostConfig ) ; err != nil {
2015-04-23 02:23:02 +00:00
return err
}
2015-11-12 19:55:17 +00:00
container . HostConfig = hostConfig
container . ToDisk ( )
2015-04-23 02:23:02 +00:00
return nil
}
2015-06-03 16:26:41 +00:00
2015-11-18 22:20:54 +00:00
func ( daemon * Daemon ) setupInitLayer ( initPath string ) error {
rootUID , rootGID := daemon . GetRemappedUIDGID ( )
return setupInitLayer ( initPath , rootUID , rootGID )
}
2015-06-15 23:33:02 +00:00
func setDefaultMtu ( config * Config ) {
// do nothing if the config does not have the default 0 value.
if config . Mtu != 0 {
return
}
config . Mtu = defaultNetworkMtu
}
2015-07-30 22:28:11 +00:00
// verifyContainerSettings performs validation of the hostconfig and config
// structures.
2015-09-29 17:51:40 +00:00
func ( daemon * Daemon ) verifyContainerSettings ( hostConfig * runconfig . HostConfig , config * runconfig . Config ) ( [ ] string , error ) {
2015-07-30 22:28:11 +00:00
// First perform verification of settings common across all platforms.
if config != nil {
2015-09-02 01:50:41 +00:00
if config . WorkingDir != "" {
config . WorkingDir = filepath . FromSlash ( config . WorkingDir ) // Ensure in platform semantics
if ! system . IsAbs ( config . WorkingDir ) {
return nil , fmt . Errorf ( "The working directory '%s' is invalid. It needs to be an absolute path." , config . WorkingDir )
}
2015-07-30 22:28:11 +00:00
}
2015-08-18 17:30:44 +00:00
if len ( config . StopSignal ) > 0 {
_ , err := signal . ParseSignal ( config . StopSignal )
if err != nil {
return nil , err
}
}
2015-07-30 22:28:11 +00:00
}
if hostConfig == nil {
return nil , nil
}
for port := range hostConfig . PortBindings {
_ , portStr := nat . SplitProtoPort ( string ( port ) )
if _ , err := nat . ParsePort ( portStr ) ; err != nil {
return nil , fmt . Errorf ( "Invalid port specification: %q" , portStr )
}
for _ , pb := range hostConfig . PortBindings [ port ] {
_ , err := nat . NewPort ( nat . SplitProtoPort ( pb . HostPort ) )
if err != nil {
return nil , fmt . Errorf ( "Invalid port specification: %q" , pb . HostPort )
}
}
}
// Now do platform-specific verification
2015-09-29 17:51:40 +00:00
return verifyPlatformContainerSettings ( daemon , hostConfig , config )
2015-07-30 22:28:11 +00:00
}
2015-09-16 21:18:24 +00:00
2015-10-08 15:51:41 +00:00
func configureVolumes ( config * Config , rootUID , rootGID int ) ( * store . VolumeStore , error ) {
volumesDriver , err := local . New ( config . Root , rootUID , rootGID )
2015-09-16 21:18:24 +00:00
if err != nil {
return nil , err
}
2015-09-18 23:58:05 +00:00
2015-09-16 21:18:24 +00:00
volumedrivers . Register ( volumesDriver , volumesDriver . Name ( ) )
2015-09-18 23:58:05 +00:00
s := store . New ( )
s . AddAll ( volumesDriver . List ( ) )
return s , nil
2015-09-16 21:18:24 +00:00
}
2015-10-08 23:16:36 +00:00
// AuthenticateToRegistry checks the validity of credentials in authConfig
func ( daemon * Daemon ) AuthenticateToRegistry ( authConfig * cliconfig . AuthConfig ) ( string , error ) {
return daemon . RegistryService . Auth ( authConfig )
}
// SearchRegistryForImages queries the registry for images matching
// term. authConfig is used to login.
func ( daemon * Daemon ) SearchRegistryForImages ( term string ,
authConfig * cliconfig . AuthConfig ,
headers map [ string ] [ ] string ) ( * registry . SearchResults , error ) {
return daemon . RegistryService . Search ( term , authConfig , headers )
}
2015-11-03 19:06:16 +00:00
2015-11-03 19:25:22 +00:00
// IsShuttingDown tells whether the daemon is shutting down or not
func ( daemon * Daemon ) IsShuttingDown ( ) bool {
return daemon . shutdown
}
// GetContainerStats collects all the stats published by a container
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) GetContainerStats ( container * container . Container ) ( * execdriver . ResourceStats , error ) {
2015-11-03 19:06:16 +00:00
stats , err := daemon . stats ( container )
if err != nil {
return nil , err
}
// Retrieve the nw statistics from libnetwork and inject them in the Stats
var nwStats [ ] * libcontainer . NetworkInterface
if nwStats , err = daemon . getNetworkStats ( container ) ; err != nil {
return nil , err
}
stats . Interfaces = nwStats
return stats , nil
}
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) getNetworkStats ( c * container . Container ) ( [ ] * libcontainer . NetworkInterface , error ) {
2015-11-03 19:06:16 +00:00
var list [ ] * libcontainer . NetworkInterface
sb , err := daemon . netController . SandboxByID ( c . NetworkSettings . SandboxID )
if err != nil {
return list , err
}
stats , err := sb . Statistics ( )
if err != nil {
return list , err
}
// Convert libnetwork nw stats into libcontainer nw stats
for ifName , ifStats := range stats {
list = append ( list , convertLnNetworkStats ( ifName , ifStats ) )
}
return list , nil
}
2015-11-18 10:04:23 +00:00
// newBaseContainer creates a new container with its initial
// configuration based on the root storage from the daemon.
2015-11-12 19:55:17 +00:00
func ( daemon * Daemon ) newBaseContainer ( id string ) * container . Container {
return container . NewBaseContainer ( id , daemon . containerRoot ( id ) )
2015-11-18 10:04:23 +00:00
}
2015-11-03 19:06:16 +00:00
func convertLnNetworkStats ( name string , stats * lntypes . InterfaceStatistics ) * libcontainer . NetworkInterface {
n := & libcontainer . NetworkInterface { Name : name }
n . RxBytes = stats . RxBytes
n . RxPackets = stats . RxPackets
n . RxErrors = stats . RxErrors
n . RxDropped = stats . RxDropped
n . TxBytes = stats . TxBytes
n . TxPackets = stats . TxPackets
n . TxErrors = stats . TxErrors
n . TxDropped = stats . TxDropped
return n
}
2015-11-12 19:55:17 +00:00
func validateID ( id string ) error {
if id == "" {
return derr . ErrorCodeEmptyID
}
return nil
}