2013-01-19 04:13:39 +04:00
package docker
import (
"container/list"
"fmt"
2013-11-08 04:35:26 +04:00
"github.com/dotcloud/docker/archive"
2014-01-30 06:34:43 +04:00
"github.com/dotcloud/docker/engine"
2014-01-10 04:03:22 +04:00
"github.com/dotcloud/docker/execdriver"
2014-01-11 08:22:39 +04:00
"github.com/dotcloud/docker/execdriver/chroot"
2014-01-10 04:03:22 +04:00
"github.com/dotcloud/docker/execdriver/lxc"
2013-11-08 00:34:01 +04:00
"github.com/dotcloud/docker/graphdriver"
2013-11-16 05:16:30 +04:00
"github.com/dotcloud/docker/graphdriver/aufs"
2013-11-22 00:45:48 +04:00
_ "github.com/dotcloud/docker/graphdriver/btrfs"
2013-11-16 03:48:24 +04:00
_ "github.com/dotcloud/docker/graphdriver/devmapper"
2013-11-23 02:58:19 +04:00
_ "github.com/dotcloud/docker/graphdriver/vfs"
2014-01-30 06:34:43 +04:00
_ "github.com/dotcloud/docker/networkdriver/lxc"
2014-01-24 00:17:28 +04:00
"github.com/dotcloud/docker/networkdriver/portallocator"
2013-12-21 20:02:06 +04:00
"github.com/dotcloud/docker/pkg/graphdb"
2014-01-16 02:36:13 +04:00
"github.com/dotcloud/docker/pkg/sysinfo"
2013-05-15 02:37:35 +04:00
"github.com/dotcloud/docker/utils"
2013-03-21 11:25:00 +04:00
"io"
2013-01-19 04:13:39 +04:00
"io/ioutil"
"os"
"path"
2013-12-13 01:34:26 +04:00
"regexp"
2013-01-30 00:15:39 +04:00
"sort"
2013-04-01 04:40:39 +04:00
"strings"
2013-11-14 10:08:08 +04:00
"sync"
2013-09-08 04:03:40 +04:00
"time"
2013-01-19 04:13:39 +04:00
)
2013-11-26 22:50:53 +04:00
// Set the max depth to the aufs default that most
// kernels are compiled with
// For more information see: http://sourceforge.net/p/aufs/aufs3-standalone/ci/aufs3.12/tree/config.mk
const MaxImageDepth = 127
2013-11-19 12:51:16 +04:00
2013-12-13 01:34:26 +04:00
var (
2013-12-17 06:17:22 +04:00
defaultDns = [ ] string { "8.8.8.8" , "8.8.4.4" }
validContainerNameChars = ` [a-zA-Z0-9_.-] `
validContainerNamePattern = regexp . MustCompile ( ` ^/? ` + validContainerNameChars + ` +$ ` )
2013-12-13 01:34:26 +04:00
)
2013-09-07 04:33:05 +04:00
2013-03-21 11:41:15 +04:00
type Runtime struct {
2013-02-28 23:52:07 +04:00
repository string
2013-11-26 02:42:22 +04:00
sysInitPath string
2013-02-28 23:52:07 +04:00
containers * list . List
2013-03-22 04:47:23 +04:00
graph * Graph
repositories * TagStore
2013-05-15 02:37:35 +04:00
idIndex * utils . TruncIndex
2014-01-16 02:36:13 +04:00
sysInfo * sysinfo . SysInfo
2013-04-06 05:00:10 +04:00
volumes * Graph
2013-05-16 04:17:33 +04:00
srv * Server
2013-10-05 06:25:15 +04:00
config * DaemonConfig
2013-11-16 03:55:45 +04:00
containerGraph * graphdb . Database
2013-11-08 00:34:01 +04:00
driver graphdriver . Driver
2014-01-10 04:03:22 +04:00
execDriver execdriver . Driver
2013-03-21 11:25:00 +04:00
}
2013-09-07 04:43:34 +04:00
// List returns an array of all containers registered in the runtime.
2013-03-21 11:41:15 +04:00
func ( runtime * Runtime ) List ( ) [ ] * Container {
2013-01-30 00:15:39 +04:00
containers := new ( History )
2013-03-21 11:41:15 +04:00
for e := runtime . containers . Front ( ) ; e != nil ; e = e . Next ( ) {
2013-01-30 00:15:39 +04:00
containers . Add ( e . Value . ( * Container ) )
2013-01-29 15:24:31 +04:00
}
2013-01-30 00:15:39 +04:00
return * containers
2013-01-19 04:13:39 +04:00
}
2013-03-21 11:41:15 +04:00
func ( runtime * Runtime ) getContainerElement ( id string ) * list . Element {
for e := runtime . containers . Front ( ) ; e != nil ; e = e . Next ( ) {
2013-01-19 04:13:39 +04:00
container := e . Value . ( * Container )
2013-06-04 22:00:22 +04:00
if container . ID == id {
2013-01-19 04:13:39 +04:00
return e
}
}
return nil
}
2013-09-07 04:43:34 +04: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.
2013-03-31 13:02:01 +04:00
func ( runtime * Runtime ) Get ( name string ) * Container {
2013-10-05 06:25:15 +04:00
if c , _ := runtime . GetByName ( name ) ; c != nil {
return c
}
2013-03-31 13:02:01 +04:00
id , err := runtime . idIndex . Get ( name )
if err != nil {
return nil
}
2013-10-05 06:25:15 +04:00
2013-03-21 11:41:15 +04:00
e := runtime . getContainerElement ( id )
2013-01-19 04:13:39 +04:00
if e == nil {
return nil
}
return e . Value . ( * Container )
}
2013-09-07 04:43:34 +04:00
// Exists returns a true if a container of the specified ID or name exists,
// false otherwise.
2013-03-21 11:41:15 +04:00
func ( runtime * Runtime ) Exists ( id string ) bool {
return runtime . Get ( id ) != nil
2013-01-19 04:13:39 +04:00
}
2013-03-21 11:41:15 +04:00
func ( runtime * Runtime ) containerRoot ( id string ) string {
return path . Join ( runtime . repository , id )
2013-03-21 11:25:00 +04:00
}
2013-10-05 06:25:15 +04:00
// Load reads the contents of a container from disk
2013-09-07 04:43:34 +04:00
// This is typically done at startup.
2013-10-05 06:25:15 +04:00
func ( runtime * Runtime ) load ( id string ) ( * Container , error ) {
2013-03-21 11:41:15 +04:00
container := & Container { root : runtime . containerRoot ( id ) }
2013-03-21 11:25:00 +04:00
if err := container . FromDisk ( ) ; err != nil {
return nil , err
}
2013-06-04 22:00:22 +04:00
if container . ID != id {
return container , fmt . Errorf ( "Container %s is stored at %s" , container . ID , id )
2013-03-21 11:25:00 +04:00
}
2013-11-22 00:21:03 +04:00
if container . State . IsRunning ( ) {
container . State . SetGhost ( true )
2013-04-11 20:26:17 +04:00
}
2013-01-19 04:13:39 +04:00
return container , nil
}
2013-06-04 22:00:22 +04:00
// Register makes a container object usable by the runtime as <container.ID>
2013-03-21 11:41:15 +04:00
func ( runtime * Runtime ) Register ( container * Container ) error {
2013-06-04 22:00:22 +04:00
if container . runtime != nil || runtime . Exists ( container . ID ) {
2013-03-21 11:25:00 +04:00
return fmt . Errorf ( "Container is already loaded" )
}
2013-06-04 22:00:22 +04:00
if err := validateID ( container . ID ) ; err != nil {
2013-03-21 11:25:00 +04:00
return err
}
2013-11-04 21:28:40 +04:00
if err := runtime . ensureName ( container ) ; err != nil {
return err
}
2013-04-01 04:40:39 +04:00
2013-11-08 00:34:01 +04:00
// Get the root filesystem from the driver
2014-01-30 19:43:53 +04:00
basefs , err := runtime . driver . Get ( container . ID )
2013-11-08 00:34:01 +04:00
if err != nil {
return fmt . Errorf ( "Error getting container filesystem %s from driver %s: %s" , container . ID , runtime . driver , err )
}
2013-12-06 01:18:02 +04:00
defer runtime . driver . Put ( container . ID )
2014-01-30 19:43:53 +04:00
container . basefs = basefs
2013-11-08 00:34:01 +04:00
2013-03-21 11:41:15 +04:00
container . runtime = runtime
2013-04-09 18:57:59 +04:00
2013-03-21 11:25:00 +04:00
// Attach to stdout and stderr
2013-05-15 02:37:35 +04:00
container . stderr = utils . NewWriteBroadcaster ( )
container . stdout = utils . NewWriteBroadcaster ( )
2013-03-21 11:25:00 +04:00
// Attach to stdin
if container . Config . OpenStdin {
container . stdin , container . stdinPipe = io . Pipe ( )
} else {
2013-05-15 02:37:35 +04:00
container . stdinPipe = utils . NopWriteCloser ( ioutil . Discard ) // Silently drop stdin
2013-03-21 11:25:00 +04:00
}
// done
2013-03-21 11:41:15 +04:00
runtime . containers . PushBack ( container )
2013-06-04 22:00:22 +04:00
runtime . idIndex . Add ( container . ID )
2013-04-19 23:08:43 +04:00
2013-04-25 06:01:23 +04: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
2013-11-22 00:21:03 +04:00
if container . State . IsRunning ( ) {
2014-01-15 23:46:25 +04:00
info := runtime . execDriver . Info ( container . ID )
if ! info . IsRunning ( ) {
2013-11-26 14:18:50 +04:00
utils . Debugf ( "Container %s was supposed to be running but is not." , container . ID )
2013-10-05 06:25:15 +04:00
if runtime . config . AutoRestart {
2013-06-04 17:51:12 +04:00
utils . Debugf ( "Restarting" )
2013-11-22 00:21:03 +04:00
container . State . SetGhost ( false )
container . State . SetStopped ( 0 )
2013-11-01 01:58:43 +04:00
if err := container . Start ( ) ; err != nil {
2013-06-04 17:51:12 +04:00
return err
}
} else {
utils . Debugf ( "Marking as stopped" )
2013-11-22 00:21:03 +04:00
container . State . SetStopped ( - 127 )
2013-06-04 17:51:12 +04:00
if err := container . ToDisk ( ) ; err != nil {
return err
2013-04-25 06:01:23 +04:00
}
}
2013-11-08 18:40:46 +04:00
} else {
utils . Debugf ( "Reconnecting to container %v" , container . ID )
2013-04-25 06:01:23 +04:00
2013-11-08 18:40:46 +04:00
if err := container . allocateNetwork ( ) ; err != nil {
return err
}
container . waitLock = make ( chan struct { } )
2014-01-14 03:02:12 +04:00
go container . monitor ( nil )
2013-11-08 18:40:46 +04:00
}
2014-01-22 04:38:17 +04:00
} else {
// When the container is not running, we still initialize the waitLock
// chan and close it. Receiving on nil chan blocks whereas receiving on a
// closed chan does not. In this case we do not want to block.
container . waitLock = make ( chan struct { } )
close ( container . waitLock )
2013-04-19 23:08:43 +04:00
}
2013-03-21 11:25:00 +04:00
return nil
}
2013-11-04 21:28:40 +04:00
func ( runtime * Runtime ) ensureName ( container * Container ) error {
if container . Name == "" {
name , err := generateRandomName ( runtime )
if err != nil {
2013-10-25 05:59:59 +04:00
name = utils . TruncateID ( container . ID )
2013-11-04 21:28:40 +04:00
}
container . Name = name
if err := container . ToDisk ( ) ; err != nil {
utils . Debugf ( "Error saving container name %s" , err )
}
if ! runtime . containerGraph . Exists ( name ) {
if _ , err := runtime . containerGraph . Set ( name , container . ID ) ; err != nil {
utils . Debugf ( "Setting default id - %s" , err )
}
}
}
return nil
}
2013-07-11 21:18:28 +04:00
func ( runtime * Runtime ) LogToDisk ( src * utils . WriteBroadcaster , dst , stream string ) error {
2013-03-21 11:25:00 +04:00
log , err := os . OpenFile ( dst , os . O_RDWR | os . O_APPEND | os . O_CREATE , 0600 )
if err != nil {
return err
}
2013-07-11 21:18:28 +04:00
src . AddWriter ( log , stream )
2013-03-21 11:25:00 +04:00
return nil
}
2013-09-07 04:43:34 +04:00
// Destroy unregisters a container from the runtime and cleanly removes its contents from the filesystem.
2013-03-21 11:41:15 +04:00
func ( runtime * Runtime ) Destroy ( container * Container ) error {
2013-05-07 22:18:13 +04:00
if container == nil {
return fmt . Errorf ( "The given container is <nil>" )
}
2013-06-04 22:00:22 +04:00
element := runtime . getContainerElement ( container . ID )
2013-01-19 04:13:39 +04:00
if element == nil {
2013-06-04 22:00:22 +04:00
return fmt . Errorf ( "Container %v not found - maybe it was already destroyed?" , container . ID )
2013-01-19 04:13:39 +04:00
}
2013-05-10 08:53:56 +04:00
if err := container . Stop ( 3 ) ; err != nil {
2013-01-19 04:13:39 +04:00
return err
}
2013-10-05 06:25:15 +04:00
2013-11-08 00:34:01 +04:00
if err := runtime . driver . Remove ( container . ID ) ; err != nil {
return fmt . Errorf ( "Driver %s failed to remove root filesystem %s: %s" , runtime . driver , container . ID , err )
2013-03-14 15:06:57 +04:00
}
2013-10-05 06:25:15 +04:00
2013-12-03 21:20:14 +04:00
initID := fmt . Sprintf ( "%s-init" , container . ID )
if err := runtime . driver . Remove ( initID ) ; err != nil {
return fmt . Errorf ( "Driver %s failed to remove init filesystem %s: %s" , runtime . driver , initID , err )
}
2013-10-05 06:25:15 +04:00
if _ , err := runtime . containerGraph . Purge ( container . ID ) ; err != nil {
utils . Debugf ( "Unable to remove container from link graph: %s" , err )
}
2013-03-21 11:25:00 +04:00
// Deregister the container before removing its directory, to avoid race conditions
2013-06-04 22:00:22 +04:00
runtime . idIndex . Delete ( container . ID )
2013-03-21 11:41:15 +04:00
runtime . containers . Remove ( element )
2013-03-21 11:25:00 +04:00
if err := os . RemoveAll ( container . root ) ; err != nil {
2013-06-04 22:00:22 +04:00
return fmt . Errorf ( "Unable to remove filesystem for %v: %v" , container . ID , err )
2013-01-19 04:13:39 +04:00
}
return nil
}
2013-03-21 11:41:15 +04:00
func ( runtime * Runtime ) restore ( ) error {
2013-08-30 02:59:34 +04:00
if os . Getenv ( "DEBUG" ) == "" && os . Getenv ( "TEST" ) == "" {
2013-12-18 22:43:42 +04:00
fmt . Printf ( "Loading containers: " )
2013-08-16 17:31:50 +04:00
}
2013-03-21 11:41:15 +04:00
dir , err := ioutil . ReadDir ( runtime . repository )
2013-01-19 04:13:39 +04:00
if err != nil {
return err
}
2013-10-25 03:49:28 +04:00
containers := make ( map [ string ] * Container )
2013-11-15 10:52:08 +04:00
currentDriver := runtime . driver . String ( )
2013-10-25 03:49:28 +04:00
2013-12-18 22:43:42 +04:00
for _ , v := range dir {
2013-03-21 11:25:00 +04:00
id := v . Name ( )
2013-10-05 06:25:15 +04:00
container , err := runtime . load ( id )
2013-12-18 22:43:42 +04:00
if os . Getenv ( "DEBUG" ) == "" && os . Getenv ( "TEST" ) == "" {
fmt . Print ( "." )
2013-08-16 17:31:50 +04:00
}
2013-01-19 04:13:39 +04:00
if err != nil {
2013-10-08 11:54:47 +04:00
utils . Errorf ( "Failed to load container %v: %v" , id , err )
2013-01-19 04:13:39 +04:00
continue
}
2013-11-15 10:52:08 +04:00
// Ignore the container if it does not support the current driver being used by the graph
if container . Driver == "" && currentDriver == "aufs" || container . Driver == currentDriver {
utils . Debugf ( "Loaded container %v" , container . ID )
containers [ container . ID ] = container
} else {
utils . Debugf ( "Cannot load container %s because it was created with another graph driver." , container . ID )
}
2013-10-05 06:25:15 +04:00
}
2013-10-25 03:49:28 +04:00
register := func ( container * Container ) {
if err := runtime . Register ( container ) ; err != nil {
utils . Debugf ( "Failed to register container %s: %s" , container . ID , err )
2013-10-05 06:25:15 +04:00
}
2013-10-25 03:49:28 +04:00
}
if entities := runtime . containerGraph . List ( "/" , - 1 ) ; entities != nil {
for _ , p := range entities . Paths ( ) {
2013-12-18 22:43:42 +04:00
if os . Getenv ( "DEBUG" ) == "" && os . Getenv ( "TEST" ) == "" {
fmt . Print ( "." )
}
2013-10-25 03:49:28 +04:00
e := entities [ p ]
if container , ok := containers [ e . ID ( ) ] ; ok {
register ( container )
delete ( containers , e . ID ( ) )
}
2013-10-05 06:25:15 +04:00
}
2013-10-25 03:49:28 +04:00
}
2013-10-24 21:25:07 +04:00
2013-10-25 03:49:28 +04:00
// Any containers that are left over do not exist in the graph
for _ , container := range containers {
2013-10-24 21:25:07 +04:00
// Try to set the default name for a container if it exists prior to links
2013-11-08 00:23:29 +04:00
container . Name , err = generateRandomName ( runtime )
2013-10-31 05:26:01 +04:00
if err != nil {
2013-10-25 05:59:59 +04:00
container . Name = utils . TruncateID ( container . ID )
2013-10-31 05:26:01 +04:00
}
2013-10-29 03:58:59 +04:00
2013-11-08 00:23:29 +04:00
if _ , err := runtime . containerGraph . Set ( container . Name , container . ID ) ; err != nil {
2013-10-24 21:25:07 +04:00
utils . Debugf ( "Setting default id - %s" , err )
}
2013-10-25 03:49:28 +04:00
register ( container )
2013-01-19 04:13:39 +04:00
}
2013-10-25 03:49:28 +04:00
2013-08-30 02:59:34 +04:00
if os . Getenv ( "DEBUG" ) == "" && os . Getenv ( "TEST" ) == "" {
2013-12-18 22:43:42 +04:00
fmt . Printf ( ": done.\n" )
2013-08-16 17:31:50 +04:00
}
2013-10-05 06:25:15 +04:00
2013-01-19 04:13:39 +04:00
return nil
}
2013-10-29 03:58:59 +04:00
// Create creates a new container from the given configuration with a given name.
func ( runtime * Runtime ) Create ( config * Config , name string ) ( * Container , [ ] string , error ) {
2013-09-07 04:33:05 +04:00
// Lookup image
img , err := runtime . repositories . LookupImage ( config . Image )
if err != nil {
2013-10-05 06:25:15 +04:00
return nil , nil , err
2013-09-07 04:33:05 +04:00
}
2013-11-19 12:51:16 +04:00
// We add 2 layers to the depth because the container's rw and
// init layer add to the restriction
depth , err := img . Depth ( )
if err != nil {
return nil , nil , err
}
if depth + 2 >= MaxImageDepth {
return nil , nil , fmt . Errorf ( "Cannot create container with more than %d parents" , MaxImageDepth )
}
2013-10-31 01:36:38 +04:00
checkDeprecatedExpose := func ( config * Config ) bool {
if config != nil {
if config . PortSpecs != nil {
for _ , p := range config . PortSpecs {
if strings . Contains ( p , ":" ) {
return true
}
}
}
2013-09-20 16:46:24 +04:00
}
2013-10-31 01:36:38 +04:00
return false
2013-09-07 04:33:05 +04:00
}
2013-10-31 01:36:38 +04:00
2013-10-30 22:13:10 +04:00
warnings := [ ] string { }
2013-10-31 01:36:38 +04:00
if checkDeprecatedExpose ( img . Config ) || checkDeprecatedExpose ( config ) {
warnings = append ( warnings , "The mapping to public ports on your host has been deprecated. Use -p to publish the ports." )
}
if img . Config != nil {
if err := MergeConfig ( config , img . Config ) ; err != nil {
return nil , nil , err
2013-10-30 22:13:10 +04:00
}
}
2013-09-07 04:33:05 +04:00
if len ( config . Entrypoint ) != 0 && config . Cmd == nil {
config . Cmd = [ ] string { }
} else if config . Cmd == nil || len ( config . Cmd ) == 0 {
2013-10-05 06:25:15 +04:00
return nil , nil , fmt . Errorf ( "No command specified" )
2013-09-07 04:33:05 +04:00
}
// Generate id
id := GenerateID ( )
2013-10-05 06:25:15 +04:00
2013-10-29 03:58:59 +04:00
if name == "" {
2013-10-31 05:26:01 +04:00
name , err = generateRandomName ( runtime )
if err != nil {
name = utils . TruncateID ( id )
}
2013-12-13 01:34:26 +04:00
} else {
2013-12-17 06:17:22 +04:00
if ! validContainerNamePattern . MatchString ( name ) {
return nil , nil , fmt . Errorf ( "Invalid container name (%s), only %s are allowed" , name , validContainerNameChars )
2013-12-13 01:34:26 +04:00
}
2013-10-29 03:58:59 +04:00
}
2013-12-13 01:34:26 +04:00
2013-10-29 03:58:59 +04:00
if name [ 0 ] != '/' {
name = "/" + name
}
// Set the enitity in the graph using the default name specified
if _ , err := runtime . containerGraph . Set ( name , id ) ; err != nil {
2013-12-06 03:22:21 +04:00
if ! strings . HasSuffix ( err . Error ( ) , "name are not unique" ) {
return nil , nil , err
}
conflictingContainer , err := runtime . GetByName ( name )
if err != nil {
if strings . Contains ( err . Error ( ) , "Could not find entity" ) {
return nil , nil , err
}
// Remove name and continue starting the container
if err := runtime . containerGraph . Delete ( name ) ; err != nil {
return nil , nil , err
}
} else {
2013-11-27 06:58:54 +04:00
nameAsKnownByUser := strings . TrimPrefix ( name , "/" )
2013-12-06 03:22:21 +04:00
return nil , nil , fmt . Errorf (
"Conflict, The name %s is already assigned to %s. You have to delete (or rename) that container to be able to assign %s to a container again." , nameAsKnownByUser ,
utils . TruncateID ( conflictingContainer . ID ) , nameAsKnownByUser )
2013-10-30 22:24:50 +04:00
}
2013-10-05 06:25:15 +04:00
}
2013-09-07 04:33:05 +04:00
// Generate default hostname
// FIXME: the lxc template no longer needs to set a default hostname
if config . Hostname == "" {
config . Hostname = id [ : 12 ]
}
var args [ ] string
var entrypoint string
if len ( config . Entrypoint ) != 0 {
entrypoint = config . Entrypoint [ 0 ]
args = append ( config . Entrypoint [ 1 : ] , config . Cmd ... )
} else {
entrypoint = config . Cmd [ 0 ]
args = config . Cmd [ 1 : ]
}
container := & Container {
// FIXME: we should generate the ID here instead of receiving it as an argument
ID : id ,
2013-11-22 04:41:41 +04:00
Created : time . Now ( ) . UTC ( ) ,
2013-09-07 04:33:05 +04:00
Path : entrypoint ,
Args : args , //FIXME: de-duplicate from config
Config : config ,
2013-11-01 01:58:43 +04:00
hostConfig : & HostConfig { } ,
2013-09-07 04:33:05 +04:00
Image : img . ID , // Always use the resolved image id
NetworkSettings : & NetworkSettings { } ,
2013-12-18 02:04:37 +04:00
Name : name ,
Driver : runtime . driver . String ( ) ,
2013-09-07 04:33:05 +04:00
}
container . root = runtime . containerRoot ( container . ID )
// Step 1: create the container directory.
// This doubles as a barrier to avoid race conditions.
if err := os . Mkdir ( container . root , 0700 ) ; err != nil {
2013-10-05 06:25:15 +04:00
return nil , nil , err
2013-09-07 04:33:05 +04:00
}
2013-11-08 00:34:01 +04:00
initID := fmt . Sprintf ( "%s-init" , container . ID )
if err := runtime . driver . Create ( initID , img . ID ) ; err != nil {
return nil , nil , err
}
initPath , err := runtime . driver . Get ( initID )
if err != nil {
return nil , nil , err
}
2013-12-06 01:18:02 +04:00
defer runtime . driver . Put ( initID )
2013-11-08 00:34:01 +04:00
if err := setupInitLayer ( initPath ) ; err != nil {
return nil , nil , err
}
if err := runtime . driver . Create ( container . ID , initID ) ; err != nil {
return nil , nil , err
}
2013-09-07 04:33:05 +04:00
resolvConf , err := utils . GetResolvConf ( )
if err != nil {
2013-10-05 06:25:15 +04:00
return nil , nil , err
2013-09-07 04:33:05 +04:00
}
2013-10-05 06:25:15 +04:00
if len ( config . Dns ) == 0 && len ( runtime . config . Dns ) == 0 && utils . CheckLocalDns ( resolvConf ) {
2013-09-07 04:33:05 +04:00
//"WARNING: Docker detected local DNS server on resolv.conf. Using default external servers: %v", defaultDns
2013-10-05 06:25:15 +04:00
runtime . config . Dns = defaultDns
2013-09-07 04:33:05 +04:00
}
// If custom dns exists, then create a resolv.conf for the container
2013-10-05 06:25:15 +04:00
if len ( config . Dns ) > 0 || len ( runtime . config . Dns ) > 0 {
2013-09-07 04:33:05 +04:00
var dns [ ] string
if len ( config . Dns ) > 0 {
dns = config . Dns
} else {
2013-10-05 06:25:15 +04:00
dns = runtime . config . Dns
2013-09-07 04:33:05 +04:00
}
container . ResolvConfPath = path . Join ( container . root , "resolv.conf" )
f , err := os . Create ( container . ResolvConfPath )
if err != nil {
2013-10-05 06:25:15 +04:00
return nil , nil , err
2013-09-07 04:33:05 +04:00
}
defer f . Close ( )
for _ , dns := range dns {
if _ , err := f . Write ( [ ] byte ( "nameserver " + dns + "\n" ) ) ; err != nil {
2013-10-05 06:25:15 +04:00
return nil , nil , err
2013-09-07 04:33:05 +04:00
}
}
} else {
container . ResolvConfPath = "/etc/resolv.conf"
}
// Step 2: save the container json
if err := container . ToDisk ( ) ; err != nil {
2013-10-05 06:25:15 +04:00
return nil , nil , err
2013-09-07 04:33:05 +04:00
}
2013-09-10 02:11:53 +04:00
2013-10-09 01:29:22 +04:00
// Step 3: register the container
2013-09-07 04:33:05 +04:00
if err := runtime . Register ( container ) ; err != nil {
2013-10-05 06:25:15 +04:00
return nil , nil , err
2013-09-07 04:33:05 +04:00
}
2013-10-05 06:25:15 +04:00
return container , warnings , nil
2013-09-07 04:33:05 +04:00
}
// Commit creates a new filesystem image from the current state of a container.
// The image can optionally be tagged into a repository
func ( runtime * Runtime ) Commit ( container * Container , repository , tag , comment , author string , config * Config ) ( * Image , error ) {
// FIXME: freeze the container before copying it to avoid data corruption?
// FIXME: this shouldn't be in commands.
2013-12-06 15:15:14 +04:00
if err := container . Mount ( ) ; err != nil {
2013-09-07 04:33:05 +04:00
return nil , err
}
2013-12-06 01:18:02 +04:00
defer container . Unmount ( )
2013-09-07 04:33:05 +04:00
rwTar , err := container . ExportRw ( )
if err != nil {
return nil , err
}
// Create a new image from the container's base layers + a new layer from container changes
img , err := runtime . graph . Create ( rwTar , container , comment , author , config )
if err != nil {
return nil , err
}
// Register the image if needed
if repository != "" {
if err := runtime . repositories . Set ( repository , tag , img . ID , true ) ; err != nil {
return img , err
}
}
return img , nil
}
2013-11-14 10:08:08 +04:00
func getFullName ( name string ) ( string , error ) {
2013-11-04 21:28:40 +04:00
if name == "" {
return "" , fmt . Errorf ( "Container name cannot be empty" )
}
2013-10-25 03:49:28 +04:00
if name [ 0 ] != '/' {
name = "/" + name
}
2013-11-04 21:28:40 +04:00
return name , nil
2013-10-25 03:49:28 +04:00
}
func ( runtime * Runtime ) GetByName ( name string ) ( * Container , error ) {
2014-01-02 03:06:50 +04:00
fullName , err := getFullName ( name )
2013-11-04 21:28:40 +04:00
if err != nil {
return nil , err
}
entity := runtime . containerGraph . Get ( fullName )
2013-10-05 06:25:15 +04:00
if entity == nil {
return nil , fmt . Errorf ( "Could not find entity for %s" , name )
}
e := runtime . getContainerElement ( entity . ID ( ) )
if e == nil {
return nil , fmt . Errorf ( "Could not find container for entity id %s" , entity . ID ( ) )
}
return e . Value . ( * Container ) , nil
}
func ( runtime * Runtime ) Children ( name string ) ( map [ string ] * Container , error ) {
2014-01-02 03:06:50 +04:00
name , err := getFullName ( name )
2013-11-04 21:28:40 +04:00
if err != nil {
return nil , err
}
2013-10-05 06:25:15 +04:00
children := make ( map [ string ] * Container )
2013-11-16 03:55:45 +04:00
err = runtime . containerGraph . Walk ( name , func ( p string , e * graphdb . Entity ) error {
2013-10-05 06:25:15 +04:00
c := runtime . Get ( e . ID ( ) )
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
}
2013-10-29 03:58:59 +04:00
func ( runtime * Runtime ) RegisterLink ( parent , child * Container , alias string ) error {
fullName := path . Join ( parent . Name , alias )
if ! runtime . containerGraph . Exists ( fullName ) {
_ , err := runtime . containerGraph . Set ( fullName , child . ID )
2013-10-05 06:25:15 +04:00
return err
}
2013-10-29 03:58:59 +04:00
return nil
2013-10-05 06:25:15 +04:00
}
2013-03-31 13:02:01 +04:00
// FIXME: harmonize with NewGraph()
2014-01-30 06:34:43 +04:00
func NewRuntime ( config * DaemonConfig , eng * engine . Engine ) ( * Runtime , error ) {
runtime , err := NewRuntimeFromDirectory ( config , eng )
2013-04-19 07:47:24 +04:00
if err != nil {
return nil , err
}
return runtime , nil
2013-01-19 04:13:39 +04:00
}
2014-01-30 06:34:43 +04:00
func NewRuntimeFromDirectory ( config * DaemonConfig , eng * engine . Engine ) ( * Runtime , error ) {
2013-11-15 11:02:09 +04:00
// Set the default driver
graphdriver . DefaultDriver = config . GraphDriver
2013-11-08 00:34:01 +04:00
// Load storage driver
driver , err := graphdriver . New ( config . Root )
if err != nil {
return nil , err
}
2013-11-08 05:01:57 +04:00
utils . Debugf ( "Using graph driver %s" , driver )
2013-11-08 00:34:01 +04:00
2013-10-23 12:09:16 +04:00
runtimeRepo := path . Join ( config . Root , "containers" )
2013-03-14 05:48:50 +04:00
2013-03-29 04:12:23 +04:00
if err := os . MkdirAll ( runtimeRepo , 0700 ) ; err != nil && ! os . IsExist ( err ) {
2013-03-14 05:48:50 +04:00
return nil , err
}
2013-11-19 15:27:59 +04:00
if ad , ok := driver . ( * aufs . Driver ) ; ok {
2013-12-18 22:43:42 +04:00
utils . Debugf ( "Migrating existing containers" )
2013-11-19 05:20:03 +04:00
if err := ad . Migrate ( config . Root , setupInitLayer ) ; err != nil {
2013-11-16 05:16:30 +04:00
return nil , err
}
}
2013-12-18 22:43:42 +04:00
utils . Debugf ( "Creating images graph" )
2013-11-08 00:34:01 +04:00
g , err := NewGraph ( path . Join ( config . Root , "graph" ) , driver )
2013-02-27 05:45:46 +04:00
if err != nil {
return nil , err
}
2013-11-15 14:30:28 +04:00
// We don't want to use a complex driver like aufs or devmapper
// for volumes, just a plain filesystem
2013-11-23 02:58:19 +04:00
volumesDriver , err := graphdriver . GetDriver ( "vfs" , config . Root )
2013-04-06 05:00:10 +04:00
if err != nil {
return nil , err
}
2013-12-18 22:43:42 +04:00
utils . Debugf ( "Creating volumes graph" )
2013-11-15 14:30:28 +04:00
volumes , err := NewGraph ( path . Join ( config . Root , "volumes" ) , volumesDriver )
2013-04-06 05:00:10 +04:00
if err != nil {
return nil , err
}
2013-12-18 22:43:42 +04:00
utils . Debugf ( "Creating repository list" )
2013-11-19 14:32:08 +04:00
repositories , err := NewTagStore ( path . Join ( config . Root , "repositories-" + driver . String ( ) ) , g )
2013-03-22 04:35:49 +04:00
if err != nil {
return nil , fmt . Errorf ( "Couldn't create Tag store: %s" , err )
}
2014-01-30 06:34:43 +04:00
if ! config . DisableNetwork {
job := eng . Job ( "init_networkdriver" )
job . SetenvBool ( "EnableIptables" , config . EnableIptables )
job . SetenvBool ( "InterContainerCommunication" , config . InterContainerCommunication )
job . SetenvBool ( "EnableIpForward" , config . EnableIpForward )
job . Setenv ( "BridgeIface" , config . BridgeIface )
job . Setenv ( "BridgeIP" , config . BridgeIP )
2014-01-30 23:25:06 +04:00
job . Setenv ( "DefaultBindingIP" , config . DefaultIp . String ( ) )
2014-01-30 06:34:43 +04:00
if err := job . Run ( ) ; err != nil {
return nil , err
}
2013-04-04 16:33:28 +04:00
}
2013-10-05 06:25:15 +04:00
2013-11-16 03:55:45 +04:00
graphdbPath := path . Join ( config . Root , "linkgraph.db" )
2013-12-19 09:14:16 +04:00
graph , err := graphdb . NewSqliteConn ( graphdbPath )
2013-02-26 02:06:22 +04:00
if err != nil {
return nil , err
}
2013-10-05 06:25:15 +04:00
2013-11-26 02:42:22 +04:00
localCopy := path . Join ( config . Root , "init" , fmt . Sprintf ( "dockerinit-%s" , VERSION ) )
sysInitPath := utils . DockerInitPath ( localCopy )
if sysInitPath == "" {
return nil , fmt . Errorf ( "Could not locate dockerinit: This usually means docker was built incorrectly. See http://docs.docker.io/en/latest/contributing/devenvironment for official build instructions." )
}
2013-12-05 13:10:41 +04: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-26 02:42:22 +04:00
return nil , err
}
if _ , err := utils . CopyFile ( sysInitPath , localCopy ) ; err != nil {
return nil , err
}
2013-12-05 13:10:41 +04:00
if err := os . Chmod ( localCopy , 0700 ) ; err != nil {
2013-11-26 02:42:22 +04:00
return nil , err
}
2013-12-05 13:10:41 +04:00
sysInitPath = localCopy
2013-11-26 02:42:22 +04:00
}
2014-01-16 02:36:13 +04:00
sysInfo := sysinfo . New ( false )
2014-01-15 23:46:25 +04:00
/ *
temporarilly disabled .
* /
if false {
var ed execdriver . Driver
if driver := os . Getenv ( "EXEC_DRIVER" ) ; driver == "lxc" {
2014-01-16 02:36:13 +04:00
ed , err = lxc . NewDriver ( config . Root , sysInfo . AppArmor )
2014-01-15 23:46:25 +04:00
} else {
ed , err = chroot . NewDriver ( )
}
if ed != nil {
}
2014-01-11 08:22:39 +04:00
}
2014-01-16 02:36:13 +04:00
ed , err := lxc . NewDriver ( config . Root , sysInfo . AppArmor )
2014-01-10 04:03:22 +04:00
if err != nil {
return nil , err
}
2013-03-21 11:41:15 +04:00
runtime := & Runtime {
2013-03-29 04:12:23 +04:00
repository : runtimeRepo ,
2013-02-28 23:52:07 +04:00
containers : list . New ( ) ,
2013-03-22 04:35:49 +04:00
graph : g ,
repositories : repositories ,
2013-05-15 02:37:35 +04:00
idIndex : utils . NewTruncIndex ( ) ,
2014-01-16 02:36:13 +04:00
sysInfo : sysInfo ,
2013-04-06 05:00:10 +04:00
volumes : volumes ,
2013-10-05 06:25:15 +04:00
config : config ,
containerGraph : graph ,
2013-11-08 03:58:03 +04:00
driver : driver ,
2013-11-26 02:42:22 +04:00
sysInitPath : sysInitPath ,
2014-01-10 04:03:22 +04:00
execDriver : ed ,
2013-01-19 04:13:39 +04:00
}
2013-03-21 11:41:15 +04:00
if err := runtime . restore ( ) ; err != nil {
2013-01-19 04:13:39 +04:00
return nil , err
}
2013-03-21 11:41:15 +04:00
return runtime , nil
2013-01-19 04:13:39 +04:00
}
2013-01-30 00:15:39 +04:00
2013-10-23 03:23:52 +04:00
func ( runtime * Runtime ) Close ( ) error {
2013-11-20 05:08:21 +04:00
errorsStrings := [ ] string { }
2014-01-24 00:17:28 +04:00
if err := portallocator . ReleaseAll ( ) ; err != nil {
utils . Errorf ( "portallocator.ReleaseAll(): %s" , err )
2013-11-20 05:08:21 +04:00
errorsStrings = append ( errorsStrings , err . Error ( ) )
}
if err := runtime . driver . Cleanup ( ) ; err != nil {
utils . Errorf ( "runtime.driver.Cleanup(): %s" , err . Error ( ) )
errorsStrings = append ( errorsStrings , err . Error ( ) )
}
if err := runtime . containerGraph . Close ( ) ; err != nil {
utils . Errorf ( "runtime.containerGraph.Close(): %s" , err . Error ( ) )
errorsStrings = append ( errorsStrings , err . Error ( ) )
}
if len ( errorsStrings ) > 0 {
return fmt . Errorf ( "%s" , strings . Join ( errorsStrings , ", " ) )
}
return nil
2013-10-23 03:23:52 +04:00
}
2013-11-01 05:07:54 +04:00
func ( runtime * Runtime ) Mount ( container * Container ) error {
2013-11-08 00:34:01 +04:00
dir , err := runtime . driver . Get ( container . ID )
2013-11-01 05:07:54 +04:00
if err != nil {
2013-11-08 00:34:01 +04:00
return fmt . Errorf ( "Error getting container %s from driver %s: %s" , container . ID , runtime . driver , err )
}
2014-01-30 19:43:53 +04:00
if container . basefs == "" {
container . basefs = dir
} else if container . basefs != dir {
2013-11-08 00:34:01 +04:00
return fmt . Errorf ( "Error: driver %s is returning inconsistent paths for container %s ('%s' then '%s')" ,
2014-01-30 19:43:53 +04:00
runtime . driver , container . ID , container . basefs , dir )
2013-11-01 05:07:54 +04:00
}
2013-11-08 00:34:01 +04:00
return nil
2013-11-01 05:07:54 +04:00
}
func ( runtime * Runtime ) Unmount ( container * Container ) error {
2013-12-06 01:18:02 +04:00
runtime . driver . Put ( container . ID )
2013-11-08 00:34:01 +04:00
return nil
2013-11-01 05:07:54 +04:00
}
2013-11-08 04:35:26 +04:00
func ( runtime * Runtime ) Changes ( container * Container ) ( [ ] archive . Change , error ) {
2013-11-12 05:17:38 +04:00
if differ , ok := runtime . driver . ( graphdriver . Differ ) ; ok {
return differ . Changes ( container . ID )
}
cDir , err := runtime . driver . Get ( container . ID )
if err != nil {
return nil , fmt . Errorf ( "Error getting container rootfs %s from driver %s: %s" , container . ID , container . runtime . driver , err )
}
2013-12-06 01:18:02 +04:00
defer runtime . driver . Put ( container . ID )
2013-11-12 05:17:38 +04:00
initDir , err := runtime . driver . Get ( container . ID + "-init" )
if err != nil {
return nil , fmt . Errorf ( "Error getting container init rootfs %s from driver %s: %s" , container . ID , container . runtime . driver , err )
}
2013-12-06 01:18:02 +04:00
defer runtime . driver . Put ( container . ID + "-init" )
2013-11-12 05:17:38 +04:00
return archive . ChangesDirs ( cDir , initDir )
2013-11-01 05:07:54 +04:00
}
2013-11-11 19:47:36 +04:00
func ( runtime * Runtime ) Diff ( container * Container ) ( archive . Archive , error ) {
2013-11-12 05:17:38 +04:00
if differ , ok := runtime . driver . ( graphdriver . Differ ) ; ok {
return differ . Diff ( container . ID )
}
changes , err := runtime . Changes ( container )
if err != nil {
return nil , err
}
cDir , err := runtime . driver . Get ( container . ID )
if err != nil {
return nil , fmt . Errorf ( "Error getting container rootfs %s from driver %s: %s" , container . ID , container . runtime . driver , err )
}
2013-12-06 01:18:02 +04:00
archive , err := archive . ExportChanges ( cDir , changes )
if err != nil {
return nil , err
}
return EofReader ( archive , func ( ) { runtime . driver . Put ( container . ID ) } ) , nil
2013-10-23 03:23:52 +04:00
}
2014-01-14 03:02:12 +04:00
func ( runtime * Runtime ) Run ( c * Container , startCallback execdriver . StartCallback ) ( int , error ) {
2014-01-21 04:05:07 +04:00
return runtime . execDriver . Run ( c . command , startCallback )
2014-01-11 02:26:29 +04:00
}
func ( runtime * Runtime ) Kill ( c * Container , sig int ) error {
2014-01-21 04:05:07 +04:00
return runtime . execDriver . Kill ( c . command , sig )
2014-01-11 02:26:29 +04:00
}
2014-01-21 06:43:54 +04:00
func ( runtime * Runtime ) RestoreCommand ( c * Container ) error {
2014-01-21 06:07:18 +04:00
return runtime . execDriver . Restore ( c . command )
2014-01-11 02:26:29 +04:00
}
2013-11-14 10:08:08 +04:00
// Nuke kills all containers then removes all content
// from the content root, including images, volumes and
// container filesystems.
// Again: this will remove your entire docker runtime!
func ( runtime * Runtime ) Nuke ( ) error {
var wg sync . WaitGroup
for _ , container := range runtime . List ( ) {
wg . Add ( 1 )
go func ( c * Container ) {
c . Kill ( )
wg . Done ( )
} ( container )
}
wg . Wait ( )
runtime . Close ( )
return os . RemoveAll ( runtime . config . Root )
}
// FIXME: this is a convenience function for integration tests
// which need direct access to runtime.graph.
// Once the tests switch to using engine and jobs, this method
// can go away.
func ( runtime * Runtime ) Graph ( ) * Graph {
return runtime . graph
}
2013-09-07 04:43:34 +04:00
// History is a convenience type for storing a list of containers,
// ordered by creation date.
2013-01-30 00:15:39 +04:00
type History [ ] * Container
func ( history * History ) Len ( ) int {
return len ( * history )
}
func ( history * History ) Less ( i , j int ) bool {
containers := * history
return containers [ j ] . When ( ) . Before ( containers [ i ] . When ( ) )
}
func ( history * History ) Swap ( i , j int ) {
containers := * history
tmp := containers [ i ]
containers [ i ] = containers [ j ]
containers [ j ] = tmp
}
func ( history * History ) Add ( container * Container ) {
* history = append ( * history , container )
sort . Sort ( history )
}