2014-04-17 21:43:01 +00:00
package daemon
2013-01-19 00:13:39 +00:00
import (
2014-12-10 05:55:09 +00:00
"bytes"
2013-01-19 00:13:39 +00:00
"fmt"
2014-04-28 21:36:04 +00:00
"io"
"io/ioutil"
"os"
"path"
2015-01-16 19:48:25 +00:00
"path/filepath"
2014-04-28 21:36:04 +00:00
"regexp"
2014-07-30 06:51:43 +00:00
"runtime"
2014-04-28 21:36:04 +00:00
"strings"
"sync"
"time"
2014-07-24 20:37:44 +00:00
"github.com/docker/libcontainer/label"
2014-10-24 17:12:35 +00:00
log "github.com/Sirupsen/logrus"
2014-11-17 19:23:41 +00:00
"github.com/docker/docker/api"
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/execdriver/lxc"
"github.com/docker/docker/daemon/graphdriver"
_ "github.com/docker/docker/daemon/graphdriver/vfs"
_ "github.com/docker/docker/daemon/networkdriver/bridge"
"github.com/docker/docker/daemon/networkdriver/portallocator"
"github.com/docker/docker/dockerversion"
"github.com/docker/docker/engine"
"github.com/docker/docker/graph"
"github.com/docker/docker/image"
2014-09-30 06:23:36 +00:00
"github.com/docker/docker/pkg/archive"
2014-07-30 15:16:10 +00:00
"github.com/docker/docker/pkg/broadcastwriter"
2014-07-24 22:19:50 +00:00
"github.com/docker/docker/pkg/graphdb"
2014-08-12 16:10:43 +00:00
"github.com/docker/docker/pkg/ioutils"
2014-07-24 22:19:50 +00:00
"github.com/docker/docker/pkg/namesgenerator"
2014-12-10 05:55:09 +00:00
"github.com/docker/docker/pkg/networkfs/resolvconf"
2014-07-29 00:23:38 +00:00
"github.com/docker/docker/pkg/parsers"
2014-07-30 06:51:43 +00:00
"github.com/docker/docker/pkg/parsers/kernel"
2014-07-24 22:19:50 +00:00
"github.com/docker/docker/pkg/sysinfo"
"github.com/docker/docker/pkg/truncindex"
"github.com/docker/docker/runconfig"
2014-10-02 01:26:06 +00:00
"github.com/docker/docker/trust"
2014-07-24 22:19:50 +00:00
"github.com/docker/docker/utils"
2014-08-28 14:18:08 +00:00
"github.com/docker/docker/volumes"
2014-12-10 05:55:09 +00:00
"github.com/go-fsnotify/fsnotify"
2013-01-19 00:13:39 +00:00
)
2013-12-12 21:34:26 +00:00
var (
2014-09-12 17:45:07 +00:00
validContainerNameChars = ` [a-zA-Z0-9][a-zA-Z0-9_.-] `
2013-12-17 02:17:22 +00:00
validContainerNamePattern = regexp . MustCompile ( ` ^/? ` + validContainerNameChars + ` +$ ` )
2013-12-12 21:34:26 +00:00
)
2013-09-07 00:33:05 +00:00
2014-05-30 08:55:25 +00:00
type contStore struct {
s map [ string ] * Container
sync . Mutex
}
func ( c * contStore ) Add ( id string , cont * Container ) {
c . Lock ( )
c . s [ id ] = cont
c . Unlock ( )
}
func ( c * contStore ) Get ( id string ) * Container {
c . Lock ( )
res := c . s [ id ]
c . Unlock ( )
return res
}
func ( c * contStore ) Delete ( id string ) {
c . Lock ( )
delete ( c . s , id )
c . Unlock ( )
}
func ( c * contStore ) List ( ) [ ] * Container {
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 ( )
2014-05-30 08:55:25 +00:00
containers . Sort ( )
return * containers
}
2014-04-17 21:43:01 +00:00
type Daemon struct {
2014-11-17 19:23:41 +00:00
ID string
2013-02-28 19:52:07 +00:00
repository string
2013-11-25 22:42:22 +00:00
sysInitPath string
2014-05-30 08:55:25 +00:00
containers * contStore
2014-09-15 22:56:47 +00:00
execCommands * execStore
2014-03-08 02:04:38 +00:00
graph * graph . Graph
repositories * graph . TagStore
2014-06-24 17:19:15 +00:00
idIndex * truncindex . TruncIndex
2014-01-15 22:36:13 +00:00
sysInfo * sysinfo . SysInfo
2014-08-28 14:18:08 +00:00
volumes * volumes . Repository
2014-01-30 19:50:59 +00:00
eng * engine . Engine
2014-08-09 22:30:27 +00:00
config * Config
2013-11-15 23:55:45 +00:00
containerGraph * graphdb . Database
2013-11-07 20:34:01 +00:00
driver graphdriver . Driver
2014-01-10 00:03:22 +00:00
execDriver execdriver . Driver
2014-10-02 01:26:06 +00:00
trustStore * trust . TrustStore
2013-03-21 07:25:00 +00:00
}
2014-05-20 19:36:15 +00:00
// Install installs daemon capabilities to eng.
func ( daemon * Daemon ) Install ( eng * engine . Engine ) error {
2014-08-05 06:41:30 +00:00
// FIXME: remove ImageDelete's dependency on Daemon, then move to graph/
2014-07-31 21:37:30 +00:00
for name , method := range map [ string ] engine . Handler {
"attach" : daemon . ContainerAttach ,
"commit" : daemon . ContainerCommit ,
"container_changes" : daemon . ContainerChanges ,
"container_copy" : daemon . ContainerCopy ,
2014-10-05 02:47:54 +00:00
"container_rename" : daemon . ContainerRename ,
2014-07-31 21:37:30 +00:00
"container_inspect" : daemon . ContainerInspect ,
"containers" : daemon . Containers ,
"create" : daemon . ContainerCreate ,
2014-08-21 10:40:47 +00:00
"rm" : daemon . ContainerRm ,
2014-07-31 21:37:30 +00:00
"export" : daemon . ContainerExport ,
2014-08-08 03:01:55 +00:00
"info" : daemon . CmdInfo ,
2014-07-31 21:37:30 +00:00
"kill" : daemon . ContainerKill ,
"logs" : daemon . ContainerLogs ,
"pause" : daemon . ContainerPause ,
"resize" : daemon . ContainerResize ,
"restart" : daemon . ContainerRestart ,
"start" : daemon . ContainerStart ,
"stop" : daemon . ContainerStop ,
"top" : daemon . ContainerTop ,
"unpause" : daemon . ContainerUnpause ,
"wait" : daemon . ContainerWait ,
2014-08-05 06:41:30 +00:00
"image_delete" : daemon . ImageDelete , // FIXME: see above
2014-09-15 22:56:47 +00:00
"execCreate" : daemon . ContainerExecCreate ,
"execStart" : daemon . ContainerExecStart ,
"execResize" : daemon . ContainerExecResize ,
2014-11-17 23:50:09 +00:00
"execInspect" : daemon . ContainerExecInspect ,
2014-07-31 21:37:30 +00:00
} {
if err := eng . Register ( name , method ) ; err != nil {
return err
}
2014-07-31 21:26:25 +00:00
}
2014-08-08 09:12:39 +00:00
if err := daemon . Repositories ( ) . Install ( eng ) ; err != nil {
return err
}
2014-10-02 01:26:06 +00:00
if err := daemon . trustStore . Install ( eng ) ; err != nil {
return err
}
2014-08-08 09:12:39 +00:00
// FIXME: this hack is necessary for legacy integration tests to access
// the daemon object.
eng . Hack_SetGlobalVar ( "httpapi.daemon" , daemon )
2014-07-30 08:16:23 +00:00
return nil
2014-05-20 19:36:15 +00:00
}
2013-09-07 00:43:34 +00:00
// Get looks for a container by the specified ID or name, and returns it.
// If the container is not found, or if an error occurs, nil is returned.
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Get ( name string ) * Container {
2015-01-06 19:16:33 +00:00
id , err := daemon . idIndex . Get ( name )
if err == nil {
2014-08-06 15:54:13 +00:00
return daemon . containers . Get ( id )
}
2014-11-03 00:25:44 +00:00
2014-04-17 21:43:01 +00:00
if c , _ := daemon . GetByName ( name ) ; c != nil {
2013-10-05 02:25:15 +00:00
return c
}
2014-11-03 00:25:44 +00:00
if err == truncindex . ErrDuplicateID {
log . Errorf ( "Short ID %s is ambiguous: please retry with more characters or use the full ID.\n" , name )
}
2014-08-06 15:54:13 +00:00
return 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.
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Exists ( id string ) bool {
return daemon . Get ( id ) != nil
2013-01-19 00:13:39 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) containerRoot ( id string ) string {
return path . 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.
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) load ( id string ) ( * Container , error ) {
2014-09-18 21:38:22 +00:00
container := & Container {
root : daemon . containerRoot ( id ) ,
State : NewState ( ) ,
execCommands : newExecStore ( ) ,
}
2013-03-21 07:25:00 +00:00
if err := container . FromDisk ( ) ; err != nil {
return nil , err
}
2014-08-06 17:40:43 +00:00
2013-06-04 18:00:22 +00:00
if container . ID != id {
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
container . readHostConfig ( )
2013-01-19 00:13:39 +00:00
return container , nil
}
2014-04-17 21:43:01 +00:00
// Register makes a container object usable by the daemon as <container.ID>
2014-05-14 14:58:37 +00:00
// This is a wrapper for register
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Register ( container * Container ) error {
2014-08-06 17:40:43 +00:00
return daemon . register ( container , true )
2014-05-14 14:58:37 +00:00
}
// register makes a container object usable by the daemon as <container.ID>
2014-08-06 17:40:43 +00:00
func ( daemon * Daemon ) register ( container * Container , updateSuffixarray bool ) error {
2014-04-17 21:43:01 +00:00
if container . daemon != nil || 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
2014-04-17 21:43:01 +00:00
container . daemon = daemon
2013-04-09 14:57:59 +00:00
2013-03-21 07:25:00 +00:00
// Attach to stdout and stderr
2014-08-26 22:44:00 +00:00
container . stderr = broadcastwriter . New ( )
container . stdout = broadcastwriter . New ( )
2013-03-21 07:25:00 +00:00
// Attach to stdin
if container . Config . OpenStdin {
2014-08-26 22:44:00 +00:00
container . stdin , container . stdinPipe = io . Pipe ( )
2013-03-21 07:25:00 +00:00
} else {
2014-08-12 16:10:43 +00:00
container . stdinPipe = ioutils . NopWriteCloser ( ioutil . Discard ) // Silently drop stdin
2013-03-21 07:25:00 +00:00
}
// done
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
2015-01-16 19:48:25 +00:00
container . registerVolumes ( )
2013-04-25 02:01:23 +00:00
// FIXME: if the container is supposed to be running but is not, auto restart it?
// if so, then we need to restart monitor and init a new lock
// If the container is supposed to be running, make sure of it
2014-08-31 15:20:35 +00:00
if container . IsRunning ( ) {
2014-07-24 20:37:44 +00:00
log . Debugf ( "killing old running container %s" , container . ID )
2014-04-18 03:42:57 +00:00
2014-08-31 15:20:35 +00:00
existingPid := container . Pid
2014-12-12 18:38:48 +00:00
container . SetStopped ( & execdriver . ExitStatus { ExitCode : 0 } )
2014-04-18 03:42:57 +00:00
// We only have to handle this for lxc because the other drivers will ensure that
// no processes are left when docker dies
if container . ExecDriver == "" || strings . Contains ( container . ExecDriver , "lxc" ) {
lxc . KillLxc ( container . ID , 9 )
} else {
// use the current driver and ensure that the container is dead x.x
cmd := & execdriver . Command {
ID : container . ID ,
2014-03-06 22:14:25 +00:00
}
2014-04-18 03:42:57 +00:00
var err error
2014-08-26 22:05:37 +00:00
cmd . ProcessConfig . Process , err = os . FindProcess ( existingPid )
2014-04-18 03:42:57 +00:00
if err != nil {
2014-07-24 20:37:44 +00:00
log . Debugf ( "cannot find existing process for %d" , existingPid )
2014-03-26 06:59:41 +00:00
}
2014-04-18 03:42:57 +00:00
daemon . execDriver . Terminate ( cmd )
}
2014-07-22 02:59:44 +00:00
2014-04-18 03:42:57 +00:00
if err := container . Unmount ( ) ; err != nil {
2014-07-24 20:37:44 +00:00
log . Debugf ( "unmount error %s" , err )
2014-04-18 03:42:57 +00:00
}
if err := container . ToDisk ( ) ; err != nil {
2014-07-24 20:37:44 +00:00
log . Debugf ( "saving stopped state to disk %s" , err )
2014-03-06 22:14:25 +00:00
}
2014-04-17 21:43:01 +00:00
info := daemon . execDriver . Info ( container . ID )
2014-01-15 19:46:25 +00:00
if ! info . IsRunning ( ) {
2014-07-24 20:37:44 +00:00
log . Debugf ( "Container %s was supposed to be running but is not." , container . ID )
2014-07-22 02:59:44 +00:00
2014-07-24 20:37:44 +00:00
log . Debugf ( "Marking as stopped" )
2014-07-22 02:59:44 +00:00
2014-12-12 18:38:48 +00:00
container . SetStopped ( & execdriver . ExitStatus { ExitCode : - 127 } )
2014-07-22 02:59:44 +00:00
if err := container . ToDisk ( ) ; err != nil {
return err
}
2013-11-08 14:40:46 +00:00
}
2013-04-19 19:08:43 +00:00
}
2013-03-21 07:25:00 +00:00
return nil
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) ensureName ( 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
if err := container . ToDisk ( ) ; err != nil {
2014-07-24 20:37:44 +00:00
log . Debugf ( "Error saving container name %s" , err )
2013-11-04 17:28:40 +00:00
}
}
return nil
}
2014-07-02 14:48:37 +00:00
func ( daemon * Daemon ) LogToDisk ( src * broadcastwriter . BroadcastWriter , dst , stream string ) error {
2013-03-21 07:25:00 +00:00
log , err := os . OpenFile ( dst , os . O_RDWR | os . O_APPEND | os . O_CREATE , 0600 )
if err != nil {
return err
}
2013-07-11 17:18:28 +00:00
src . AddWriter ( log , stream )
2013-03-21 07:25:00 +00:00
return nil
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) restore ( ) error {
2014-06-06 00:31:58 +00:00
var (
2014-08-06 17:40:43 +00:00
debug = ( os . Getenv ( "DEBUG" ) != "" || os . Getenv ( "TEST" ) != "" )
containers = make ( map [ string ] * Container )
currentDriver = daemon . driver . String ( )
2014-06-06 00:31:58 +00:00
)
2014-05-30 18:03:56 +00:00
if ! debug {
2014-10-24 17:12:35 +00:00
log . Infof ( "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 )
2014-05-30 18:03:56 +00:00
if ! debug {
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 {
2014-07-24 20:37:44 +00:00
log . 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 {
2014-07-24 20:37:44 +00:00
log . Debugf ( "Loaded container %v" , container . ID )
2014-08-06 17:40:43 +00:00
2013-11-15 06:52:08 +00:00
containers [ container . ID ] = container
} else {
2014-07-24 20:37:44 +00:00
log . 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
}
2014-08-06 17:40:43 +00:00
registeredContainers := [ ] * Container { }
2014-04-17 21:43:01 +00:00
if entities := daemon . containerGraph . List ( "/" , - 1 ) ; entities != nil {
2013-10-24 23:49:28 +00:00
for _ , p := range entities . Paths ( ) {
2014-05-30 18:03:56 +00:00
if ! debug {
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
2013-10-24 23:49:28 +00:00
if container , ok := containers [ e . ID ( ) ] ; ok {
2014-08-06 17:40:43 +00:00
if err := daemon . register ( container , false ) ; err != nil {
2014-07-24 20:37:44 +00:00
log . Debugf ( "Failed to register container %s: %s" , container . ID , err )
2014-05-30 18:03:56 +00:00
}
2014-08-06 17:40:43 +00:00
registeredContainers = append ( registeredContainers , container )
// delete from the map so that a new name is not automatically generated
2013-10-24 23:49:28 +00:00
delete ( containers , e . ID ( ) )
}
2013-10-05 02:25:15 +00:00
}
2013-10-24 23:49:28 +00:00
}
2013-10-24 17:25:07 +00:00
2013-10-24 23:49:28 +00:00
// Any containers that are left over do not exist in the graph
for _ , container := range containers {
2013-10-24 17:25:07 +00:00
// Try to set the default name for a container if it exists prior to links
2014-05-24 00:51:16 +00:00
container . Name , err = daemon . generateNewName ( container . ID )
2013-10-31 01:26:01 +00:00
if err != nil {
2014-07-24 20:37:44 +00:00
log . Debugf ( "Setting default id - %s" , err )
2013-10-24 17:25:07 +00:00
}
2014-08-06 17:40:43 +00:00
if err := daemon . register ( container , false ) ; err != nil {
2014-07-24 20:37:44 +00:00
log . Debugf ( "Failed to register container %s: %s" , container . ID , err )
2014-05-30 18:03:56 +00:00
}
2014-08-06 17:40:43 +00:00
registeredContainers = append ( registeredContainers , container )
2013-01-19 00:13:39 +00:00
}
2013-10-24 23:49:28 +00:00
2014-08-06 17:40:43 +00:00
// check the restart policy on the containers and restart any container with
// the restart policy of "always"
if daemon . config . AutoRestart {
log . Debugf ( "Restarting containers..." )
for _ , container := range registeredContainers {
2014-08-07 04:13:06 +00:00
if container . hostConfig . RestartPolicy . Name == "always" ||
2014-08-31 15:20:35 +00:00
( container . hostConfig . RestartPolicy . Name == "on-failure" && container . ExitCode != 0 ) {
2014-08-13 21:58:57 +00:00
log . Debugf ( "Starting container %s" , container . ID )
2014-08-06 17:40:43 +00:00
if err := container . Start ( ) ; err != nil {
2014-08-13 21:58:57 +00:00
log . Debugf ( "Failed to start container %s: %s" , container . ID , err )
2014-08-06 17:40:43 +00:00
}
}
2014-06-06 00:31:58 +00:00
}
}
2014-05-30 18:03:56 +00:00
if ! debug {
2014-10-24 17:12:35 +00:00
fmt . Println ( )
log . Infof ( "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
}
2014-12-10 05:55:09 +00:00
// set up the watch on the host's /etc/resolv.conf so that we can update container's
// live resolv.conf when the network changes on the host
func ( daemon * Daemon ) setupResolvconfWatcher ( ) error {
watcher , err := fsnotify . NewWatcher ( )
if err != nil {
return err
}
//this goroutine listens for the events on the watch we add
//on the resolv.conf file on the host
go func ( ) {
for {
select {
case event := <- watcher . Events :
if event . Op & fsnotify . Write == fsnotify . Write {
// verify a real change happened before we go further--a file write may have happened
// without an actual change to the file
updatedResolvConf , newResolvConfHash , err := resolvconf . GetIfChanged ( )
if err != nil {
log . Debugf ( "Error retrieving updated host resolv.conf: %v" , err )
} else if updatedResolvConf != nil {
// because the new host resolv.conf might have localhost nameservers..
2015-01-09 17:06:48 +00:00
updatedResolvConf , modified := resolvconf . FilterResolvDns ( updatedResolvConf , daemon . config . EnableIPv6 )
2014-12-10 05:55:09 +00:00
if modified {
// changes have occurred during localhost cleanup: generate an updated hash
newHash , err := utils . HashData ( bytes . NewReader ( updatedResolvConf ) )
if err != nil {
log . Debugf ( "Error generating hash of new resolv.conf: %v" , err )
} else {
newResolvConfHash = newHash
}
}
log . Debugf ( "host network resolv.conf changed--walking container list for updates" )
contList := daemon . containers . List ( )
for _ , container := range contList {
if err := container . updateResolvConf ( updatedResolvConf , newResolvConfHash ) ; err != nil {
log . Debugf ( "Error on resolv.conf update check for container ID: %s: %v" , container . ID , err )
}
}
}
}
case err := <- watcher . Errors :
log . Debugf ( "host resolv.conf notify error: %v" , err )
}
}
} ( )
if err := watcher . Add ( "/etc/resolv.conf" ) ; err != nil {
return err
}
return nil
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) checkDeprecatedExpose ( config * runconfig . Config ) bool {
2014-04-07 19:20:23 +00:00
if config != nil {
if config . PortSpecs != nil {
for _ , p := range config . PortSpecs {
if strings . Contains ( p , ":" ) {
return true
2013-10-30 21:36:38 +00:00
}
}
2013-09-20 12:46:24 +00:00
}
2013-09-07 00:33:05 +00:00
}
2014-04-07 19:20:23 +00:00
return false
}
2013-10-30 21:36:38 +00:00
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) mergeAndVerifyConfig ( config * runconfig . Config , img * image . Image ) ( [ ] string , error ) {
2013-10-30 18:13:10 +00:00
warnings := [ ] string { }
2014-10-28 21:06:23 +00:00
if ( img != nil && daemon . checkDeprecatedExpose ( img . Config ) ) || daemon . checkDeprecatedExpose ( config ) {
2014-03-03 07:35:40 +00:00
warnings = append ( warnings , "The mapping to public ports on your host via Dockerfile EXPOSE (host:port:port) has been deprecated. Use -p to publish the ports." )
2013-10-30 21:36:38 +00:00
}
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 {
2014-04-07 19:20:23 +00:00
return nil , err
2013-10-30 18:13:10 +00:00
}
}
2014-02-10 19:04:24 +00:00
if len ( config . Entrypoint ) == 0 && len ( config . Cmd ) == 0 {
2014-04-07 19:20:23 +00:00
return nil , fmt . Errorf ( "No command specified" )
2013-09-07 00:33:05 +00:00
}
2014-04-07 19:20:23 +00:00
return warnings , nil
}
2013-09-07 00:33:05 +00:00
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) generateIdAndName ( name string ) ( string , string , error ) {
2014-04-07 19:20:23 +00:00
var (
err error
id = utils . GenerateRandomID ( )
)
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
}
if name , err = daemon . reserveName ( id , name ) ; err != nil {
return "" , "" , err
}
return id , name , nil
}
func ( daemon * Daemon ) reserveName ( id , name string ) ( string , error ) {
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
2014-04-17 21:43:01 +00:00
if _ , err := daemon . containerGraph . 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
}
2014-04-17 21:43:01 +00:00
conflictingContainer , err := daemon . GetByName ( name )
2013-12-05 23:22:21 +00:00
if err != nil {
if strings . Contains ( err . Error ( ) , "Could not find entity" ) {
2014-05-24 00:51:16 +00:00
return "" , err
2013-12-05 23:22:21 +00:00
}
// Remove name and continue starting the container
2014-04-17 21:43:01 +00:00
if err := daemon . containerGraph . Delete ( name ) ; err != nil {
2014-05-24 00:51:16 +00:00
return "" , err
2013-12-05 23:22:21 +00:00
}
} else {
2013-11-27 02:58:54 +00:00
nameAsKnownByUser := strings . TrimPrefix ( name , "/" )
2014-05-24 00:51:16 +00:00
return "" , fmt . Errorf (
2015-01-13 20:57:48 +00:00
"Conflict. The name %q is already in use by container %s. You have to delete (or rename) that container to be able to reuse that name." , nameAsKnownByUser ,
2014-12-22 08:59:08 +00:00
utils . TruncateID ( conflictingContainer . ID ) )
2013-10-30 18:24:50 +00:00
}
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
}
if _ , err := daemon . containerGraph . Set ( name , id ) ; err != nil {
if ! graphdb . IsNonUniqueNameError ( err ) {
return "" , err
}
continue
}
return name , nil
}
name = "/" + utils . TruncateID ( id )
if _ , err := daemon . containerGraph . Set ( name , id ) ; err != nil {
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
// FIXME: the lxc template no longer needs to set a 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
2014-09-09 04:19:32 +00:00
func ( daemon * Daemon ) getEntrypointAndArgs ( configEntrypoint , configCmd [ ] string ) ( string , [ ] string ) {
2014-04-07 19:20:23 +00:00
var (
entrypoint string
args [ ] string
)
2014-09-09 04:19:32 +00:00
if len ( configEntrypoint ) != 0 {
entrypoint = configEntrypoint [ 0 ]
args = append ( configEntrypoint [ 1 : ] , configCmd ... )
2013-09-07 00:33:05 +00:00
} else {
2014-09-09 04:19:32 +00:00
entrypoint = configCmd [ 0 ]
args = configCmd [ 1 : ]
2013-09-07 00:33:05 +00:00
}
2014-04-07 19:20:23 +00:00
return entrypoint , args
}
2014-11-03 22:57:18 +00:00
func parseSecurityOpt ( container * Container , config * runconfig . HostConfig ) error {
2014-04-07 19:20:23 +00:00
var (
2014-11-03 22:57:18 +00:00
labelOpts [ ] string
err error
2014-09-30 19:10:03 +00:00
)
for _ , opt := range config . SecurityOpt {
con := strings . SplitN ( opt , ":" , 2 )
if len ( con ) == 1 {
return fmt . Errorf ( "Invalid --security-opt: %q" , opt )
}
switch con [ 0 ] {
case "label" :
2014-11-03 22:57:18 +00:00
labelOpts = append ( labelOpts , con [ 1 ] )
2014-09-30 19:10:03 +00:00
case "apparmor" :
container . AppArmorProfile = con [ 1 ]
default :
return fmt . Errorf ( "Invalid --security-opt: %q" , opt )
}
}
2014-11-03 22:57:18 +00:00
container . ProcessLabel , container . MountLabel , err = label . InitLabels ( labelOpts )
2014-09-30 19:10:03 +00:00
return err
}
2014-10-28 21:06:23 +00:00
func ( daemon * Daemon ) newContainer ( name string , config * runconfig . Config , imgID string ) ( * Container , error ) {
2014-09-30 19:10:03 +00:00
var (
id string
err error
2014-04-07 19:20:23 +00:00
)
2014-04-17 21:43:01 +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
container := & Container {
// FIXME: we should generate the ID here instead of receiving it as an argument
ID : id ,
2013-11-22 00:41:41 +00:00
Created : time . Now ( ) . UTC ( ) ,
2013-09-07 00:33:05 +00:00
Path : entrypoint ,
Args : args , //FIXME: de-duplicate from config
Config : config ,
2014-02-12 04:04:39 +00:00
hostConfig : & runconfig . HostConfig { } ,
2014-10-28 21:06:23 +00:00
ImageID : imgID ,
2013-09-07 00:33:05 +00:00
NetworkSettings : & NetworkSettings { } ,
2013-12-17 22:04:37 +00:00
Name : name ,
2014-04-17 21:43:01 +00:00
Driver : daemon . driver . String ( ) ,
ExecDriver : daemon . execDriver . Name ( ) ,
2014-06-06 11:30:04 +00:00
State : NewState ( ) ,
2014-09-15 22:56:47 +00:00
execCommands : newExecStore ( ) ,
2013-09-07 00:33:05 +00:00
}
2014-04-17 21:43:01 +00:00
container . root = daemon . containerRoot ( container . ID )
2014-09-30 19:10:03 +00:00
return container , err
2014-04-07 19:20:23 +00:00
}
2014-10-28 21:06:23 +00:00
func ( daemon * Daemon ) createRootfs ( container * Container ) error {
2013-09-07 00:33:05 +00:00
// Step 1: create the container directory.
// This doubles as a barrier to avoid race conditions.
if err := os . Mkdir ( container . root , 0700 ) ; err != nil {
2014-04-07 19:20:23 +00:00
return err
2013-09-07 00:33:05 +00:00
}
2013-11-07 20:34:01 +00:00
initID := fmt . Sprintf ( "%s-init" , container . ID )
2014-10-28 21:06:23 +00:00
if err := daemon . driver . Create ( initID , container . ImageID ) ; err != nil {
2014-04-07 19:20:23 +00:00
return err
2013-11-07 20:34:01 +00:00
}
2014-04-17 23:47:27 +00:00
initPath , err := daemon . driver . Get ( initID , "" )
2013-11-07 20:34:01 +00:00
if err != nil {
2014-04-07 19:20:23 +00:00
return err
2013-11-07 20:34:01 +00:00
}
2014-04-17 21:43:01 +00:00
defer daemon . driver . Put ( initID )
2013-12-05 21:18:02 +00:00
2014-03-08 02:04:38 +00:00
if err := graph . SetupInitLayer ( initPath ) ; err != nil {
2014-04-07 19:20:23 +00:00
return err
2013-11-07 20:34:01 +00:00
}
2014-04-17 23:47:27 +00:00
if err := daemon . driver . Create ( container . ID , initID ) ; err != nil {
2014-04-07 19:20:23 +00:00
return err
2013-11-07 20:34:01 +00:00
}
2014-04-07 19:20:23 +00:00
return nil
}
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
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) GetByName ( name string ) ( * 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
}
2014-04-17 21:43:01 +00:00
entity := daemon . containerGraph . 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
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Children ( name string ) ( map [ string ] * 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
}
2013-10-05 02:25:15 +00:00
children := make ( map [ string ] * Container )
2014-04-17 21:43:01 +00:00
err = daemon . containerGraph . Walk ( name , func ( p string , e * graphdb . Entity ) error {
c := daemon . Get ( e . ID ( ) )
2013-10-05 02:25:15 +00:00
if c == nil {
return fmt . Errorf ( "Could not get container for name %s and id %s" , e . ID ( ) , p )
}
children [ p ] = c
return nil
} , 0 )
if err != nil {
return nil , err
}
return children , nil
}
2014-07-14 23:19:37 +00:00
func ( daemon * Daemon ) Parents ( name string ) ( [ ] string , error ) {
name , err := GetFullContainerName ( name )
if err != nil {
return nil , err
}
return daemon . containerGraph . Parents ( name )
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) RegisterLink ( parent , child * Container , alias string ) error {
2013-10-28 23:58:59 +00:00
fullName := path . Join ( parent . Name , alias )
2014-04-17 21:43:01 +00:00
if ! daemon . containerGraph . Exists ( fullName ) {
_ , err := daemon . containerGraph . 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
}
2014-05-13 00:54:46 +00:00
func ( daemon * Daemon ) RegisterLinks ( container * Container , hostConfig * runconfig . HostConfig ) error {
if hostConfig != nil && hostConfig . Links != nil {
for _ , l := range hostConfig . Links {
2014-07-29 00:23:38 +00:00
parts , err := parsers . PartParser ( "name:alias" , l )
2014-05-13 00:54:46 +00:00
if err != nil {
return err
}
2015-01-13 01:38:12 +00:00
child := daemon . Get ( parts [ "name" ] )
2014-05-13 00:54:46 +00:00
if child == nil {
return fmt . Errorf ( "Could not get container for %s" , parts [ "name" ] )
}
2014-12-08 19:33:18 +00:00
if child . hostConfig . NetworkMode . IsHost ( ) {
return runconfig . ErrConflictHostNetworkAndLinks
}
2014-05-13 00:54:46 +00:00
if err := daemon . RegisterLink ( container , child , parts [ "alias" ] ) ; err != nil {
return err
}
}
// After we load all the links into the daemon
// set them to nil on the hostconfig
hostConfig . Links = nil
if err := container . WriteHostConfig ( ) ; err != nil {
return err
}
}
return nil
}
2013-03-31 09:02:01 +00:00
// FIXME: harmonize with NewGraph()
2014-08-09 22:30:27 +00:00
func NewDaemon ( config * Config , eng * engine . Engine ) ( * Daemon , error ) {
2014-04-17 21:43:01 +00:00
daemon , err := NewDaemonFromDirectory ( config , eng )
2013-04-19 03:47:24 +00:00
if err != nil {
return nil , err
}
2014-04-17 21:43:01 +00:00
return daemon , nil
2013-01-19 00:13:39 +00:00
}
2014-08-09 22:30:27 +00:00
func NewDaemonFromDirectory ( config * Config , eng * engine . Engine ) ( * Daemon , error ) {
2014-08-10 01:18:32 +00:00
if config . Mtu == 0 {
2014-11-04 23:53:34 +00:00
config . Mtu = getDefaultNetworkMtu ( )
2014-08-10 01:18:32 +00:00
}
2014-08-10 03:58:19 +00:00
// Check for mutually incompatible config options
if config . BridgeIface != "" && config . BridgeIP != "" {
return nil , fmt . Errorf ( "You specified -b & --bip, mutually exclusive options. Please specify only one." )
}
if ! config . EnableIptables && ! config . InterContainerCommunication {
return nil , fmt . Errorf ( "You specified --iptables=false with --icc=false. ICC uses iptables to function. Please set --icc or --iptables to true." )
}
2014-09-17 03:00:15 +00:00
if ! config . EnableIptables && config . EnableIpMasq {
2014-10-16 18:39:22 +00:00
config . EnableIpMasq = false
2014-09-17 03:00:15 +00:00
}
2014-09-16 17:37:50 +00:00
config . DisableNetwork = config . BridgeIface == disableNetworkBridge
2014-08-10 01:18:32 +00:00
2014-08-06 08:12:22 +00:00
// Claim the pidfile first, to avoid any and all unexpected race conditions.
// Some of the init doesn't need a pidfile lock - but let's not try to be smart.
if config . Pidfile != "" {
if err := utils . CreatePidFile ( config . Pidfile ) ; err != nil {
return nil , err
}
eng . OnShutdown ( func ( ) {
// Always release the pidfile last, just in case
utils . RemovePidFile ( config . Pidfile )
} )
}
// Check that the system is supported and we have sufficient privileges
2014-07-30 06:37:12 +00:00
if runtime . GOOS != "linux" {
2014-09-16 17:42:59 +00:00
return nil , fmt . Errorf ( "The Docker daemon is only supported on linux" )
2014-07-30 06:37:12 +00:00
}
if os . Geteuid ( ) != 0 {
2014-09-16 17:42:59 +00:00
return nil , fmt . Errorf ( "The Docker daemon needs to be run as root" )
2014-07-30 06:37:12 +00:00
}
2014-07-30 06:51:43 +00:00
if err := checkKernelAndArch ( ) ; err != nil {
2014-09-16 17:42:59 +00:00
return nil , err
2014-07-30 06:51:43 +00:00
}
2014-07-30 06:44:34 +00:00
// set up the TempDir to use a canonical path
2014-08-05 20:43:33 +00:00
tmp , err := utils . TempDir ( config . Root )
if err != nil {
2014-09-16 17:42:59 +00:00
return nil , fmt . Errorf ( "Unable to get the TempDir under %s: %s" , config . Root , err )
2014-08-05 20:43:33 +00:00
}
2014-07-30 06:44:34 +00:00
realTmp , err := utils . ReadSymlinkedDirectory ( tmp )
if err != nil {
2014-09-16 17:42:59 +00:00
return nil , fmt . Errorf ( "Unable to get the full path to the TempDir (%s): %s" , tmp , err )
2014-07-30 06:44:34 +00:00
}
os . Setenv ( "TMPDIR" , realTmp )
2014-04-07 21:43:50 +00:00
if ! config . EnableSelinuxSupport {
2014-07-16 23:39:15 +00:00
selinuxSetDisabled ( )
2014-04-07 21:43:50 +00:00
}
2014-05-10 01:05:54 +00:00
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 {
realRoot , err = utils . ReadSymlinkedDirectory ( config . Root )
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
}
}
config . Root = realRoot
2014-05-10 01:05:54 +00:00
// Create the root directory if it doesn't exists
if err := os . MkdirAll ( config . Root , 0700 ) ; err != nil && ! os . IsExist ( err ) {
return nil , err
}
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
2014-06-05 08:34:20 +00:00
driver , err := graphdriver . New ( config . Root , config . GraphOptions )
2013-11-07 20:34:01 +00:00
if err != nil {
return nil , err
}
2014-07-24 20:37:44 +00:00
log . Debugf ( "Using graph driver %s" , driver )
2013-11-07 20:34:01 +00:00
2014-06-04 20:38:06 +00:00
// As Docker on btrfs and SELinux are incompatible at present, error on both being enabled
2014-09-23 11:46:02 +00:00
if selinuxEnabled ( ) && config . EnableSelinuxSupport && driver . String ( ) == "btrfs" {
2014-06-04 20:38:06 +00:00
return nil , fmt . Errorf ( "SELinux is not supported with the BTRFS graph driver!" )
}
2014-04-17 21:43:01 +00:00
daemonRepo := path . Join ( config . Root , "containers" )
2013-03-14 01:48:50 +00:00
2014-04-17 21:43:01 +00:00
if err := os . MkdirAll ( daemonRepo , 0700 ) ; 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
if err = migrateIfAufs ( driver , config . Root ) ; err != nil {
return nil , err
2013-11-16 01:16:30 +00:00
}
2014-07-24 20:37:44 +00:00
log . Debugf ( "Creating images graph" )
2014-03-08 02:04:38 +00:00
g , err := graph . NewGraph ( path . Join ( config . Root , "graph" ) , driver )
2013-02-27 01:45:46 +00:00
if err != nil {
return nil , err
}
2013-11-15 10:30:28 +00:00
2014-06-05 08:34:20 +00:00
volumesDriver , err := graphdriver . GetDriver ( "vfs" , config . Root , config . GraphOptions )
2013-04-06 01:00:10 +00:00
if err != nil {
return nil , err
}
2014-08-28 14:18:08 +00:00
2015-01-16 19:48:25 +00:00
volumes , err := volumes . NewRepository ( filepath . Join ( config . Root , "volumes" ) , volumesDriver )
2013-04-06 01:00:10 +00:00
if err != nil {
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
}
2014-07-24 20:37:44 +00:00
log . Debugf ( "Creating repository list" )
2015-01-07 22:59:12 +00:00
repositories , err := graph . NewTagStore ( path . Join ( config . Root , "repositories-" + driver . String ( ) ) , g , trustKey )
2013-03-22 00:35:49 +00:00
if err != nil {
return nil , fmt . Errorf ( "Couldn't create Tag store: %s" , err )
}
2014-01-30 02:34:43 +00:00
2014-10-02 01:26:06 +00:00
trustDir := path . Join ( config . Root , "trust" )
if err := os . MkdirAll ( trustDir , 0700 ) ; err != nil && ! os . IsExist ( err ) {
return nil , err
}
t , err := trust . NewTrustStore ( trustDir )
if err != nil {
return nil , fmt . Errorf ( "could not create trust store: %s" , err )
}
2014-01-30 02:34:43 +00:00
if ! config . DisableNetwork {
job := eng . Job ( "init_networkdriver" )
job . SetenvBool ( "EnableIptables" , config . EnableIptables )
job . SetenvBool ( "InterContainerCommunication" , config . InterContainerCommunication )
job . SetenvBool ( "EnableIpForward" , config . EnableIpForward )
2014-09-17 03:00:15 +00:00
job . SetenvBool ( "EnableIpMasq" , config . EnableIpMasq )
2015-01-08 23:03:19 +00:00
job . SetenvBool ( "EnableIPv6" , config . EnableIPv6 )
2014-01-30 02:34:43 +00:00
job . Setenv ( "BridgeIface" , config . BridgeIface )
job . Setenv ( "BridgeIP" , config . BridgeIP )
2014-05-28 20:06:23 +00:00
job . Setenv ( "FixedCIDR" , config . FixedCIDR )
2015-01-08 23:03:19 +00:00
job . Setenv ( "FixedCIDRv6" , config . FixedCIDRv6 )
2014-01-30 19:25:06 +00:00
job . Setenv ( "DefaultBindingIP" , config . DefaultIp . String ( ) )
2014-01-30 02:34:43 +00:00
if err := job . Run ( ) ; err != nil {
return nil , err
}
2013-04-04 12:33:28 +00:00
}
2013-10-05 02:25:15 +00:00
2013-11-15 23:55:45 +00:00
graphdbPath := path . 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
}
2013-10-05 02:25:15 +00:00
2014-02-12 00:26:54 +00:00
localCopy := path . Join ( config . Root , "init" , fmt . Sprintf ( "dockerinit-%s" , dockerversion . VERSION ) )
2013-11-25 22:42:22 +00:00
sysInitPath := utils . DockerInitPath ( localCopy )
if sysInitPath == "" {
2014-07-02 00:30:25 +00:00
return nil , fmt . Errorf ( "Could not locate dockerinit: This usually means docker was built incorrectly. See http://docs.docker.com/contributing/devenvironment for official build instructions." )
2013-11-25 22:42:22 +00:00
}
2013-12-05 09:10:41 +00:00
if sysInitPath != localCopy {
// When we find a suitable dockerinit binary (even if it's our local binary), we copy it into config.Root at localCopy for future use (so that the original can go away without that being a problem, for example during a package upgrade).
if err := os . Mkdir ( path . Dir ( localCopy ) , 0700 ) ; err != nil && ! os . IsExist ( err ) {
2013-11-25 22:42:22 +00:00
return nil , err
}
if _ , err := utils . CopyFile ( sysInitPath , localCopy ) ; err != nil {
return nil , err
}
2013-12-05 09:10:41 +00:00
if err := os . Chmod ( localCopy , 0700 ) ; err != nil {
2013-11-25 22:42:22 +00:00
return nil , err
}
2013-12-05 09:10:41 +00:00
sysInitPath = localCopy
2013-11-25 22:42:22 +00:00
}
2014-03-05 09:40:55 +00:00
sysInfo := sysinfo . New ( false )
2014-03-03 15:15:29 +00:00
ed , err := execdrivers . NewDriver ( config . ExecDriver , config . Root , sysInitPath , sysInfo )
2014-01-10 00:03:22 +00:00
if err != nil {
return nil , err
}
2014-04-17 21:43:01 +00:00
daemon := & Daemon {
2014-11-17 19:23:41 +00:00
ID : trustKey . PublicKey ( ) . KeyID ( ) ,
2014-04-17 21:43:01 +00:00
repository : daemonRepo ,
2014-05-30 08:55:25 +00:00
containers : & contStore { s : make ( map [ string ] * Container ) } ,
2014-09-15 22:56:47 +00:00
execCommands : newExecStore ( ) ,
2013-03-22 00:35:49 +00:00
graph : g ,
repositories : repositories ,
2014-06-24 17:19:15 +00:00
idIndex : truncindex . NewTruncIndex ( [ ] string { } ) ,
2014-01-15 22:36:13 +00:00
sysInfo : sysInfo ,
2013-04-06 01:00:10 +00:00
volumes : volumes ,
2013-10-05 02:25:15 +00:00
config : config ,
containerGraph : graph ,
2013-11-07 23:58:03 +00:00
driver : driver ,
2013-11-25 22:42:22 +00:00
sysInitPath : sysInitPath ,
2014-01-10 00:03:22 +00:00
execDriver : ed ,
2014-01-30 19:50:59 +00:00
eng : eng ,
2014-10-02 01:26:06 +00:00
trustStore : t ,
2013-01-19 00:13:39 +00:00
}
2014-04-17 21:43:01 +00:00
if err := daemon . restore ( ) ; err != nil {
2013-01-19 00:13:39 +00:00
return nil , err
}
2014-12-10 05:55:09 +00:00
// set up filesystem watch on resolv.conf for network changes
if err := daemon . setupResolvconfWatcher ( ) ; err != nil {
return nil , err
}
2014-08-06 08:12:22 +00:00
// Setup shutdown handlers
// FIXME: can these shutdown handlers be registered closer to their source?
eng . OnShutdown ( func ( ) {
// FIXME: if these cleanup steps can be called concurrently, register
// them as separate handlers to speed up total shutdown time
if err := daemon . shutdown ( ) ; err != nil {
2014-07-24 20:37:44 +00:00
log . Errorf ( "daemon.shutdown(): %s" , err )
2014-08-06 08:12:22 +00:00
}
if err := portallocator . ReleaseAll ( ) ; err != nil {
2014-07-24 20:37:44 +00:00
log . Errorf ( "portallocator.ReleaseAll(): %s" , err )
2014-08-06 08:12:22 +00:00
}
if err := daemon . driver . Cleanup ( ) ; err != nil {
2014-07-24 20:37:44 +00:00
log . Errorf ( "daemon.driver.Cleanup(): %s" , err . Error ( ) )
2014-08-06 08:12:22 +00:00
}
if err := daemon . containerGraph . Close ( ) ; err != nil {
2014-07-24 20:37:44 +00:00
log . Errorf ( "daemon.containerGraph.Close(): %s" , err . Error ( ) )
2014-08-06 08:12:22 +00:00
}
} )
2014-04-17 21:43:01 +00:00
return daemon , nil
2013-01-19 00:13:39 +00:00
}
2013-01-29 20:15:39 +00:00
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) shutdown ( ) error {
2014-03-25 23:21:07 +00:00
group := sync . WaitGroup { }
2014-07-24 20:37:44 +00:00
log . Debugf ( "starting clean shutdown of all containers..." )
2014-04-17 21:43:01 +00:00
for _ , container := range daemon . List ( ) {
2014-04-01 00:11:17 +00:00
c := container
2014-08-31 15:20:35 +00:00
if c . IsRunning ( ) {
2014-07-24 20:37:44 +00:00
log . Debugf ( "stopping %s" , c . ID )
2014-03-25 23:21:07 +00:00
group . Add ( 1 )
go func ( ) {
defer group . Done ( )
2014-04-01 00:11:17 +00:00
if err := c . KillSig ( 15 ) ; err != nil {
2014-07-24 20:37:44 +00:00
log . Debugf ( "kill 15 error for %s - %s" , c . ID , err )
2014-04-01 00:11:17 +00:00
}
2014-08-31 15:20:35 +00:00
c . WaitStop ( - 1 * time . Second )
2014-07-24 20:37:44 +00:00
log . Debugf ( "container stopped %s" , c . ID )
2014-03-25 23:21:07 +00:00
} ( )
}
}
group . Wait ( )
return nil
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Mount ( container * Container ) error {
2014-04-29 08:08:19 +00:00
dir , err := daemon . driver . Get ( container . ID , container . GetMountLabel ( ) )
2013-11-01 01:07:54 +00:00
if err != nil {
2014-04-17 21:43:01 +00:00
return fmt . Errorf ( "Error getting container %s from driver %s: %s" , container . ID , daemon . driver , err )
2013-11-07 20:34:01 +00:00
}
2014-01-30 15:43:53 +00:00
if container . basefs == "" {
container . basefs = dir
} else if container . basefs != dir {
2014-10-30 05:31:19 +00:00
daemon . driver . Put ( container . ID )
2013-11-07 20:34:01 +00:00
return fmt . Errorf ( "Error: driver %s is returning inconsistent paths for container %s ('%s' then '%s')" ,
2014-04-17 21:43:01 +00:00
daemon . driver , container . ID , container . basefs , dir )
2013-11-01 01:07:54 +00:00
}
2013-11-07 20:34:01 +00:00
return nil
2013-11-01 01:07:54 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Unmount ( container * Container ) error {
daemon . driver . Put ( container . ID )
2013-11-07 20:34:01 +00:00
return nil
2013-11-01 01:07:54 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Changes ( container * Container ) ( [ ] archive . Change , error ) {
2014-09-11 03:30:52 +00:00
initID := fmt . Sprintf ( "%s-init" , container . ID )
return daemon . driver . Changes ( container . ID , initID )
2013-11-01 01:07:54 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Diff ( container * Container ) ( archive . Archive , error ) {
2014-09-11 03:30:52 +00:00
initID := fmt . Sprintf ( "%s-init" , container . ID )
return daemon . driver . Diff ( container . ID , initID )
2013-10-22 23:23:52 +00:00
}
2014-10-30 23:06:54 +00:00
func ( daemon * Daemon ) Run ( c * Container , pipes * execdriver . Pipes , startCallback execdriver . StartCallback ) ( execdriver . ExitStatus , error ) {
2014-04-17 21:43:01 +00:00
return daemon . execDriver . Run ( c . command , pipes , startCallback )
2014-01-10 22:26:29 +00:00
}
2014-05-21 21:06:18 +00:00
func ( daemon * Daemon ) Pause ( c * Container ) error {
2014-06-03 15:44:21 +00:00
if err := daemon . execDriver . Pause ( c . command ) ; err != nil {
2014-05-21 21:06:18 +00:00
return err
}
2014-08-31 15:20:35 +00:00
c . SetPaused ( )
2014-05-21 21:06:18 +00:00
return nil
}
func ( daemon * Daemon ) Unpause ( c * Container ) error {
2014-06-03 15:44:21 +00:00
if err := daemon . execDriver . Unpause ( c . command ) ; err != nil {
2014-05-21 21:06:18 +00:00
return err
}
2014-08-31 15:20:35 +00:00
c . SetUnpaused ( )
2014-05-21 21:06:18 +00:00
return nil
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Kill ( c * Container , sig int ) error {
return daemon . execDriver . Kill ( c . command , sig )
2014-01-10 22:26:29 +00:00
}
2013-11-14 06:08:08 +00:00
// Nuke kills all containers then removes all content
// from the content root, including images, volumes and
// container filesystems.
2014-04-17 21:43:01 +00:00
// Again: this will remove your entire docker daemon!
2014-08-06 08:12:22 +00:00
// FIXME: this is deprecated, and only used in legacy
// tests. Please remove.
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Nuke ( ) error {
2013-11-14 06:08:08 +00:00
var wg sync . WaitGroup
2014-04-17 21:43:01 +00:00
for _ , container := range daemon . List ( ) {
2013-11-14 06:08:08 +00:00
wg . Add ( 1 )
go func ( c * Container ) {
c . Kill ( )
wg . Done ( )
} ( container )
}
wg . Wait ( )
2014-04-17 21:43:01 +00:00
return os . RemoveAll ( daemon . config . Root )
2013-11-14 06:08:08 +00:00
}
// FIXME: this is a convenience function for integration tests
2014-04-17 21:43:01 +00:00
// which need direct access to daemon.graph.
2013-11-14 06:08:08 +00:00
// Once the tests switch to using engine and jobs, this method
// can go away.
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Graph ( ) * graph . Graph {
return daemon . graph
2013-11-14 06:08:08 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) Repositories ( ) * graph . TagStore {
return daemon . repositories
2014-03-08 02:42:29 +00:00
}
2014-08-09 22:30:27 +00:00
func ( daemon * Daemon ) Config ( ) * Config {
2014-04-17 21:43:01 +00:00
return daemon . config
2014-03-08 02:42:29 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) SystemConfig ( ) * sysinfo . SysInfo {
return daemon . sysInfo
2014-03-08 02:42:29 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) SystemInitPath ( ) string {
return daemon . sysInitPath
2014-03-08 02:42:29 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) GraphDriver ( ) graphdriver . Driver {
return daemon . driver
2014-03-08 02:42:29 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) ExecutionDriver ( ) execdriver . Driver {
return daemon . execDriver
2014-03-08 02:42:29 +00:00
}
2014-04-17 21:43:01 +00:00
func ( daemon * Daemon ) ContainerGraph ( ) * graphdb . Database {
return daemon . containerGraph
2014-03-08 02:42:29 +00:00
}
2014-07-29 05:22:58 +00:00
func ( daemon * Daemon ) ImageGetCached ( imgID string , config * runconfig . Config ) ( * image . Image , error ) {
// Retrieve all images
images , err := daemon . Graph ( ) . Map ( )
if err != nil {
return nil , err
}
// Store the tree in a map of map (map[parentId][childId])
imageMap := make ( map [ string ] map [ string ] struct { } )
for _ , img := range images {
if _ , exists := imageMap [ img . Parent ] ; ! exists {
imageMap [ img . Parent ] = make ( map [ string ] struct { } )
}
imageMap [ img . Parent ] [ img . ID ] = struct { } { }
}
// Loop on the children of the given image and check the config
var match * image . Image
for elem := range imageMap [ imgID ] {
2014-11-11 20:15:00 +00:00
img , ok := images [ elem ]
if ! ok {
return nil , fmt . Errorf ( "unable to find image %q" , elem )
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
func checkKernelAndArch ( ) error {
// Check for unsupported architectures
if runtime . GOARCH != "amd64" {
return fmt . Errorf ( "The Docker runtime currently only supports amd64 (not %s). This will change in the future. Aborting." , runtime . GOARCH )
}
// Check for unsupported kernel versions
// FIXME: it would be cleaner to not test for specific versions, but rather
// test for specific functionalities.
// Unfortunately we can't test for the feature "does not cause a kernel panic"
// without actually causing a kernel panic, so we need this workaround until
// the circumstances of pre-3.8 crashes are clearer.
// For details see http://github.com/docker/docker/issues/407
if k , err := kernel . GetKernelVersion ( ) ; err != nil {
2014-08-14 01:08:27 +00:00
log . Infof ( "WARNING: %s" , err )
2014-07-30 06:51:43 +00:00
} else {
if kernel . CompareKernelVersion ( k , & kernel . KernelVersionInfo { Kernel : 3 , Major : 8 , Minor : 0 } ) < 0 {
if os . Getenv ( "DOCKER_NOWARN_KERNEL_VERSION" ) == "" {
2014-07-24 20:37:44 +00:00
log . Infof ( "WARNING: You are running linux kernel version %s, which might be unstable running docker. Please upgrade your kernel to 3.8.0." , k . String ( ) )
2014-07-30 06:51:43 +00:00
}
}
}
return nil
}