From d17d5e16aec04980c7cc1c2441ffa3626f81705e Mon Sep 17 00:00:00 2001
From: Zilin Du <zilin.du@gmail.com>
Date: Tue, 8 Oct 2013 14:29:22 -0700
Subject: [PATCH 001/184] replace 127.0.0.1 by the assigned IP address in the
 container's /etc/hosts file. Upstream-commit:
 7d95d300abd9d9cc811713e53fd41adec66f2e00 Component: engine

---
 components/engine/container.go | 28 ++++++++++++++++++++++++++++
 components/engine/runtime.go   | 27 +--------------------------
 2 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index 316e0d259f..c6317c087e 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -579,10 +579,12 @@ func (container *Container) Start(hostConfig *HostConfig) error {
 	}
 	if container.runtime.networkManager.disabled {
 		container.Config.NetworkDisabled = true
+		container.buildHostnameAndHostsFiles("127.0.0.1")
 	} else {
 		if err := container.allocateNetwork(); err != nil {
 			return err
 		}
+		container.buildHostnameAndHostsFiles(container.NetworkSettings.IPAddress)
 	}
 
 	// Make sure the config is compatible with the current kernel
@@ -868,6 +870,32 @@ func (container *Container) StderrPipe() (io.ReadCloser, error) {
 	return utils.NewBufReader(reader), nil
 }
 
+func (container *Container) buildHostnameAndHostsFiles(IP string) {
+	container.HostnamePath = path.Join(container.root, "hostname")
+	ioutil.WriteFile(container.HostnamePath, []byte(container.Config.Hostname+"\n"), 0644)
+
+	hostsContent := []byte(`
+127.0.0.1	localhost
+::1		localhost ip6-localhost ip6-loopback
+fe00::0		ip6-localnet
+ff00::0		ip6-mcastprefix
+ff02::1		ip6-allnodes
+ff02::2		ip6-allrouters
+`)
+
+	container.HostsPath = path.Join(container.root, "hosts")
+
+	if container.Config.Domainname != "" {
+		hostsContent = append([]byte(fmt.Sprintf("::1\t\t%s.%s %s\n", container.Config.Hostname, container.Config.Domainname, container.Config.Hostname)), hostsContent...)
+		hostsContent = append([]byte(fmt.Sprintf("%s\t%s.%s %s\n", IP, container.Config.Hostname, container.Config.Domainname, container.Config.Hostname)), hostsContent...)
+	} else {
+		hostsContent = append([]byte(fmt.Sprintf("::1\t\t%s\n", container.Config.Hostname)), hostsContent...)
+		hostsContent = append([]byte(fmt.Sprintf("%s\t%s\n", IP, container.Config.Hostname)), hostsContent...)
+	}
+
+	ioutil.WriteFile(container.HostsPath, hostsContent, 0644)
+}
+
 func (container *Container) allocateNetwork() error {
 	if container.Config.NetworkDisabled {
 		return nil
diff --git a/components/engine/runtime.go b/components/engine/runtime.go
index d77ecca722..e4bca0457c 100644
--- a/components/engine/runtime.go
+++ b/components/engine/runtime.go
@@ -368,32 +368,7 @@ func (runtime *Runtime) Create(config *Config) (*Container, error) {
 		return nil, err
 	}
 
-	// Step 3: if hostname, build hostname and hosts files
-	container.HostnamePath = path.Join(container.root, "hostname")
-	ioutil.WriteFile(container.HostnamePath, []byte(container.Config.Hostname+"\n"), 0644)
-
-	hostsContent := []byte(`
-127.0.0.1	localhost
-::1		localhost ip6-localhost ip6-loopback
-fe00::0		ip6-localnet
-ff00::0		ip6-mcastprefix
-ff02::1		ip6-allnodes
-ff02::2		ip6-allrouters
-`)
-
-	container.HostsPath = path.Join(container.root, "hosts")
-
-	if container.Config.Domainname != "" {
-		hostsContent = append([]byte(fmt.Sprintf("::1\t\t%s.%s %s\n", container.Config.Hostname, container.Config.Domainname, container.Config.Hostname)), hostsContent...)
-		hostsContent = append([]byte(fmt.Sprintf("127.0.0.1\t%s.%s %s\n", container.Config.Hostname, container.Config.Domainname, container.Config.Hostname)), hostsContent...)
-	} else {
-		hostsContent = append([]byte(fmt.Sprintf("::1\t\t%s\n", container.Config.Hostname)), hostsContent...)
-		hostsContent = append([]byte(fmt.Sprintf("127.0.0.1\t%s\n", container.Config.Hostname)), hostsContent...)
-	}
-
-	ioutil.WriteFile(container.HostsPath, hostsContent, 0644)
-
-	// Step 4: register the container
+	// Step 3: register the container
 	if err := runtime.Register(container); err != nil {
 		return nil, err
 	}

From 8ac7033a81e9c1fc0913d10a421d805b128d6e34 Mon Sep 17 00:00:00 2001
From: Zilin Du <zilin.du@gmail.com>
Date: Thu, 10 Oct 2013 09:44:48 -0700
Subject: [PATCH 002/184] change 127.0.0.1 -> 127.0.1.1 & remove ::1 ->
 hostname mapping Upstream-commit: c2912c82aa7398a10d39fe114eb6328abd636d82
 Component: engine

---
 components/engine/container.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index c6317c087e..555f4a524e 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -579,7 +579,7 @@ func (container *Container) Start(hostConfig *HostConfig) error {
 	}
 	if container.runtime.networkManager.disabled {
 		container.Config.NetworkDisabled = true
-		container.buildHostnameAndHostsFiles("127.0.0.1")
+		container.buildHostnameAndHostsFiles("127.0.1.1")
 	} else {
 		if err := container.allocateNetwork(); err != nil {
 			return err
@@ -886,10 +886,8 @@ ff02::2		ip6-allrouters
 	container.HostsPath = path.Join(container.root, "hosts")
 
 	if container.Config.Domainname != "" {
-		hostsContent = append([]byte(fmt.Sprintf("::1\t\t%s.%s %s\n", container.Config.Hostname, container.Config.Domainname, container.Config.Hostname)), hostsContent...)
 		hostsContent = append([]byte(fmt.Sprintf("%s\t%s.%s %s\n", IP, container.Config.Hostname, container.Config.Domainname, container.Config.Hostname)), hostsContent...)
 	} else {
-		hostsContent = append([]byte(fmt.Sprintf("::1\t\t%s\n", container.Config.Hostname)), hostsContent...)
 		hostsContent = append([]byte(fmt.Sprintf("%s\t%s\n", IP, container.Config.Hostname)), hostsContent...)
 	}
 

From 78b1cb1fcb80ac90f625d8e374054ca60bdf1019 Mon Sep 17 00:00:00 2001
From: Mathieu Le Marec - Pasquet <kiorky@cryptelium.net>
Date: Fri, 25 Oct 2013 18:41:03 +0200
Subject: [PATCH 003/184] Do not drop sys_boot

This fixes #2391
Upstream-commit: b64ce8e33cb0a63ede881da78580e37ea4f0d6a7
Component: engine
---
 components/engine/AUTHORS         | 1 +
 components/engine/lxc_template.go | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/components/engine/AUTHORS b/components/engine/AUTHORS
index 7b1bba49e7..13872ecebf 100644
--- a/components/engine/AUTHORS
+++ b/components/engine/AUTHORS
@@ -117,6 +117,7 @@ Marko Mikulicic <mmikulicic@gmail.com>
 Markus Fix <lispmeister@gmail.com>
 Martin Redmond <martin@tinychat.com>
 Matt Apperson <me@mattapperson.com>
+Mathieu Le Marec - Pasquet <kiorky@cryptelium.net>
 Matt Bachmann <bachmann.matt@gmail.com>
 Matthew Mueller <mattmuelle@gmail.com>
 Maxim Treskin <zerthurd@gmail.com>
diff --git a/components/engine/lxc_template.go b/components/engine/lxc_template.go
index 37232a89d3..315e84744a 100644
--- a/components/engine/lxc_template.go
+++ b/components/engine/lxc_template.go
@@ -113,7 +113,7 @@ lxc.mount.entry = {{$realPath}} {{$ROOTFS}}/{{$virtualPath}} none bind,{{ if ind
 #  (Note: 'lxc.cap.keep' is coming soon and should replace this under the
 #         security principle 'deny all unless explicitly permitted', see
 #         http://sourceforge.net/mailarchive/message.php?msg_id=31054627 )
-lxc.cap.drop = audit_control audit_write mac_admin mac_override mknod setpcap sys_admin sys_boot sys_module sys_nice sys_pacct sys_rawio sys_resource sys_time sys_tty_config
+lxc.cap.drop = audit_control audit_write mac_admin mac_override mknod setpcap sys_admin sys_module sys_nice sys_pacct sys_rawio sys_resource sys_time sys_tty_config
 {{end}}
 
 # limits

From a1a49c89198b79e666a50901863423f8d6246fb3 Mon Sep 17 00:00:00 2001
From: Aanand Prasad <aanand.prasad@gmail.com>
Date: Thu, 3 Oct 2013 18:23:29 +0000
Subject: [PATCH 004/184] Container memory limit can be specified in kilobytes,
 megabytes or gigabytes

    -m 10  # 10 bytes
    -m 10b # 10 bytes
    -m 10k # 10240 bytes (10 * 1024)
    -m 10m # 10485760 bytes (10 * 1024 * 1024)
    -m 10g # 10737418240 bytes (10 * 1024 * 1024 * 1024)

Units are case-insensitive, and 'kb', 'mb' and 'gb' are equivalent to 'k', 'm' and 'g'.
Upstream-commit: 9ee9d2f9959390d1cda56accbbd975df18d157ad
Component: engine
---
 components/engine/container.go                | 22 ++++++++++---
 .../engine/docs/sources/commandline/cli.rst   |  2 +-
 components/engine/utils/utils.go              | 32 ++++++++++++++++++
 components/engine/utils/utils_test.go         | 33 +++++++++++++++++++
 4 files changed, 83 insertions(+), 6 deletions(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index e67c8f5b0b..30c010a66c 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -162,7 +162,7 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 	cmd.Var(flAttach, "a", "Attach to stdin, stdout or stderr.")
 	flStdin := cmd.Bool("i", false, "Keep stdin open even if not attached")
 	flTty := cmd.Bool("t", false, "Allocate a pseudo-tty")
-	flMemory := cmd.Int64("m", 0, "Memory limit (in bytes)")
+	flMemoryString := cmd.String("m", "", "Memory limit (format: <number><optional unit>, where unit = b, k, m or g)")
 	flContainerIDFile := cmd.String("cidfile", "", "Write the container ID to the file")
 	flNetwork := cmd.Bool("n", true, "Enable networking for this container")
 	flPrivileged := cmd.Bool("privileged", false, "Give extended privileges to this container")
@@ -170,9 +170,9 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 	cmd.Bool("sig-proxy", true, "Proxify all received signal to the process (even in non-tty mode)")
 	cmd.String("name", "", "Assign a name to the container")
 
-	if capabilities != nil && *flMemory > 0 && !capabilities.MemoryLimit {
+	if capabilities != nil && *flMemoryString != "" && !capabilities.MemoryLimit {
 		//fmt.Fprintf(stdout, "WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.\n")
-		*flMemory = 0
+		*flMemoryString = ""
 	}
 
 	flCpuShares := cmd.Int64("c", 0, "CPU shares (relative weight)")
@@ -239,6 +239,18 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 		}
 	}
 
+	var flMemory int64
+
+	if *flMemoryString != "" {
+		parsedMemory, err := utils.RAMInBytes(*flMemoryString)
+
+		if err != nil {
+			return nil, nil, cmd, err
+		}
+
+		flMemory = parsedMemory
+	}
+
 	var binds []string
 
 	// add any bind targets to the list of container volumes
@@ -306,7 +318,7 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 		Tty:             *flTty,
 		NetworkDisabled: !*flNetwork,
 		OpenStdin:       *flStdin,
-		Memory:          *flMemory,
+		Memory:          flMemory,
 		CpuShares:       *flCpuShares,
 		AttachStdin:     flAttach.Get("stdin"),
 		AttachStdout:    flAttach.Get("stdout"),
@@ -330,7 +342,7 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 		Links:           flLinks,
 	}
 
-	if capabilities != nil && *flMemory > 0 && !capabilities.SwapLimit {
+	if capabilities != nil && flMemory > 0 && !capabilities.SwapLimit {
 		//fmt.Fprintf(stdout, "WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.\n")
 		config.MemorySwap = -1
 	}
diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index c6579da355..a3c2b9eeda 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -568,7 +568,7 @@ network communication.
       -h="": Container host name
       -i=false: Keep stdin open even if not attached
       -privileged=false: Give extended privileges to this container
-      -m=0: Memory limit (in bytes)
+      -m="": Memory limit (format: <number><optional unit>, where unit = b, k, m or g)
       -n=true: Enable networking for this container
       -p=[]: Map a network port to the container
       -rm=false: Automatically remove the container when it exits (incompatible with -d)
diff --git a/components/engine/utils/utils.go b/components/engine/utils/utils.go
index d53094397f..c37b3cc6a1 100644
--- a/components/engine/utils/utils.go
+++ b/components/engine/utils/utils.go
@@ -20,6 +20,7 @@ import (
 	"strings"
 	"sync"
 	"time"
+	"regexp"
 )
 
 var (
@@ -176,6 +177,37 @@ func HumanSize(size int64) string {
 	return fmt.Sprintf("%.4g %s", sizef, units[i])
 }
 
+// Parses a human-readable string representing an amount of RAM
+// in bytes, kibibytes, mebibytes or gibibytes, and returns the
+// number of bytes, or -1 if the string is unparseable.
+// Units are case-insensitive, and the 'b' suffix is optional.
+func RAMInBytes(size string) (bytes int64, err error) {
+	re, error := regexp.Compile("^(\\d+)([kKmMgG])?[bB]?$")
+	if error != nil { return -1, error }
+
+	matches := re.FindStringSubmatch(size)
+
+	if len(matches) != 3 {
+		return -1, fmt.Errorf("Invalid size: '%s'", size)
+	}
+
+	memLimit, error := strconv.ParseInt(matches[1], 10, 0)
+	if error != nil { return -1, error }
+ 
+	unit := strings.ToLower(matches[2])
+
+	if unit == "k" {
+		memLimit *= 1024
+	} else if unit == "m" {
+		memLimit *= 1024*1024
+	} else if unit == "g" {
+		memLimit *= 1024*1024*1024
+	}
+
+	return memLimit, nil
+}
+
+
 func Trunc(s string, maxlen int) string {
 	if len(s) <= maxlen {
 		return s
diff --git a/components/engine/utils/utils_test.go b/components/engine/utils/utils_test.go
index 49f19bf759..8775bd0891 100644
--- a/components/engine/utils/utils_test.go
+++ b/components/engine/utils/utils_test.go
@@ -265,6 +265,39 @@ func TestHumanSize(t *testing.T) {
 	}
 }
 
+func TestRAMInBytes(t *testing.T) {
+	assertRAMInBytes(t, "32",   false, 32)
+	assertRAMInBytes(t, "32b",  false, 32)
+	assertRAMInBytes(t, "32B",  false, 32)
+	assertRAMInBytes(t, "32k",  false, 32*1024)
+	assertRAMInBytes(t, "32K",  false, 32*1024)
+	assertRAMInBytes(t, "32kb", false, 32*1024)
+	assertRAMInBytes(t, "32Kb", false, 32*1024)
+	assertRAMInBytes(t, "32Mb", false, 32*1024*1024)
+	assertRAMInBytes(t, "32Gb", false, 32*1024*1024*1024)
+
+	assertRAMInBytes(t, "",      true, -1)
+	assertRAMInBytes(t, "hello", true, -1)
+	assertRAMInBytes(t, "-32",   true, -1)
+	assertRAMInBytes(t, " 32 ",  true, -1)
+	assertRAMInBytes(t, "32 mb", true, -1)
+	assertRAMInBytes(t, "32m b", true, -1)
+	assertRAMInBytes(t, "32bm",  true, -1)
+}
+
+func assertRAMInBytes(t *testing.T, size string, expectError bool, expectedBytes int64) {
+	actualBytes, err := RAMInBytes(size)
+	if (err != nil) && !expectError {
+		t.Errorf("Unexpected error parsing '%s': %s", size, err)
+	}
+	if (err == nil) && expectError {
+		t.Errorf("Expected to get an error parsing '%s', but got none (bytes=%d)", size, actualBytes)
+	}
+	if actualBytes != expectedBytes {
+		t.Errorf("Expected '%s' to parse as %d bytes, got %d", size, expectedBytes, actualBytes)
+	}
+}
+
 func TestParseHost(t *testing.T) {
 	if addr, err := ParseHost("127.0.0.1", 4243, "0.0.0.0"); err != nil || addr != "tcp://0.0.0.0:4243" {
 		t.Errorf("0.0.0.0 -> expected tcp://0.0.0.0:4243, got %s", addr)

From adc686474c8d19affd47cf475e3c56e00ab75d10 Mon Sep 17 00:00:00 2001
From: Andy Rothfusz <github@metaliveblog.com>
Date: Wed, 23 Oct 2013 19:04:03 -0700
Subject: [PATCH 005/184] Add known issues to sections via new "issues"
 extension. Upstream-commit: 4194617bfe1e29bae2c2515aefbed5f1f2a1ebc1
 Component: engine

---
 components/engine/docs/sources/conf.py         |  6 +++++-
 components/engine/docs/sources/use/builder.rst | 10 ++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/components/engine/docs/sources/conf.py b/components/engine/docs/sources/conf.py
index 7aa27c7b84..0ccd4a4ed5 100644
--- a/components/engine/docs/sources/conf.py
+++ b/components/engine/docs/sources/conf.py
@@ -40,7 +40,11 @@ html_additional_pages = {
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinxcontrib.httpdomain']
+extensions = ['sphinxcontrib.httpdomain', 'sphinx.ext.extlinks']
+
+# Configure extlinks
+extlinks = { 'issue': ('https://github.com/dotcloud/docker/issues/%s',
+	               'Issue ') }
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
diff --git a/components/engine/docs/sources/use/builder.rst b/components/engine/docs/sources/use/builder.rst
index d1747c3fb3..a1fd85df91 100644
--- a/components/engine/docs/sources/use/builder.rst
+++ b/components/engine/docs/sources/use/builder.rst
@@ -116,6 +116,16 @@ core concepts of Docker where commits are cheap and containers can be
 created from any point in an image's history, much like source
 control.
 
+Known Issues
+............
+
+* :issue:`783` is about file permissions problems that can occur when
+  using the AUFS file system. You might notice it during an attempt to
+  ``rm`` a file, for example. The issue describes a workaround.
+
+
+
+
 3.4 CMD
 -------
 

From 938714910e543ee50e6fe6df8387c3a4f00b85b4 Mon Sep 17 00:00:00 2001
From: Andy Rothfusz <github@metaliveblog.com>
Date: Fri, 1 Nov 2013 16:06:46 -0700
Subject: [PATCH 006/184] Add known issues. Fix build warnings.
 Upstream-commit: 5a9adfe9fb5bc988185ef41ca637fbeee73e947c Component: engine

---
 components/engine/docs/sources/commandline/cli.rst   | 12 ++++++++++++
 .../docs/sources/contributing/contributing.rst       |  9 ++++++---
 components/engine/docs/sources/use/builder.rst       |  6 +++---
 3 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 8f778c32de..ab622bff54 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -408,6 +408,12 @@ Insert file from github
 
 The main process inside the container will be sent SIGKILL.
 
+Known Issues (kill)
+~~~~~~~~~~~~~~~~~~~
+
+* :issue:`197` indicates that ``docker kill`` may leave directories
+  behind and make it difficult to remove the container.
+
 .. _cli_login:
 
 ``login``
@@ -516,6 +522,12 @@ The main process inside the container will be sent SIGKILL.
     Remove one or more containers
         -link="": Remove the link instead of the actual container
 
+Known Issues (rm)
+~~~~~~~~~~~~~~~~~~~
+
+* :issue:`197` indicates that ``docker kill`` may leave directories
+  behind and make it difficult to remove the container.
+
 
 Examples:
 ~~~~~~~~~
diff --git a/components/engine/docs/sources/contributing/contributing.rst b/components/engine/docs/sources/contributing/contributing.rst
index 3cdb0b6f14..3b3b3f8f88 100644
--- a/components/engine/docs/sources/contributing/contributing.rst
+++ b/components/engine/docs/sources/contributing/contributing.rst
@@ -10,13 +10,16 @@ Want to hack on Docker? Awesome!
 The repository includes `all the instructions you need to get
 started <https://github.com/dotcloud/docker/blob/master/CONTRIBUTING.md>`_.
 
-The developer environment `Dockerfile <https://github.com/dotcloud/docker/blob/master/Dockerfile>`_
+The `developer environment Dockerfile
+<https://github.com/dotcloud/docker/blob/master/Dockerfile>`_
 specifies the tools and versions used to test and build Docker.
 
 If you're making changes to the documentation, see the
 `README.md <https://github.com/dotcloud/docker/blob/master/docs/README.md>`_.
 
-The documentation environment `Dockerfile <https://github.com/dotcloud/docker/blob/master/docs/Dockerfile>`_
+The `documentation environment Dockerfile
+<https://github.com/dotcloud/docker/blob/master/docs/Dockerfile>`_
 specifies the tools and versions used to build the Documentation.
 
-Further interesting details can be found in the `Packaging hints <https://github.com/dotcloud/docker/blob/master/hack/PACKAGERS.md>`_.
+Further interesting details can be found in the `Packaging hints
+<https://github.com/dotcloud/docker/blob/master/hack/PACKAGERS.md>`_.
diff --git a/components/engine/docs/sources/use/builder.rst b/components/engine/docs/sources/use/builder.rst
index a1fd85df91..e48f3f2a48 100644
--- a/components/engine/docs/sources/use/builder.rst
+++ b/components/engine/docs/sources/use/builder.rst
@@ -116,13 +116,13 @@ core concepts of Docker where commits are cheap and containers can be
 created from any point in an image's history, much like source
 control.
 
-Known Issues
-............
+Known Issues (RUN)
+..................
 
 * :issue:`783` is about file permissions problems that can occur when
   using the AUFS file system. You might notice it during an attempt to
   ``rm`` a file, for example. The issue describes a workaround.
-
+* :issue:`2424` Locale will not be set automatically.
 
 
 

From 14d0aebe52c031d53be017a3c4ae8d1fc9d35bee Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Mon, 4 Nov 2013 19:18:37 -0600
Subject: [PATCH 007/184] Updated Redis service example to use links
 Upstream-commit: 1182797c6d6bf4bb87e5edcddd75edb3f995dac0 Component: engine

---
 .../examples/running_redis_service.rst        | 111 ++++++++++--------
 1 file changed, 65 insertions(+), 46 deletions(-)

diff --git a/components/engine/docs/sources/examples/running_redis_service.rst b/components/engine/docs/sources/examples/running_redis_service.rst
index ac869501b0..edcf73e657 100644
--- a/components/engine/docs/sources/examples/running_redis_service.rst
+++ b/components/engine/docs/sources/examples/running_redis_service.rst
@@ -9,74 +9,93 @@ Redis Service
 
 .. include:: example_header.inc
 
-Very simple, no frills, Redis service.
+Very simple, no frills, Redis service attached to a web application using a link.
 
-Open a docker container
------------------------
+Create a docker container for Redis
+-----------------------------------
+
+Firstly, we create a ``Dockerfile`` for our new Redis image.
 
 .. code-block:: bash
 
-    sudo docker run -i -t ubuntu /bin/bash
+    FROM        ubuntu:12.10
+    RUN         apt-get update
+    RUN         apt-get -y install redis-server
+    EXPOSE      6379
+    ENTRYPOINT  ["/usr/bin/redis-server"]
 
-Building your image
--------------------
-
-Update your Docker container, install the Redis server.  Once
-installed, exit out of the Docker container.
+Next we build an image from our ``Dockerfile``. Replace ``<your username>`` 
+with your own user name.
 
 .. code-block:: bash
 
-    apt-get update
-    apt-get install redis-server
-    exit
-
-Snapshot the installation
--------------------------
-
-.. code-block:: bash
-
-    sudo docker ps -a  # grab the container id (this will be the first one in the list)
-    sudo docker commit <container_id> <your username>/redis
+    sudo docker build -t <your username>/redis
 
 Run the service
 ---------------
 
+Use the image we've just created and name your container ``redis``.
+
 Running the service with ``-d`` runs the container in detached mode, leaving the
-container running in the background. Use your snapshot.
+container running in the background.
+
+Importantly, we're not exposing any ports on our container. Instead we're going to 
+use a container link to provide access to our Redis database.
 
 .. code-block:: bash
 
-    sudo docker run -d -p 6379 <your username>/redis /usr/bin/redis-server
+    sudo docker run -name redis -d <your username>/redis
 
-Test 1
-++++++
+Create your web application container
+-------------------------------------
 
-Connect to the container with the ``redis-cli`` binary.
+Next we can create a container for our application. We're going to use the ``-link`` 
+flag to create a link to the ``redis`` container we've just created with an alias of 
+``db``. This will create a secure tunnel to the ``redis`` container and expose the 
+Redis instance running inside that container to only this container.
 
 .. code-block:: bash
 
-    sudo docker ps  # grab the new container id
-    sudo docker inspect <container_id>    # grab the ipaddress of the container
-    redis-cli -h <ipaddress> -p 6379
-    redis 10.0.3.32:6379> set docker awesome
+    sudo docker run -link redis:db -i -t ubuntu:12.10 /bin/bash
+
+Once inside our freshly created container we need to install Redis to get the 
+``redis-cli`` binary to test our connection.
+
+.. code-block:: bash
+
+    apt-get update
+    apt-get -y install redis-server
+    service redis-server stop
+
+Now we can test the connection. Firstly, let's look at the available environmental 
+variables in our web application container. We can use these to get the IP and port 
+of our ``redis`` container.
+
+.. code-block:: bash
+
+    env
+    . . .
+    DB_NAME=/violet_wolf/db
+    DB_PORT_6379_TCP_PORT=6379
+    DB_PORT=tcp://172.17.0.33:6379
+    DB_PORT_6379_TCP=tcp://172.17.0.33:6379
+    DB_PORT_6379_TCP_ADDR=172.17.0.33
+    DB_PORT_6379_TCP_PROTO=tcp
+
+We can see that we've got a small list of environmental varaibles prefixed with ``DB``. 
+The ``DB`` comes from the link alias specified when we launched the container. Let's use 
+the ``DB_PORT_6379_TCP_ADDR`` variable to connect to our Redis container.
+
+.. code-block:: bash
+
+    redis-cli -h $DB_PORT_6379_TCP_ADDR
+    redis 172.17.0.33:6379>
+    redis 172.17.0.33:6379> set docker awesome
     OK
-    redis 10.0.3.32:6379> get docker
+    redis 172.17.0.33:6379> get docker
     "awesome"
-    redis 10.0.3.32:6379> exit
+    redis 172.17.0.33:6379> exit
 
-Test 2
-++++++
+We could easily use this or other environment variables in our web application to make a 
+connection to our ``redis`` container.
 
-Connect to the host os with the ``redis-cli`` binary.
-
-.. code-block:: bash
-
-    sudo docker ps  # grab the new container id
-    sudo docker port <container_id> 6379  # grab the external port
-    ip addr show   # grab the host ip address
-    redis-cli -h <host ipaddress> -p <external port>
-    redis 192.168.0.1:49153> set docker awesome
-    OK
-    redis 192.168.0.1:49153> get docker
-    "awesome"
-    redis 192.168.0.1:49153> exit

From 255b88c5328f4fc107037059384b2636d8701586 Mon Sep 17 00:00:00 2001
From: "Guillaume J. Charmes" <charmes.guillaume@gmail.com>
Date: Tue, 5 Nov 2013 07:33:07 -0800
Subject: [PATCH 008/184] Check the output of iptables command.
 Upstream-commit: ff8a4ba0aa20dc3b382e2dcddcd89bb0bb168496 Component: engine

---
 components/engine/iptables/iptables.go      | 43 +++++++++++++++------
 components/engine/iptables/iptables_test.go |  4 +-
 components/engine/links.go                  |  8 +++-
 components/engine/network.go                |  8 +++-
 4 files changed, 46 insertions(+), 17 deletions(-)

diff --git a/components/engine/iptables/iptables.go b/components/engine/iptables/iptables.go
index 463f443fda..8139b9881e 100644
--- a/components/engine/iptables/iptables.go
+++ b/components/engine/iptables/iptables.go
@@ -27,8 +27,10 @@ type Chain struct {
 }
 
 func NewChain(name, bridge string) (*Chain, error) {
-	if err := Raw("-t", "nat", "-N", name); err != nil {
+	if output, err := Raw("-t", "nat", "-N", name); err != nil {
 		return nil, err
+	} else if len(output) != 0 {
+		return nil, fmt.Errorf("Error creating new iptables chain: %s", output)
 	}
 	chain := &Chain{
 		Name:   name,
@@ -52,13 +54,18 @@ func RemoveExistingChain(name string) error {
 }
 
 func (c *Chain) Forward(action Action, ip net.IP, port int, proto, dest_addr string, dest_port int) error {
-	return Raw("-t", "nat", fmt.Sprint(action), c.Name,
+	if output, err := Raw("-t", "nat", fmt.Sprint(action), c.Name,
 		"-p", proto,
 		"-d", ip.String(),
 		"--dport", strconv.Itoa(port),
 		"!", "-i", c.Bridge,
 		"-j", "DNAT",
-		"--to-destination", net.JoinHostPort(dest_addr, strconv.Itoa(dest_port)))
+		"--to-destination", net.JoinHostPort(dest_addr, strconv.Itoa(dest_port))); err != nil {
+		return err
+	} else if len(output) != 0 {
+		return fmt.Errorf("Error iptables forward: %s", output)
+	}
+	return nil
 }
 
 func (c *Chain) Prerouting(action Action, args ...string) error {
@@ -66,7 +73,12 @@ func (c *Chain) Prerouting(action Action, args ...string) error {
 	if len(args) > 0 {
 		a = append(a, args...)
 	}
-	return Raw(append(a, "-j", c.Name)...)
+	if output, err := Raw(append(a, "-j", c.Name)...); err != nil {
+		return err
+	} else if len(output) != 0 {
+		return fmt.Errorf("Error iptables prerouting: %s", output)
+	}
+	return nil
 }
 
 func (c *Chain) Output(action Action, args ...string) error {
@@ -74,7 +86,12 @@ func (c *Chain) Output(action Action, args ...string) error {
 	if len(args) > 0 {
 		a = append(a, args...)
 	}
-	return Raw(append(a, "-j", c.Name)...)
+	if output, err := Raw(append(a, "-j", c.Name)...); err != nil {
+		return err
+	} else if len(output) != 0 {
+		return fmt.Errorf("Error iptables output: %s", output)
+	}
+	return nil
 }
 
 func (c *Chain) Remove() error {
@@ -94,17 +111,21 @@ func (c *Chain) Remove() error {
 
 // Check if an existing rule exists
 func Exists(args ...string) bool {
-	return Raw(append([]string{"-C"}, args...)...) == nil
+	if _, err := Raw(append([]string{"-C"}, args...)...); err != nil {
+		return false
+	}
+	return true
 }
 
-func Raw(args ...string) error {
+func Raw(args ...string) ([]byte, error) {
 	path, err := exec.LookPath("iptables")
 	if err != nil {
-		return ErrIptablesNotFound
+		return nil, ErrIptablesNotFound
 	}
-	if err := exec.Command(path, args...).Run(); err != nil {
-		return fmt.Errorf("iptables failed: iptables %v", strings.Join(args, " "))
+	output, err := exec.Command(path, args...).CombinedOutput()
+	if err != nil {
+		return nil, fmt.Errorf("iptables failed: iptables %v: %s (%s)", strings.Join(args, " "), output, err)
 	}
-	return nil
+	return output, err
 
 }
diff --git a/components/engine/iptables/iptables_test.go b/components/engine/iptables/iptables_test.go
index aad8acdb81..886a63c03f 100644
--- a/components/engine/iptables/iptables_test.go
+++ b/components/engine/iptables/iptables_test.go
@@ -6,13 +6,13 @@ import (
 )
 
 func TestIptables(t *testing.T) {
-	if err := Raw("-L"); err != nil {
+	if _, err := Raw("-L"); err != nil {
 		t.Fatal(err)
 	}
 	path := os.Getenv("PATH")
 	os.Setenv("PATH", "")
 	defer os.Setenv("PATH", path)
-	if err := Raw("-L"); err == nil {
+	if _, err := Raw("-L"); err == nil {
 		t.Fatal("Not finding iptables in the PATH should cause an error")
 	}
 }
diff --git a/components/engine/links.go b/components/engine/links.go
index 60c738abb4..3c689d0bf3 100644
--- a/components/engine/links.go
+++ b/components/engine/links.go
@@ -120,7 +120,7 @@ func (l *Link) Disable() {
 
 func (l *Link) toggle(action string, ignoreErrors bool) error {
 	for _, p := range l.Ports {
-		if err := iptables.Raw(action, "FORWARD",
+		if output, err := iptables.Raw(action, "FORWARD",
 			"-i", l.BridgeInterface, "-o", l.BridgeInterface,
 			"-p", p.Proto(),
 			"-s", l.ParentIP,
@@ -128,9 +128,11 @@ func (l *Link) toggle(action string, ignoreErrors bool) error {
 			"-d", l.ChildIP,
 			"-j", "ACCEPT"); !ignoreErrors && err != nil {
 			return err
+		} else if len(output) != 0 {
+			return fmt.Errorf("Error toggle iptables forward: %s", output)
 		}
 
-		if err := iptables.Raw(action, "FORWARD",
+		if output, err := iptables.Raw(action, "FORWARD",
 			"-i", l.BridgeInterface, "-o", l.BridgeInterface,
 			"-p", p.Proto(),
 			"-s", l.ChildIP,
@@ -138,6 +140,8 @@ func (l *Link) toggle(action string, ignoreErrors bool) error {
 			"-d", l.ParentIP,
 			"-j", "ACCEPT"); !ignoreErrors && err != nil {
 			return err
+		} else if len(output) != 0 {
+			return fmt.Errorf("Error toggle iptables forward: %s", output)
 		}
 	}
 	return nil
diff --git a/components/engine/network.go b/components/engine/network.go
index c237ccc86d..acb94ce1f5 100644
--- a/components/engine/network.go
+++ b/components/engine/network.go
@@ -141,9 +141,11 @@ func CreateBridgeIface(config *DaemonConfig) error {
 	}
 
 	if config.EnableIptables {
-		if err := iptables.Raw("-t", "nat", "-A", "POSTROUTING", "-s", ifaceAddr,
+		if output, err := iptables.Raw("-t", "nat", "-A", "POSTROUTING", "-s", ifaceAddr,
 			"!", "-d", ifaceAddr, "-j", "MASQUERADE"); err != nil {
 			return fmt.Errorf("Unable to enable network bridge NAT: %s", err)
+		} else if len(output) != 0 {
+			return fmt.Errorf("Error iptables postrouting: %s", output)
 		}
 	}
 	return nil
@@ -656,8 +658,10 @@ func newNetworkManager(config *DaemonConfig) (*NetworkManager, error) {
 		if !config.InterContainerCommunication {
 			if !iptables.Exists(args...) {
 				utils.Debugf("Disable inter-container communication")
-				if err := iptables.Raw(append([]string{"-A"}, args...)...); err != nil {
+				if output, err := iptables.Raw(append([]string{"-A"}, args...)...); err != nil {
 					return nil, fmt.Errorf("Unable to prevent intercontainer communication: %s", err)
+				} else if len(output) != 0 {
+					return nil, fmt.Errorf("Error enabling iptables: %s", output)
 				}
 			}
 		} else {

From 8a182f4aaff8696f338d58c58b1d8e78eeb26f09 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sat, 26 Oct 2013 17:19:35 -0700
Subject: [PATCH 009/184] Separate a) initialization of the http api and b)
 actually serving the api into 2 distinct jobs Upstream-commit:
 433c8e9c7da7cd3cd952c3dce3763db70fc450e5 Component: engine

---
 components/engine/config.go        |  2 --
 components/engine/docker/docker.go |  8 ++++++--
 components/engine/server.go        | 31 +++++++++++++++---------------
 3 files changed, 21 insertions(+), 20 deletions(-)

diff --git a/components/engine/config.go b/components/engine/config.go
index 40c47e692c..d5f852c26f 100644
--- a/components/engine/config.go
+++ b/components/engine/config.go
@@ -9,7 +9,6 @@ import (
 type DaemonConfig struct {
 	Pidfile                     string
 	Root                        string
-	ProtoAddresses              []string
 	AutoRestart                 bool
 	EnableCors                  bool
 	Dns                         []string
@@ -36,7 +35,6 @@ func ConfigFromJob(job *engine.Job) *DaemonConfig {
 	} else {
 		config.BridgeIface = DefaultNetworkBridge
 	}
-	config.ProtoAddresses = job.GetenvList("ProtoAddresses")
 	config.DefaultIp = net.ParseIP(job.Getenv("DefaultIp"))
 	config.InterContainerCommunication = job.GetenvBool("InterContainerCommunication")
 	return &config
diff --git a/components/engine/docker/docker.go b/components/engine/docker/docker.go
index c500633a71..2fc864adf4 100644
--- a/components/engine/docker/docker.go
+++ b/components/engine/docker/docker.go
@@ -71,7 +71,8 @@ func main() {
 		if err != nil {
 			log.Fatal(err)
 		}
-		job := eng.Job("serveapi")
+		// Load plugin: httpapi
+		job := eng.Job("initapi")
 		job.Setenv("Pidfile", *pidfile)
 		job.Setenv("Root", *flRoot)
 		job.SetenvBool("AutoRestart", *flAutoRestart)
@@ -79,12 +80,15 @@ func main() {
 		job.Setenv("Dns", *flDns)
 		job.SetenvBool("EnableIptables", *flEnableIptables)
 		job.Setenv("BridgeIface", *bridgeName)
-		job.SetenvList("ProtoAddresses", flHosts)
 		job.Setenv("DefaultIp", *flDefaultIp)
 		job.SetenvBool("InterContainerCommunication", *flInterContainerComm)
 		if err := job.Run(); err != nil {
 			log.Fatal(err)
 		}
+		// Serve api
+		if err := eng.Job("serveapi", flHosts...).Run(); err != nil {
+			log.Fatal(err)
+		}
 	} else {
 		if len(flHosts) > 1 {
 			log.Fatal("Please specify only one -H")
diff --git a/components/engine/server.go b/components/engine/server.go
index 314df0256b..d8b70b88ae 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -33,30 +33,20 @@ func (srv *Server) Close() error {
 }
 
 func init() {
-	engine.Register("serveapi", JobServeApi)
+	engine.Register("initapi", jobInitApi)
 }
 
-func JobServeApi(job *engine.Job) string {
+// jobInitApi runs the remote api server `srv` as a daemon,
+// Only one api server can run at the same time - this is enforced by a pidfile.
+// The signals SIGINT, SIGKILL and SIGTERM are intercepted for cleanup.
+func jobInitApi(job *engine.Job) string {
 	srv, err := NewServer(ConfigFromJob(job))
 	if err != nil {
 		return err.Error()
 	}
-	defer srv.Close()
-	if err := srv.Daemon(); err != nil {
-		return err.Error()
-	}
-	return "0"
-}
-
-// Daemon runs the remote api server `srv` as a daemon,
-// Only one api server can run at the same time - this is enforced by a pidfile.
-// The signals SIGINT, SIGKILL and SIGTERM are intercepted for cleanup.
-func (srv *Server) Daemon() error {
 	if err := utils.CreatePidFile(srv.runtime.config.Pidfile); err != nil {
 		log.Fatal(err)
 	}
-	defer utils.RemovePidFile(srv.runtime.config.Pidfile)
-
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, os.Interrupt, os.Kill, os.Signal(syscall.SIGTERM))
 	go func() {
@@ -66,8 +56,17 @@ func (srv *Server) Daemon() error {
 		srv.Close()
 		os.Exit(0)
 	}()
+	err = engine.Register("serveapi", func(job *engine.Job) string {
+		return srv.ListenAndServe(job.Args...).Error()
+	})
+	if err != nil {
+		return err.Error()
+	}
+	return "0"
+}
 
-	protoAddrs := srv.runtime.config.ProtoAddresses
+
+func (srv *Server) ListenAndServe(protoAddrs ...string) error {
 	chErrors := make(chan error, len(protoAddrs))
 	for _, protoAddr := range protoAddrs {
 		protoAddrParts := strings.SplitN(protoAddr, "://", 2)

From 6c362cebcc557b11e8455f8c7c9d02b807172673 Mon Sep 17 00:00:00 2001
From: Daniel Garcia <daniel@danielgarcia.info>
Date: Sun, 13 Oct 2013 15:58:54 -0500
Subject: [PATCH 010/184] Add ability to mount volumes in readonly mode using
 -volumes-from Upstream-commit: f9cb6ae46a3478c19e85a2a159c4ac31223ec499
 Component: engine

---
 components/engine/container.go                | 24 +++++--
 components/engine/container_test.go           | 62 +++++++++++++++++++
 .../engine/docs/sources/commandline/cli.rst   | 13 +++-
 3 files changed, 93 insertions(+), 6 deletions(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index a22484c2d6..db444e758c 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -199,7 +199,7 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 	cmd.Var(flVolumes, "v", "Bind mount a volume (e.g. from the host: -v /host:/container, from docker: -v /container)")
 
 	var flVolumesFrom utils.ListOpts
-	cmd.Var(&flVolumesFrom, "volumes-from", "Mount volumes from the specified container")
+	cmd.Var(&flVolumesFrom, "volumes-from", "Mount volumes from the specified container(s)")
 
 	flEntrypoint := cmd.String("entrypoint", "", "Overwrite the default entrypoint of the image")
 
@@ -749,9 +749,23 @@ func (container *Container) Start() (err error) {
 
 	// Apply volumes from another container if requested
 	if container.Config.VolumesFrom != "" {
-		volumes := strings.Split(container.Config.VolumesFrom, ",")
-		for _, v := range volumes {
-			c := container.runtime.Get(v)
+		containerSpecs := strings.Split(container.Config.VolumesFrom, ",")
+		for _, containerSpec := range containerSpecs {
+			mountRW := true
+			specParts := strings.SplitN(containerSpec, ":", 2)
+			switch len(specParts) {
+			case 0:
+				return fmt.Errorf("Malformed volumes-from specification: %s", container.Config.VolumesFrom)
+			case 2:
+				switch specParts[1] {
+				case "ro":
+					mountRW = false
+				case "rw": // mountRW is already true
+				default:
+					return fmt.Errorf("Malformed volumes-from speficication: %s", containerSpec)
+				}
+			}
+			c := container.runtime.Get(specParts[0])
 			if c == nil {
 				return fmt.Errorf("Container %s not found. Impossible to mount its volumes", container.ID)
 			}
@@ -764,7 +778,7 @@ func (container *Container) Start() (err error) {
 				}
 				container.Volumes[volPath] = id
 				if isRW, exists := c.VolumesRW[volPath]; exists {
-					container.VolumesRW[volPath] = isRW
+					container.VolumesRW[volPath] = isRW && mountRW
 				}
 			}
 
diff --git a/components/engine/container_test.go b/components/engine/container_test.go
index cbabffc364..5540bb9c27 100644
--- a/components/engine/container_test.go
+++ b/components/engine/container_test.go
@@ -1338,6 +1338,68 @@ func TestBindMounts(t *testing.T) {
 	}
 }
 
+// Test that -volumes-from supports both read-only mounts
+func TestFromVolumesInReadonlyMode(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+	container, _, err := runtime.Create(
+		&Config{
+			Image:     GetTestImage(runtime).ID,
+			Cmd:       []string{"/bin/echo", "-n", "foobar"},
+			Volumes:   map[string]struct{}{"/test": {}},
+		},
+		"",
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container)
+	_, err = container.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !container.VolumesRW["/test"] {
+		t.Fail()
+	}
+
+	container2, _, err := runtime.Create(
+		&Config{
+			Image:       GetTestImage(runtime).ID,
+			Cmd:         []string{"/bin/echo", "-n", "foobar"},
+			VolumesFrom: container.ID + ":ro",
+		},
+		"",
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container2)
+
+	_, err = container2.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if container.Volumes["/test"] != container2.Volumes["/test"] {
+		t.Logf("container volumes do not match: %s | %s ", 
+			container.Volumes["/test"],
+			container2.Volumes["/test"])
+		t.Fail()
+	}
+
+	_, exists := container2.VolumesRW["/test"]
+	if !exists {
+		t.Logf("container2 is missing '/test' volume: %s", container2.VolumesRW)
+		t.Fail()
+	}
+
+	if container2.VolumesRW["/test"] != false {
+		t.Log("'/test' volume mounted in read-write mode, expected read-only")
+		t.Fail()
+	}
+}
+
+
 // Test that VolumesRW values are copied to the new container.  Regression test for #1201
 func TestVolumesFromReadonlyMount(t *testing.T) {
 	runtime := mkRuntime(t)
diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index da0c262c4a..786fca6a6f 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -576,7 +576,7 @@ network communication.
       -u="": Username or UID
       -dns=[]: Set custom dns servers for the container
       -v=[]: Create a bind mount with: [host-dir]:[container-dir]:[rw|ro]. If "container-dir" is missing, then docker creates a new volume.
-      -volumes-from="": Mount all volumes from the given container
+      -volumes-from="": Mount all volumes from the given container(s)
       -entrypoint="": Overwrite the default entrypoint set by the image
       -w="": Working directory inside the container
       -lxc-conf=[]: Add custom lxc options -lxc-conf="lxc.cgroup.cpuset.cpus = 0,1"
@@ -668,6 +668,17 @@ can access the network and environment of the redis container via
 environment variables.  The ``-name`` flag will assign the name ``console``
 to the newly created container.
 
+.. code-block:: bash
+
+   docker run -volumes-from 777f7dc92da7,ba8c0c54f0f2:ro -i -t ubuntu pwd
+
+The ``-volumes-from`` flag mounts all the defined volumes from the
+refrence containers. Containers can be specified by a comma seperated
+list or by repetitions of the ``-volumes-from`` argument. The container
+id may be optionally suffixed with ``:ro`` or ``:rw`` to mount the volumes in
+read-only or read-write mode, respectively. By default, the volumes are mounted
+in the same mode (rw or ro) as the reference container.
+
 .. _cli_search:
 
 ``search``

From 26507356b34b65b1d70480e58042653e0c3961ef Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sat, 26 Oct 2013 19:24:01 -0700
Subject: [PATCH 011/184] Engine: 'start' starts the specified container
 Upstream-commit: 958b4a8757e83c3fada757b10dd1be4ab7bff5ee Component: engine

---
 components/engine/api.go                      | 24 +++-----
 components/engine/api_test.go                 |  6 +-
 components/engine/engine/engine.go            | 10 ++--
 components/engine/engine/hack.go              | 23 +++++++
 components/engine/engine/job.go               | 60 ++++++++++++++++++-
 .../engine/engine/{init_test.go => utils.go}  |  4 +-
 components/engine/server.go                   | 54 +++++++++++------
 components/engine/server_test.go              | 52 +++++++++++-----
 components/engine/utils_test.go               | 13 ++++
 9 files changed, 186 insertions(+), 60 deletions(-)
 create mode 100644 components/engine/engine/hack.go
 rename components/engine/engine/{init_test.go => utils.go} (90%)

diff --git a/components/engine/api.go b/components/engine/api.go
index 0c06b2e6d1..1a3d92de32 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -639,26 +639,20 @@ func deleteImages(srv *Server, version float64, w http.ResponseWriter, r *http.R
 }
 
 func postContainersStart(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var hostConfig *HostConfig
-	// allow a nil body for backwards compatibility
-	if r.Body != nil {
-		if matchesContentType(r.Header.Get("Content-Type"), "application/json") {
-			hostConfig = &HostConfig{}
-			if err := json.NewDecoder(r.Body).Decode(hostConfig); err != nil {
-				return err
-			}
-		}
-	}
-
 	if vars == nil {
 		return fmt.Errorf("Missing parameter")
 	}
 	name := vars["name"]
-	// Register any links from the host config before starting the container
-	if err := srv.RegisterLinks(name, hostConfig); err != nil {
-		return err
+	job := srv.Eng.Job("start", name)
+	// allow a nil body for backwards compatibility
+	if r.Body != nil {
+		if matchesContentType(r.Header.Get("Content-Type"), "application/json") {
+			if err := job.DecodeEnv(r.Body); err != nil {
+				return err
+			}
+		}
 	}
-	if err := srv.ContainerStart(name, hostConfig); err != nil {
+	if err := job.Run(); err != nil {
 		return err
 	}
 	w.WriteHeader(http.StatusNoContent)
diff --git a/components/engine/api_test.go b/components/engine/api_test.go
index fcca8ce83f..50a86e3f23 100644
--- a/components/engine/api_test.go
+++ b/components/engine/api_test.go
@@ -781,11 +781,11 @@ func TestPostContainersRestart(t *testing.T) {
 }
 
 func TestPostContainersStart(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
-
 	container, _, err := runtime.Create(
 		&Config{
 			Image:     GetTestImage(runtime).ID,
diff --git a/components/engine/engine/engine.go b/components/engine/engine/engine.go
index 8d67242ca2..a0d5a3c4ad 100644
--- a/components/engine/engine/engine.go
+++ b/components/engine/engine/engine.go
@@ -13,10 +13,11 @@ type Handler func(*Job) string
 
 var globalHandlers map[string]Handler
 
+func init() {
+	globalHandlers = make(map[string]Handler)
+}
+
 func Register(name string, handler Handler) error {
-	if globalHandlers == nil {
-		globalHandlers = make(map[string]Handler)
-	}
 	globalHandlers[name] = handler
 	return nil
 }
@@ -27,6 +28,7 @@ func Register(name string, handler Handler) error {
 type Engine struct {
 	root		string
 	handlers	map[string]Handler
+	hack		Hack	// data for temporary hackery (see hack.go)
 }
 
 // New initializes a new engine managing the directory specified at `root`.
@@ -66,7 +68,7 @@ func New(root string) (*Engine, error) {
 // This function mimics `Command` from the standard os/exec package.
 func (eng *Engine) Job(name string, args ...string) *Job {
 	job := &Job{
-		eng:		eng,
+		Eng:		eng,
 		Name:		name,
 		Args:		args,
 		Stdin:		os.Stdin,
diff --git a/components/engine/engine/hack.go b/components/engine/engine/hack.go
new file mode 100644
index 0000000000..7f6e79c0e9
--- /dev/null
+++ b/components/engine/engine/hack.go
@@ -0,0 +1,23 @@
+package engine
+
+
+type Hack map[string]interface{}
+
+
+func (eng *Engine) Hack_GetGlobalVar(key string) interface{} {
+	if eng.hack == nil {
+		return nil
+	}
+	val, exists := eng.hack[key]
+	if !exists {
+		return nil
+	}
+	return val
+}
+
+func (eng *Engine) Hack_SetGlobalVar(key string, val interface{}) {
+	if eng.hack == nil {
+		eng.hack = make(Hack)
+	}
+	eng.hack[key] = val
+}
diff --git a/components/engine/engine/job.go b/components/engine/engine/job.go
index 0bde2a0beb..5c02fe15d5 100644
--- a/components/engine/engine/job.go
+++ b/components/engine/engine/job.go
@@ -1,6 +1,7 @@
 package engine
 
 import (
+	"bytes"
 	"io"
 	"strings"
 	"fmt"
@@ -22,7 +23,7 @@ import (
 // This allows for richer error reporting.
 // 
 type Job struct {
-	eng	*Engine
+	Eng	*Engine
 	Name	string
 	Args	[]string
 	env	[]string
@@ -111,3 +112,60 @@ func (job *Job) SetenvList(key string, value []string) error {
 func (job *Job) Setenv(key, value string) {
 	job.env = append(job.env, key + "=" + value)
 }
+
+// DecodeEnv decodes `src` as a json dictionary, and adds
+// each decoded key-value pair to the environment.
+//
+// If `text` cannot be decoded as a json dictionary, an error
+// is returned.
+func (job *Job) DecodeEnv(src io.Reader) error {
+	m := make(map[string]interface{})
+	if err := json.NewDecoder(src).Decode(&m); err != nil {
+		return err
+	}
+	for k, v := range m {
+		if sval, ok := v.(string); ok {
+			job.Setenv(k, sval)
+		} else	if val, err := json.Marshal(v); err == nil {
+			job.Setenv(k, string(val))
+		} else {
+			job.Setenv(k, fmt.Sprintf("%v", v))
+		}
+	}
+	return nil
+}
+
+func (job *Job) EncodeEnv(dst io.Writer) error {
+	return json.NewEncoder(dst).Encode(job.Environ())
+}
+
+func (job *Job) ExportEnv(dst interface{}) error {
+	var buf bytes.Buffer
+	if err := job.EncodeEnv(&buf); err != nil {
+		return err
+	}
+	if err := json.NewDecoder(&buf).Decode(dst); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (job *Job) ImportEnv(src interface{}) error {
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(src); err != nil {
+		return err
+	}
+	if err := job.DecodeEnv(&buf); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (job *Job) Environ() map[string]string {
+	m := make(map[string]string)
+	for _, kv := range job.env {
+		parts := strings.SplitN(kv, "=", 2)
+		m[parts[0]] = parts[1]
+	}
+	return m
+}
diff --git a/components/engine/engine/init_test.go b/components/engine/engine/utils.go
similarity index 90%
rename from components/engine/engine/init_test.go
rename to components/engine/engine/utils.go
index 5c03ded87d..58e5f9aae2 100644
--- a/components/engine/engine/init_test.go
+++ b/components/engine/engine/utils.go
@@ -15,7 +15,7 @@ func init() {
 	Register("dummy", func(job *Job) string { return ""; })
 }
 
-func mkEngine(t *testing.T) *Engine {
+func NewTestEngine(t *testing.T) *Engine {
 	// Use the caller function name as a prefix.
 	// This helps trace temp directories back to their test.
 	pc, _, _, _ := runtime.Caller(1)
@@ -38,5 +38,5 @@ func mkEngine(t *testing.T) *Engine {
 }
 
 func mkJob(t *testing.T, name string, args ...string) *Job {
-	return mkEngine(t).Job(name, args...)
+	return NewTestEngine(t).Job(name, args...)
 }
diff --git a/components/engine/server.go b/components/engine/server.go
index d8b70b88ae..efc34d14e1 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -40,7 +40,7 @@ func init() {
 // Only one api server can run at the same time - this is enforced by a pidfile.
 // The signals SIGINT, SIGKILL and SIGTERM are intercepted for cleanup.
 func jobInitApi(job *engine.Job) string {
-	srv, err := NewServer(ConfigFromJob(job))
+	srv, err := NewServer(job.Eng, ConfigFromJob(job))
 	if err != nil {
 		return err.Error()
 	}
@@ -56,17 +56,19 @@ func jobInitApi(job *engine.Job) string {
 		srv.Close()
 		os.Exit(0)
 	}()
-	err = engine.Register("serveapi", func(job *engine.Job) string {
-		return srv.ListenAndServe(job.Args...).Error()
-	})
-	if err != nil {
+	job.Eng.Hack_SetGlobalVar("httpapi.server", srv)
+	if err := engine.Register("start", srv.ContainerStart); err != nil {
+		return err.Error()
+	}
+	if err := engine.Register("serveapi", srv.ListenAndServe); err != nil {
 		return err.Error()
 	}
 	return "0"
 }
 
 
-func (srv *Server) ListenAndServe(protoAddrs ...string) error {
+func (srv *Server) ListenAndServe(job *engine.Job) string {
+	protoAddrs := job.Args
 	chErrors := make(chan error, len(protoAddrs))
 	for _, protoAddr := range protoAddrs {
 		protoAddrParts := strings.SplitN(protoAddr, "://", 2)
@@ -80,7 +82,7 @@ func (srv *Server) ListenAndServe(protoAddrs ...string) error {
 				log.Println("/!\\ DON'T BIND ON ANOTHER IP ADDRESS THAN 127.0.0.1 IF YOU DON'T KNOW WHAT YOU'RE DOING /!\\")
 			}
 		default:
-			return fmt.Errorf("Invalid protocol format.")
+			return "Invalid protocol format."
 		}
 		go func() {
 			chErrors <- ListenAndServe(protoAddrParts[0], protoAddrParts[1], srv, true)
@@ -89,10 +91,10 @@ func (srv *Server) ListenAndServe(protoAddrs ...string) error {
 	for i := 0; i < len(protoAddrs); i += 1 {
 		err := <-chErrors
 		if err != nil {
-			return err
+			return err.Error()
 		}
 	}
-	return nil
+	return "0"
 }
 
 func (srv *Server) DockerVersion() APIVersion {
@@ -1282,8 +1284,7 @@ func (srv *Server) RegisterLinks(name string, hostConfig *HostConfig) error {
 		return fmt.Errorf("No such container: %s", name)
 	}
 
-	// Register links
-	if hostConfig != nil && hostConfig.Links != nil {
+	if hostConfig.Links != nil {
 		for _, l := range hostConfig.Links {
 			parts, err := parseLink(l)
 			if err != nil {
@@ -1296,7 +1297,6 @@ func (srv *Server) RegisterLinks(name string, hostConfig *HostConfig) error {
 			if child == nil {
 				return fmt.Errorf("Could not get container for %s", parts["name"])
 			}
-
 			if err := runtime.RegisterLink(container, child, parts["alias"]); err != nil {
 				return err
 			}
@@ -1312,22 +1312,36 @@ func (srv *Server) RegisterLinks(name string, hostConfig *HostConfig) error {
 	return nil
 }
 
-func (srv *Server) ContainerStart(name string, hostConfig *HostConfig) error {
+func (srv *Server) ContainerStart(job *engine.Job) string {
+	if len(job.Args) < 1 {
+		return fmt.Sprintf("Usage: %s container_id", job.Name)
+	}
+	name := job.Args[0]
 	runtime := srv.runtime
 	container := runtime.Get(name)
 	if container == nil {
-		return fmt.Errorf("No such container: %s", name)
+		return fmt.Sprintf("No such container: %s", name)
 	}
-	if hostConfig != nil {
-		container.hostConfig = hostConfig
+	// If no environment was set, then no hostconfig was passed.
+	if len(job.Environ()) > 0 {
+		var hostConfig HostConfig
+		if err := job.ExportEnv(&hostConfig); err != nil {
+			return err.Error()
+		}
+		// Register any links from the host config before starting the container
+		// FIXME: we could just pass the container here, no need to lookup by name again.
+		if err := srv.RegisterLinks(name, &hostConfig); err != nil {
+			return err.Error()
+		}
+		container.hostConfig = &hostConfig
 		container.ToDisk()
 	}
 	if err := container.Start(); err != nil {
-		return fmt.Errorf("Cannot start container %s: %s", name, err)
+		return fmt.Sprintf("Cannot start container %s: %s", name, err)
 	}
 	srv.LogEvent("start", container.ShortID(), runtime.repositories.ImageName(container.Image))
 
-	return nil
+	return "0"
 }
 
 func (srv *Server) ContainerStop(name string, t int) error {
@@ -1478,12 +1492,13 @@ func (srv *Server) ContainerCopy(name string, resource string, out io.Writer) er
 
 }
 
-func NewServer(config *DaemonConfig) (*Server, error) {
+func NewServer(eng *engine.Engine, config *DaemonConfig) (*Server, error) {
 	runtime, err := NewRuntime(config)
 	if err != nil {
 		return nil, err
 	}
 	srv := &Server{
+		Eng:         eng,
 		runtime:     runtime,
 		pullingPool: make(map[string]struct{}),
 		pushingPool: make(map[string]struct{}),
@@ -1527,4 +1542,5 @@ type Server struct {
 	events      []utils.JSONMessage
 	listeners   map[string]chan utils.JSONMessage
 	reqFactory  *utils.HTTPRequestFactory
+	Eng         *engine.Engine
 }
diff --git a/components/engine/server_test.go b/components/engine/server_test.go
index 7f9cbaadfd..20894f8fe1 100644
--- a/components/engine/server_test.go
+++ b/components/engine/server_test.go
@@ -1,6 +1,7 @@
 package docker
 
 import (
+	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/utils"
 	"strings"
 	"testing"
@@ -109,10 +110,11 @@ func TestCreateRm(t *testing.T) {
 }
 
 func TestCreateRmVolumes(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+	eng := engine.NewTestEngine(t)
 
-	srv := &Server{runtime: runtime}
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
+	defer nuke(runtime)
 
 	config, hostConfig, _, err := ParseRun([]string{"-v", "/srv", GetTestImage(runtime).ID, "echo test"}, nil)
 	if err != nil {
@@ -128,8 +130,11 @@ func TestCreateRmVolumes(t *testing.T) {
 		t.Errorf("Expected 1 container, %v found", len(runtime.List()))
 	}
 
-	err = srv.ContainerStart(id, hostConfig)
-	if err != nil {
+	job := eng.Job("start", id)
+	if err := job.ImportEnv(hostConfig); err != nil {
+		t.Fatal(err)
+	}
+	if err := job.Run(); err != nil {
 		t.Fatal(err)
 	}
 
@@ -169,11 +174,11 @@ func TestCommit(t *testing.T) {
 }
 
 func TestCreateStartRestartStopStartKillRm(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := engine.NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
-
 	config, hostConfig, _, err := ParseRun([]string{GetTestImage(runtime).ID, "/bin/cat"}, nil)
 	if err != nil {
 		t.Fatal(err)
@@ -188,7 +193,11 @@ func TestCreateStartRestartStopStartKillRm(t *testing.T) {
 		t.Errorf("Expected 1 container, %v found", len(runtime.List()))
 	}
 
-	if err := srv.ContainerStart(id, hostConfig); err != nil {
+	job := eng.Job("start", id)
+	if err := job.ImportEnv(hostConfig); err != nil {
+		t.Fatal(err)
+	}
+	if err := job.Run(); err != nil {
 		t.Fatal(err)
 	}
 
@@ -200,7 +209,11 @@ func TestCreateStartRestartStopStartKillRm(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if err := srv.ContainerStart(id, hostConfig); err != nil {
+	job = eng.Job("start", id)
+	if err := job.ImportEnv(hostConfig); err != nil {
+		t.Fatal(err)
+	}
+	if err := job.Run(); err != nil {
 		t.Fatal(err)
 	}
 
@@ -384,9 +397,10 @@ func TestLogEvent(t *testing.T) {
 }
 
 func TestRmi(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := engine.NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
-	srv := &Server{runtime: runtime}
 
 	initialImages, err := srv.Images(false, "")
 	if err != nil {
@@ -404,8 +418,11 @@ func TestRmi(t *testing.T) {
 	}
 
 	//To remove
-	err = srv.ContainerStart(containerID, hostConfig)
-	if err != nil {
+	job := eng.Job("start", containerID)
+	if err := job.ImportEnv(hostConfig); err != nil {
+		t.Fatal(err)
+	}
+	if err := job.Run(); err != nil {
 		t.Fatal(err)
 	}
 
@@ -425,8 +442,11 @@ func TestRmi(t *testing.T) {
 	}
 
 	//To remove
-	err = srv.ContainerStart(containerID, hostConfig)
-	if err != nil {
+	job = eng.Job("start", containerID)
+	if err := job.ImportEnv(hostConfig); err != nil {
+		t.Fatal(err)
+	}
+	if err := job.Run(); err != nil {
 		t.Fatal(err)
 	}
 
diff --git a/components/engine/utils_test.go b/components/engine/utils_test.go
index 14cbd7c6be..282954285c 100644
--- a/components/engine/utils_test.go
+++ b/components/engine/utils_test.go
@@ -2,6 +2,7 @@ package docker
 
 import (
 	"fmt"
+	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/utils"
 	"io"
 	"io/ioutil"
@@ -40,6 +41,18 @@ func mkRuntime(f Fataler) *Runtime {
 	return runtime
 }
 
+func mkServerFromEngine(eng *engine.Engine, t Fataler) *Server {
+	iSrv := eng.Hack_GetGlobalVar("httpapi.server")
+	if iSrv == nil {
+		t.Fatal("Legacy server field not set in engine")
+	}
+	srv, ok := iSrv.(*Server)
+	if !ok {
+		t.Fatal("Legacy server field in engine does not cast to *Server")
+	}
+	return srv
+}
+
 // A common interface to access the Fatal method of
 // both testing.B and testing.T.
 type Fataler interface {

From 6d109989282c8612909a605cff595fd88efcc833 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sun, 27 Oct 2013 06:51:43 +0000
Subject: [PATCH 012/184] httpapi: don't create a pidfile if it isn't set in
 the configuration Upstream-commit: 7b17d555992c65c6b10da21c8aa48062a1aba0d9
 Component: engine

---
 components/engine/server.go | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index efc34d14e1..de79dd966d 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -44,8 +44,11 @@ func jobInitApi(job *engine.Job) string {
 	if err != nil {
 		return err.Error()
 	}
-	if err := utils.CreatePidFile(srv.runtime.config.Pidfile); err != nil {
-		log.Fatal(err)
+	if srv.runtime.config.Pidfile != "" {
+		job.Logf("Creating pidfile")
+		if err := utils.CreatePidFile(srv.runtime.config.Pidfile); err != nil {
+			log.Fatal(err)
+		}
 	}
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, os.Interrupt, os.Kill, os.Signal(syscall.SIGTERM))

From 02af0b76845576b17e6018c518795aa22f5fdda1 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sun, 27 Oct 2013 06:54:51 +0000
Subject: [PATCH 013/184] Engine: fix a bug which caused handlers to be shared
 between multiple engine instances Upstream-commit:
 847411a1ee6e5ee5d051fc4729425215dc0c8561 Component: engine

---
 components/engine/engine/engine.go | 22 +++++++++++++++++++++-
 components/engine/server.go        |  4 ++--
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/components/engine/engine/engine.go b/components/engine/engine/engine.go
index a0d5a3c4ad..956847adee 100644
--- a/components/engine/engine/engine.go
+++ b/components/engine/engine/engine.go
@@ -18,6 +18,10 @@ func init() {
 }
 
 func Register(name string, handler Handler) error {
+	_, exists := globalHandlers[name]
+	if exists {
+		return fmt.Errorf("Can't overwrite global handler for command %s", name)
+	}
 	globalHandlers[name] = handler
 	return nil
 }
@@ -31,6 +35,17 @@ type Engine struct {
 	hack		Hack	// data for temporary hackery (see hack.go)
 }
 
+func (eng *Engine) Register(name string, handler Handler) error {
+	eng.Logf("Register(%s) (handlers=%v)", name, eng.handlers)
+	_, exists := eng.handlers[name]
+	if exists {
+		return fmt.Errorf("Can't overwrite handler for command %s", name)
+	}
+	eng.handlers[name] = handler
+	return nil
+}
+
+
 // New initializes a new engine managing the directory specified at `root`.
 // `root` is used to store containers and any other state private to the engine.
 // Changing the contents of the root without executing a job will cause unspecified
@@ -59,7 +74,12 @@ func New(root string) (*Engine, error) {
 	}
 	eng := &Engine{
 		root:		root,
-		handlers:	globalHandlers,
+		handlers:	make(map[string]Handler),
+		id:		utils.RandomString(),
+	}
+	// Copy existing global handlers
+	for k, v := range globalHandlers {
+		eng.handlers[k] = v
 	}
 	return eng, nil
 }
diff --git a/components/engine/server.go b/components/engine/server.go
index de79dd966d..72ad39cdce 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -60,10 +60,10 @@ func jobInitApi(job *engine.Job) string {
 		os.Exit(0)
 	}()
 	job.Eng.Hack_SetGlobalVar("httpapi.server", srv)
-	if err := engine.Register("start", srv.ContainerStart); err != nil {
+	if err := job.Eng.Register("start", srv.ContainerStart); err != nil {
 		return err.Error()
 	}
-	if err := engine.Register("serveapi", srv.ListenAndServe); err != nil {
+	if err := job.Eng.Register("serveapi", srv.ListenAndServe); err != nil {
 		return err.Error()
 	}
 	return "0"

From be8463c1d5899c8f3ea3fcd26db5155334fac8a3 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sun, 27 Oct 2013 06:57:29 +0000
Subject: [PATCH 014/184] Engine: don't export private testing utilities
 Upstream-commit: ca6f0aa107117d2125a63eb5e78d74095bf08a4c Component: engine

---
 components/engine/engine/utils.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/components/engine/engine/utils.go b/components/engine/engine/utils.go
index 58e5f9aae2..14ee4742ff 100644
--- a/components/engine/engine/utils.go
+++ b/components/engine/engine/utils.go
@@ -15,7 +15,7 @@ func init() {
 	Register("dummy", func(job *Job) string { return ""; })
 }
 
-func NewTestEngine(t *testing.T) *Engine {
+func newTestEngine(t *testing.T) *Engine {
 	// Use the caller function name as a prefix.
 	// This helps trace temp directories back to their test.
 	pc, _, _, _ := runtime.Caller(1)
@@ -38,5 +38,5 @@ func NewTestEngine(t *testing.T) *Engine {
 }
 
 func mkJob(t *testing.T, name string, args ...string) *Job {
-	return NewTestEngine(t).Job(name, args...)
+	return newTestEngine(t).Job(name, args...)
 }

From 18c16d13e346c415036cf1cfc1ffdccc9dd10bf1 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sun, 27 Oct 2013 07:01:15 +0000
Subject: [PATCH 015/184] Engine: improved logging and identification of jobs
 Upstream-commit: 4e7cb37dcc18975010df630d8c9580a3a65e0e69 Component: engine

---
 components/engine/engine/engine.go | 15 +++++++++++++++
 components/engine/engine/job.go    | 28 +++++++++++++++++++++++-----
 2 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/components/engine/engine/engine.go b/components/engine/engine/engine.go
index 956847adee..565c6ed4fa 100644
--- a/components/engine/engine/engine.go
+++ b/components/engine/engine/engine.go
@@ -5,6 +5,7 @@ import (
 	"os"
 	"log"
 	"runtime"
+	"strings"
 	"github.com/dotcloud/docker/utils"
 )
 
@@ -33,6 +34,11 @@ type Engine struct {
 	root		string
 	handlers	map[string]Handler
 	hack		Hack	// data for temporary hackery (see hack.go)
+	id		string
+}
+
+func (eng *Engine) Root() string {
+	return eng.root
 }
 
 func (eng *Engine) Register(name string, handler Handler) error {
@@ -84,6 +90,10 @@ func New(root string) (*Engine, error) {
 	return eng, nil
 }
 
+func (eng *Engine) String() string {
+	return fmt.Sprintf("%s|%s", eng.Root(), eng.id[:8])
+}
+
 // Job creates a new job which can later be executed.
 // This function mimics `Command` from the standard os/exec package.
 func (eng *Engine) Job(name string, args ...string) *Job {
@@ -102,3 +112,8 @@ func (eng *Engine) Job(name string, args ...string) *Job {
 	return job
 }
 
+
+func (eng *Engine) Logf(format string, args ...interface{}) (n int, err error) {
+	prefixedFormat := fmt.Sprintf("[%s] %s\n", eng, strings.TrimRight(format, "\n"))
+	return fmt.Printf(prefixedFormat, args...)
+}
diff --git a/components/engine/engine/job.go b/components/engine/engine/job.go
index 5c02fe15d5..7a261409e0 100644
--- a/components/engine/engine/job.go
+++ b/components/engine/engine/job.go
@@ -6,7 +6,6 @@ import (
 	"strings"
 	"fmt"
 	"encoding/json"
-	"github.com/dotcloud/docker/utils"
 )
 
 // A job is the fundamental unit of work in the docker engine.
@@ -38,9 +37,10 @@ type Job struct {
 // If the job returns a failure status, an error is returned
 // which includes the status.
 func (job *Job) Run() error {
-	randId := utils.RandomString()[:4]
-	fmt.Printf("Job #%s: %s\n", randId, job)
-	defer fmt.Printf("Job #%s: %s = '%s'", randId, job, job.status)
+	job.Logf("{")
+	defer func() {
+		job.Logf("}")
+	}()
 	if job.handler == nil {
 		job.status = "command not found"
 	} else {
@@ -54,7 +54,20 @@ func (job *Job) Run() error {
 
 // String returns a human-readable description of `job`
 func (job *Job) String() string {
-	return strings.Join(append([]string{job.Name}, job.Args...), " ")
+	s := fmt.Sprintf("%s.%s(%s)", job.Eng, job.Name, strings.Join(job.Args, ", "))
+	// FIXME: if a job returns the empty string, it will be printed
+	// as not having returned.
+	// (this only affects String which is a convenience function).
+	if job.status != "" {
+		var okerr string
+		if job.status == "0" {
+			okerr = "OK"
+		} else {
+			okerr = "ERR"
+		}
+		s = fmt.Sprintf("%s = %s (%s)", s, okerr, job.status)
+	}
+	return s
 }
 
 func (job *Job) Getenv(key string) (value string) {
@@ -169,3 +182,8 @@ func (job *Job) Environ() map[string]string {
 	}
 	return m
 }
+
+func (job *Job) Logf(format string, args ...interface{}) (n int, err error) {
+	prefixedFormat := fmt.Sprintf("[%s] %s\n", job, strings.TrimRight(format, "\n"))
+	return fmt.Fprintf(job.Stdout, prefixedFormat, args...)
+}

From 5d5633048a460aae53a7bdf8359ef620066b94b6 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sun, 27 Oct 2013 07:06:43 +0000
Subject: [PATCH 016/184] Engine: optional environment variable 'Logging' in
 'serveapi' Upstream-commit: 02ddaad5d985186eed94dea4105a57fa21ba24db
 Component: engine

---
 components/engine/docker/docker.go | 4 +++-
 components/engine/server.go        | 3 ++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/components/engine/docker/docker.go b/components/engine/docker/docker.go
index 2fc864adf4..e58bd40013 100644
--- a/components/engine/docker/docker.go
+++ b/components/engine/docker/docker.go
@@ -86,7 +86,9 @@ func main() {
 			log.Fatal(err)
 		}
 		// Serve api
-		if err := eng.Job("serveapi", flHosts...).Run(); err != nil {
+		job := eng.Job("serveapi", flHosts...)
+		job.Setenv("Logging", true)
+		if err := job.Run(); err != nil {
 			log.Fatal(err)
 		}
 	} else {
diff --git a/components/engine/server.go b/components/engine/server.go
index 72ad39cdce..c041491ead 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -88,7 +88,8 @@ func (srv *Server) ListenAndServe(job *engine.Job) string {
 			return "Invalid protocol format."
 		}
 		go func() {
-			chErrors <- ListenAndServe(protoAddrParts[0], protoAddrParts[1], srv, true)
+			// FIXME: merge Server.ListenAndServe with ListenAndServe
+			chErrors <- ListenAndServe(protoAddrParts[0], protoAddrParts[1], srv, job.GetenvBool("Logging"))
 		}()
 	}
 	for i := 0; i < len(protoAddrs); i += 1 {

From 8da2c74ae50b4d2309d29cc0183e99b8a7ffa6db Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Tue, 5 Nov 2013 14:28:57 -0600
Subject: [PATCH 017/184] Removed redundant linking example Upstream-commit:
 e88368b34cab8d4b7d5a1179cdd25fc9cd2b3d79 Component: engine

---
 .../engine/docs/sources/examples/index.rst    |   1 -
 .../sources/examples/linking_into_redis.rst   | 137 ------------------
 2 files changed, 138 deletions(-)
 delete mode 100644 components/engine/docs/sources/examples/linking_into_redis.rst

diff --git a/components/engine/docs/sources/examples/index.rst b/components/engine/docs/sources/examples/index.rst
index 6167e35652..ea3294d2d3 100644
--- a/components/engine/docs/sources/examples/index.rst
+++ b/components/engine/docs/sources/examples/index.rst
@@ -24,4 +24,3 @@ to more substantial services like those which you might find in production.
    postgresql_service
    mongodb
    running_riak_service
-   linking_into_redis
diff --git a/components/engine/docs/sources/examples/linking_into_redis.rst b/components/engine/docs/sources/examples/linking_into_redis.rst
deleted file mode 100644
index 1b91b8451d..0000000000
--- a/components/engine/docs/sources/examples/linking_into_redis.rst
+++ /dev/null
@@ -1,137 +0,0 @@
-:title: Linking to an Redis container
-:description: Running redis linked into your web app
-:keywords: docker, example, networking, redis, link
-
-.. _linking_redis:
-
-Linking Redis
-=============
-
-.. include:: example_header.inc
-
-Building a Redis container to link as a child of our web application.
-
-Building the Redis container
-----------------------------
-
-Lets build a Redis image with the following Dockerfile.
-
-First checkout the Redis source code.
-
-.. code-block:: bash
-
-    git clone https://github.com/antirez/redis.git
-    cd redis
-    git checkout 2.6
-
-
-Now let's create a Dockerfile in the root of the Redis repository.
-
-.. code-block:: bash
-
-    # Build redis from source
-    # Make sure you have the redis source code checked out in
-    # the same directory as this Dockerfile
-    FROM ubuntu
-
-    RUN echo "deb http://archive.ubuntu.com/ubuntu precise main universe" > /etc/apt/sources.list
-    RUN apt-get update
-    RUN apt-get upgrade -y
-
-    RUN apt-get install -y gcc make g++ build-essential libc6-dev tcl
-
-    ADD . /redis
-
-    RUN (cd /redis && make)
-
-    RUN mkdir -p /redis-data
-    VOLUME ["/redis-data"]
-    EXPOSE 6379
-
-    ENTRYPOINT ["/redis/src/redis-server"]
-    CMD ["--dir", "/redis-data"]
-
-    # docker build our new redis image from source
-    docker build -t redis-2.6 .
-
-
-We need to ``EXPOSE`` the default port of 6379 so that our link knows what ports 
-to connect to our Redis container on.  If you do not expose any ports for the
-image then docker will not be able to establish the link between containers.
-
-
-Run the Redis container
------------------------
-
-.. code-block:: bash
-
-    sudo docker run -d -e PASSWORD=docker -name redis redis-2.6 --requirepass docker
-
-This will run our Redis container with the password docker 
-to secure our service.  By specifying the ``-name`` flag on run 
-we will assign the name ``redis`` to this container.  If we do not specify a name for 
-our container via the ``-name`` flag docker will automatically generate a name for us.
-We can issue all the commands that you would expect; start, stop, attach, using the name for our container.
-The name also allows us to link other containers into this one.
-
-Linking Redis as a child
-------------------------
-
-Next we can start a new web application that has a dependency on Redis and apply a link 
-to connect both containers.  If you noticed when running our Redis server we did not use
-the ``-p`` flag to publish the Redis port to the host system.  Redis exposed port 6379 via the Dockerfile 
-and this is all we need to establish a link.
-
-Now let's start our web application with a link into Redis.
-
-.. code-block:: bash
-
-    sudo docker run -t -i -link redis:db -name webapp ubuntu bash
-
-    root@4c01db0b339c:/# env
-
-    HOSTNAME=4c01db0b339c
-    DB_NAME=/webapp/db
-    TERM=xterm
-    DB_PORT=tcp://172.17.0.8:6379
-    DB_PORT_6379_TCP=tcp://172.17.0.8:6379
-    DB_PORT_6379_TCP_PROTO=tcp
-    DB_PORT_6379_TCP_ADDR=172.17.0.8
-    DB_PORT_6379_TCP_PORT=6379
-    PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
-    PWD=/
-    DB_ENV_PASSWORD=docker
-    SHLVL=1
-    HOME=/
-    container=lxc
-    _=/usr/bin/env
-    root@4c01db0b339c:/#
-
-
-When we inspect the environment of the linked container we can see a few extra environment 
-variables have been added.  When you specified ``-link redis:db`` you are telling docker
-to link the container named ``redis`` into this new container with the alias ``db``.
-Environment variables are prefixed with the alias so that the parent container can access
-network and environment information from the containers that are linked into it.
-
-.. code-block:: bash
-
-    # The name of the child container
-    DB_NAME=/webapp/db
-
-    # The default protocol, ip, and port of the service running in the container
-    DB_PORT=tcp://172.17.0.8:6379
-
-    # A specific protocol, ip, and port of various services
-    DB_PORT_6379_TCP=tcp://172.17.0.8:6379
-    DB_PORT_6379_TCP_PROTO=tcp
-    DB_PORT_6379_TCP_ADDR=172.17.0.8
-    DB_PORT_6379_TCP_PORT=6379
-
-    # Get environment variables of the container 
-    DB_ENV_PASSWORD=docker
-
-
-Accessing the network information along with the environment of the child container allows
-us to easily connect to the Redis service on the specific IP and port and use the password
-specified in the environment.

From c13616829073ffd8846ef2eb3c1c20c484161837 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sun, 27 Oct 2013 07:13:45 +0000
Subject: [PATCH 018/184] Hack: simplify the creation of test directories
 Upstream-commit: 5a85456d481a5f88fc0efc02c41b3bff987c0ed1 Component: engine

---
 components/engine/runtime_test.go | 45 ++++++++-------
 components/engine/server_test.go  |  7 +--
 components/engine/utils/utils.go  |  6 ++
 components/engine/utils_test.go   | 96 +++++++++++++++++--------------
 4 files changed, 85 insertions(+), 69 deletions(-)

diff --git a/components/engine/runtime_test.go b/components/engine/runtime_test.go
index 4e46b7b6d0..4aac2f3442 100644
--- a/components/engine/runtime_test.go
+++ b/components/engine/runtime_test.go
@@ -3,6 +3,7 @@ package docker
 import (
 	"bytes"
 	"fmt"
+	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/sysinit"
 	"github.com/dotcloud/docker/utils"
 	"io"
@@ -17,6 +18,7 @@ import (
 	"syscall"
 	"testing"
 	"time"
+	"net/url"
 )
 
 const (
@@ -118,22 +120,19 @@ func init() {
 }
 
 func setupBaseImage() {
-	config := &DaemonConfig{
-		Root:        unitTestStoreBase,
-		AutoRestart: false,
-		BridgeIface: unitTestNetworkBridge,
-	}
-	runtime, err := NewRuntimeFromDirectory(config)
+	eng, err := engine.New(unitTestStoreBase)
 	if err != nil {
+		log.Fatalf("Can't initialize engine at %s: %s", unitTestStoreBase, err)
+	}
+	job := eng.Job("initapi")
+	job.Setenv("Root", unitTestStoreBase)
+	job.SetenvBool("Autorestart", false)
+	job.Setenv("BridgeIface", unitTestNetworkBridge)
+	if err := job.Run(); err != nil {
 		log.Fatalf("Unable to create a runtime for tests:", err)
 	}
-
-	// Create the "Server"
-	srv := &Server{
-		runtime:     runtime,
-		pullingPool: make(map[string]struct{}),
-		pushingPool: make(map[string]struct{}),
-	}
+	srv := mkServerFromEngine(eng, log.New(os.Stderr, "", 0))
+	runtime := srv.runtime
 
 	// If the unit test is not found, try to download it.
 	if img, err := runtime.repositories.LookupImage(unitTestImageName); err != nil || img.ID != unitTestImageID {
@@ -149,18 +148,22 @@ func spawnGlobalDaemon() {
 		utils.Debugf("Global runtime already exists. Skipping.")
 		return
 	}
-	globalRuntime = mkRuntime(log.New(os.Stderr, "", 0))
-	srv := &Server{
-		runtime:     globalRuntime,
-		pullingPool: make(map[string]struct{}),
-		pushingPool: make(map[string]struct{}),
-	}
+	t := log.New(os.Stderr, "", 0)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	globalRuntime = srv.runtime
 
 	// Spawn a Daemon
 	go func() {
 		utils.Debugf("Spawning global daemon for integration tests")
-		if err := ListenAndServe(testDaemonProto, testDaemonAddr, srv, os.Getenv("DEBUG") != ""); err != nil {
-			log.Fatalf("Unable to spawn the test daemon:", err)
+		listenURL := &url.URL{
+			Scheme:	testDaemonProto,
+			Host:	testDaemonAddr,
+		}
+		job := eng.Job("serveapi", listenURL.String())
+		job.SetenvBool("Logging", os.Getenv("DEBUG") != "")
+		if err := job.Run(); err != nil {
+			log.Fatalf("Unable to spawn the test daemon: %s", err)
 		}
 	}()
 	// Give some time to ListenAndServer to actually start
diff --git a/components/engine/server_test.go b/components/engine/server_test.go
index 20894f8fe1..a4bfb0155f 100644
--- a/components/engine/server_test.go
+++ b/components/engine/server_test.go
@@ -1,7 +1,6 @@
 package docker
 
 import (
-	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/utils"
 	"strings"
 	"testing"
@@ -110,7 +109,7 @@ func TestCreateRm(t *testing.T) {
 }
 
 func TestCreateRmVolumes(t *testing.T) {
-	eng := engine.NewTestEngine(t)
+	eng := NewTestEngine(t)
 
 	srv := mkServerFromEngine(eng, t)
 	runtime := srv.runtime
@@ -174,7 +173,7 @@ func TestCommit(t *testing.T) {
 }
 
 func TestCreateStartRestartStopStartKillRm(t *testing.T) {
-	eng := engine.NewTestEngine(t)
+	eng := NewTestEngine(t)
 	srv := mkServerFromEngine(eng, t)
 	runtime := srv.runtime
 	defer nuke(runtime)
@@ -397,7 +396,7 @@ func TestLogEvent(t *testing.T) {
 }
 
 func TestRmi(t *testing.T) {
-	eng := engine.NewTestEngine(t)
+	eng := NewTestEngine(t)
 	srv := mkServerFromEngine(eng, t)
 	runtime := srv.runtime
 	defer nuke(runtime)
diff --git a/components/engine/utils/utils.go b/components/engine/utils/utils.go
index cadd095031..5fd5e4e5b9 100644
--- a/components/engine/utils/utils.go
+++ b/components/engine/utils/utils.go
@@ -27,6 +27,12 @@ var (
 	INITSHA1  string // sha1sum of separate static dockerinit, if Docker itself was compiled dynamically via ./hack/make.sh dynbinary
 )
 
+// A common interface to access the Fatal method of
+// both testing.B and testing.T.
+type Fataler interface {
+	Fatal(args ...interface{})
+}
+
 // ListOpts type
 type ListOpts []string
 
diff --git a/components/engine/utils_test.go b/components/engine/utils_test.go
index 282954285c..95e12b6393 100644
--- a/components/engine/utils_test.go
+++ b/components/engine/utils_test.go
@@ -21,27 +21,24 @@ var globalTestID string
 
 // Create a temporary runtime suitable for unit testing.
 // Call t.Fatal() at the first error.
-func mkRuntime(f Fataler) *Runtime {
-	// Use the caller function name as a prefix.
-	// This helps trace temp directories back to their test.
-	pc, _, _, _ := runtime.Caller(1)
-	callerLongName := runtime.FuncForPC(pc).Name()
-	parts := strings.Split(callerLongName, ".")
-	callerShortName := parts[len(parts)-1]
-	if globalTestID == "" {
-		globalTestID = GenerateID()[:4]
-	}
-	prefix := fmt.Sprintf("docker-test%s-%s-", globalTestID, callerShortName)
-	utils.Debugf("prefix = '%s'", prefix)
-
-	runtime, err := newTestRuntime(prefix)
+func mkRuntime(f utils.Fataler) *Runtime {
+	root, err := newTestDirectory(unitTestStoreBase)
 	if err != nil {
 		f.Fatal(err)
 	}
-	return runtime
+	config := &DaemonConfig{
+		Root:   root,
+		AutoRestart: false,
+	}
+	r, err := NewRuntimeFromDirectory(config)
+	if err != nil {
+		f.Fatal(err)
+	}
+	r.UpdateCapabilities(true)
+	return r
 }
 
-func mkServerFromEngine(eng *engine.Engine, t Fataler) *Server {
+func mkServerFromEngine(eng *engine.Engine, t utils.Fataler) *Server {
 	iSrv := eng.Hack_GetGlobalVar("httpapi.server")
 	if iSrv == nil {
 		t.Fatal("Legacy server field not set in engine")
@@ -53,42 +50,53 @@ func mkServerFromEngine(eng *engine.Engine, t Fataler) *Server {
 	return srv
 }
 
-// A common interface to access the Fatal method of
-// both testing.B and testing.T.
-type Fataler interface {
-	Fatal(args ...interface{})
+
+func NewTestEngine(t utils.Fataler) *engine.Engine {
+	root, err := newTestDirectory(unitTestStoreBase)
+	if err != nil {
+		t.Fatal(err)
+	}
+	eng, err := engine.New(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Load default plugins
+	// (This is manually copied and modified from main() until we have a more generic plugin system)
+	job := eng.Job("initapi")
+	job.Setenv("Root", root)
+	job.SetenvBool("AutoRestart", false)
+	if err := job.Run(); err != nil {
+		t.Fatal(err)
+	}
+	return eng
 }
 
-func newTestRuntime(prefix string) (runtime *Runtime, err error) {
+func newTestDirectory(templateDir string) (dir string, err error) {
+	if globalTestID == "" {
+		globalTestID = GenerateID()[:4]
+	}
+	prefix := fmt.Sprintf("docker-test%s-%s-", globalTestID, getCallerName(2))
 	if prefix == "" {
 		prefix = "docker-test-"
 	}
-	utils.Debugf("prefix = %s", prefix)
-	utils.Debugf("newTestRuntime start")
-	root, err := ioutil.TempDir("", prefix)
-	defer func() {
-		utils.Debugf("newTestRuntime: %s", root)
-	}()
-	if err != nil {
-		return nil, err
+	dir, err = ioutil.TempDir("", prefix)
+	if err = os.Remove(dir); err != nil {
+		return
 	}
-	if err := os.Remove(root); err != nil {
-		return nil, err
-	}
-	if err := utils.CopyDirectory(unitTestStoreBase, root); err != nil {
-		return nil, err
+	if err = utils.CopyDirectory(templateDir, dir); err != nil {
+		return
 	}
+	return
+}
 
-	config := &DaemonConfig{
-		Root:   root,
-		AutoRestart: false,
-	}
-	runtime, err = NewRuntimeFromDirectory(config)
-	if err != nil {
-		return nil, err
-	}
-	runtime.UpdateCapabilities(true)
-	return runtime, nil
+func getCallerName(depth int) string {
+	// Use the caller function name as a prefix.
+	// This helps trace temp directories back to their test.
+	pc, _, _, _ := runtime.Caller(depth + 1)
+	callerLongName := runtime.FuncForPC(pc).Name()
+	parts := strings.Split(callerLongName, ".")
+	callerShortName := parts[len(parts)-1]
+	return callerShortName
 }
 
 // Write `content` to the file at path `dst`, creating it if necessary,

From 53c37bc88ef3a60c1be138e42f4605ead115694f Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sun, 27 Oct 2013 07:15:22 +0000
Subject: [PATCH 019/184] Engine: fix a bug when encoding a job environment to
 json Upstream-commit: 434f06d03dc2825cb4f348a88ddc6d1aa17ea19c Component:
 engine

---
 components/engine/api.go        |  3 +++
 components/engine/engine/job.go | 16 ++++++++++++++--
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index 1a3d92de32..18251eba2f 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -644,6 +644,9 @@ func postContainersStart(srv *Server, version float64, w http.ResponseWriter, r
 	}
 	name := vars["name"]
 	job := srv.Eng.Job("start", name)
+	if err := job.ImportEnv(HostConfig{}); err != nil {
+		return fmt.Errorf("Couldn't initialize host configuration")
+	}
 	// allow a nil body for backwards compatibility
 	if r.Body != nil {
 		if matchesContentType(r.Header.Get("Content-Type"), "application/json") {
diff --git a/components/engine/engine/job.go b/components/engine/engine/job.go
index 7a261409e0..b6296eb91d 100644
--- a/components/engine/engine/job.go
+++ b/components/engine/engine/job.go
@@ -149,10 +149,22 @@ func (job *Job) DecodeEnv(src io.Reader) error {
 }
 
 func (job *Job) EncodeEnv(dst io.Writer) error {
-	return json.NewEncoder(dst).Encode(job.Environ())
+	m := make(map[string]interface{})
+	for k, v := range job.Environ() {
+		var val interface{}
+		if err := json.Unmarshal([]byte(v), &val); err == nil {
+			m[k] = val
+		} else {
+			m[k] = v
+		}
+	}
+	if err := json.NewEncoder(dst).Encode(&m); err != nil {
+		return err
+	}
+	return nil
 }
 
-func (job *Job) ExportEnv(dst interface{}) error {
+func (job *Job) ExportEnv(dst interface{}) (err error) {
 	var buf bytes.Buffer
 	if err := job.EncodeEnv(&buf); err != nil {
 		return err

From c3fb3fd5123b23dd7f16fee3012726bb84f4e4e2 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sun, 27 Oct 2013 07:16:32 +0000
Subject: [PATCH 020/184] Better error reporting in engine logs and unit tests
 Upstream-commit: d3f074494a9594bc268bf4c639a7aea0934ec7c0 Component: engine

---
 components/engine/runtime_test.go | 2 +-
 components/engine/server.go       | 7 ++++++-
 components/engine/utils_test.go   | 4 ++--
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/components/engine/runtime_test.go b/components/engine/runtime_test.go
index 4aac2f3442..946a8ebf61 100644
--- a/components/engine/runtime_test.go
+++ b/components/engine/runtime_test.go
@@ -183,7 +183,7 @@ func GetTestImage(runtime *Runtime) *Image {
 			return image
 		}
 	}
-	log.Fatalf("Test image %v not found", unitTestImageID)
+	log.Fatalf("Test image %v not found in %s: %s", unitTestImageID, runtime.graph.Root, imgs)
 	return nil
 }
 
diff --git a/components/engine/server.go b/components/engine/server.go
index c041491ead..0a1270bede 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -40,6 +40,7 @@ func init() {
 // Only one api server can run at the same time - this is enforced by a pidfile.
 // The signals SIGINT, SIGKILL and SIGTERM are intercepted for cleanup.
 func jobInitApi(job *engine.Job) string {
+	job.Logf("Creating server")
 	srv, err := NewServer(job.Eng, ConfigFromJob(job))
 	if err != nil {
 		return err.Error()
@@ -50,6 +51,7 @@ func jobInitApi(job *engine.Job) string {
 			log.Fatal(err)
 		}
 	}
+	job.Logf("Setting up signal traps")
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, os.Interrupt, os.Kill, os.Signal(syscall.SIGTERM))
 	go func() {
@@ -1288,7 +1290,7 @@ func (srv *Server) RegisterLinks(name string, hostConfig *HostConfig) error {
 		return fmt.Errorf("No such container: %s", name)
 	}
 
-	if hostConfig.Links != nil {
+	if hostConfig != nil && hostConfig.Links != nil {
 		for _, l := range hostConfig.Links {
 			parts, err := parseLink(l)
 			if err != nil {
@@ -1317,11 +1319,14 @@ func (srv *Server) RegisterLinks(name string, hostConfig *HostConfig) error {
 }
 
 func (srv *Server) ContainerStart(job *engine.Job) string {
+	job.Logf("srv engine = %s", srv.Eng.Root())
+	job.Logf("job engine = %s", job.Eng.Root())
 	if len(job.Args) < 1 {
 		return fmt.Sprintf("Usage: %s container_id", job.Name)
 	}
 	name := job.Args[0]
 	runtime := srv.runtime
+	job.Logf("loading containers from %s", runtime.repository)
 	container := runtime.Get(name)
 	if container == nil {
 		return fmt.Sprintf("No such container: %s", name)
diff --git a/components/engine/utils_test.go b/components/engine/utils_test.go
index 95e12b6393..529af127e5 100644
--- a/components/engine/utils_test.go
+++ b/components/engine/utils_test.go
@@ -41,11 +41,11 @@ func mkRuntime(f utils.Fataler) *Runtime {
 func mkServerFromEngine(eng *engine.Engine, t utils.Fataler) *Server {
 	iSrv := eng.Hack_GetGlobalVar("httpapi.server")
 	if iSrv == nil {
-		t.Fatal("Legacy server field not set in engine")
+		panic("Legacy server field not set in engine")
 	}
 	srv, ok := iSrv.(*Server)
 	if !ok {
-		t.Fatal("Legacy server field in engine does not cast to *Server")
+		panic("Legacy server field in engine does not cast to *Server")
 	}
 	return srv
 }

From bf0674c59a158fd9910142950dfbecd8c03d57d1 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Tue, 5 Nov 2013 19:57:40 +0000
Subject: [PATCH 021/184] Fix main() Upstream-commit:
 5c42b2b5122c1db08d229c258da26869b4d4d9cc Component: engine

---
 components/engine/docker/docker.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/components/engine/docker/docker.go b/components/engine/docker/docker.go
index e58bd40013..213ec73fd9 100644
--- a/components/engine/docker/docker.go
+++ b/components/engine/docker/docker.go
@@ -86,8 +86,8 @@ func main() {
 			log.Fatal(err)
 		}
 		// Serve api
-		job := eng.Job("serveapi", flHosts...)
-		job.Setenv("Logging", true)
+		job = eng.Job("serveapi", flHosts...)
+		job.SetenvBool("Logging", true)
 		if err := job.Run(); err != nil {
 			log.Fatal(err)
 		}

From e6df3df72cabaa67df3030445aca7f87562981b2 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sun, 27 Oct 2013 19:20:00 -0700
Subject: [PATCH 022/184] Engine: 'create' creates a container and prints its
 ID on stdout Upstream-commit: e5f8ab6160401fb541121da5b5cbc3af4fce28b7
 Component: engine

---
 components/engine/api.go           |  31 +++---
 components/engine/api_test.go      |  28 ++---
 components/engine/engine/engine.go |   2 +-
 components/engine/engine/job.go    | 165 ++++++++++++++++++++++++++---
 components/engine/runtime_test.go  |  58 ++++------
 components/engine/server.go        |  35 ++++--
 components/engine/server_test.go   |  64 ++++-------
 components/engine/utils_test.go    |  16 +++
 8 files changed, 260 insertions(+), 139 deletions(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index 18251eba2f..1fc74d764a 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -526,43 +526,36 @@ func postContainersCreate(srv *Server, version float64, w http.ResponseWriter, r
 	if err := parseForm(r); err != nil {
 		return nil
 	}
-	config := &Config{}
 	out := &APIRun{}
-	name := r.Form.Get("name")
-
-	if err := json.NewDecoder(r.Body).Decode(config); err != nil {
+	job := srv.Eng.Job("create", r.Form.Get("name"))
+	if err := job.DecodeEnv(r.Body); err != nil {
 		return err
 	}
-
 	resolvConf, err := utils.GetResolvConf()
 	if err != nil {
 		return err
 	}
-
-	if !config.NetworkDisabled && len(config.Dns) == 0 && len(srv.runtime.config.Dns) == 0 && utils.CheckLocalDns(resolvConf) {
+	if !job.GetenvBool("NetworkDisabled") && len(job.Getenv("Dns")) == 0 && len(srv.runtime.config.Dns) == 0 && utils.CheckLocalDns(resolvConf) {
 		out.Warnings = append(out.Warnings, fmt.Sprintf("Docker detected local DNS server on resolv.conf. Using default external servers: %v", defaultDns))
-		config.Dns = defaultDns
+		job.SetenvList("Dns", defaultDns)
 	}
-
-	id, warnings, err := srv.ContainerCreate(config, name)
-	if err != nil {
+	// Read container ID from the first line of stdout
+	job.StdoutParseString(&out.ID)
+	// Read warnings from stderr
+	job.StderrParseLines(&out.Warnings, 0)
+	if err := job.Run(); err != nil {
 		return err
 	}
-	out.ID = id
-	for _, warning := range warnings {
-		out.Warnings = append(out.Warnings, warning)
-	}
-
-	if config.Memory > 0 && !srv.runtime.capabilities.MemoryLimit {
+	if job.GetenvInt("Memory") > 0 && !srv.runtime.capabilities.MemoryLimit {
 		log.Println("WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.")
 		out.Warnings = append(out.Warnings, "Your kernel does not support memory limit capabilities. Limitation discarded.")
 	}
-	if config.Memory > 0 && !srv.runtime.capabilities.SwapLimit {
+	if job.GetenvInt("Memory") > 0 && !srv.runtime.capabilities.SwapLimit {
 		log.Println("WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.")
 		out.Warnings = append(out.Warnings, "Your kernel does not support memory swap capabilities. Limitation discarded.")
 	}
 
-	if !config.NetworkDisabled && srv.runtime.capabilities.IPv4ForwardingDisabled {
+	if !job.GetenvBool("NetworkDisabled") && srv.runtime.capabilities.IPv4ForwardingDisabled {
 		log.Println("Warning: IPv4 forwarding is disabled.")
 		out.Warnings = append(out.Warnings, "IPv4 forwarding is disabled.")
 	}
diff --git a/components/engine/api_test.go b/components/engine/api_test.go
index 50a86e3f23..7b0dfaa077 100644
--- a/components/engine/api_test.go
+++ b/components/engine/api_test.go
@@ -634,11 +634,11 @@ func TestPostCommit(t *testing.T) {
 }
 
 func TestPostContainersCreate(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
-
 	configJSON, err := json.Marshal(&Config{
 		Image:  GetTestImage(runtime).ID,
 		Memory: 33554432,
@@ -786,22 +786,18 @@ func TestPostContainersStart(t *testing.T) {
 	runtime := srv.runtime
 	defer nuke(runtime)
 
-	container, _, err := runtime.Create(
+	id := createTestContainer(
+		eng,
 		&Config{
 			Image:     GetTestImage(runtime).ID,
 			Cmd:       []string{"/bin/cat"},
 			OpenStdin: true,
 		},
-		"",
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
+		t)
 
 	hostConfigJSON, err := json.Marshal(&HostConfig{})
 
-	req, err := http.NewRequest("POST", "/containers/"+container.ID+"/start", bytes.NewReader(hostConfigJSON))
+	req, err := http.NewRequest("POST", "/containers/"+id+"/start", bytes.NewReader(hostConfigJSON))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -809,22 +805,26 @@ func TestPostContainersStart(t *testing.T) {
 	req.Header.Set("Content-Type", "application/json")
 
 	r := httptest.NewRecorder()
-	if err := postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+	if err := postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": id}); err != nil {
 		t.Fatal(err)
 	}
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
 
+	container := runtime.Get(id)
+	if container == nil {
+		t.Fatalf("Container %s was not created", id)
+	}
 	// Give some time to the process to start
+	// FIXME: use Wait once it's available as a job
 	container.WaitTimeout(500 * time.Millisecond)
-
 	if !container.State.Running {
 		t.Errorf("Container should be running")
 	}
 
 	r = httptest.NewRecorder()
-	if err = postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err == nil {
+	if err = postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": id}); err == nil {
 		t.Fatalf("A running container should be able to be started")
 	}
 
diff --git a/components/engine/engine/engine.go b/components/engine/engine/engine.go
index 565c6ed4fa..428ef706c9 100644
--- a/components/engine/engine/engine.go
+++ b/components/engine/engine/engine.go
@@ -115,5 +115,5 @@ func (eng *Engine) Job(name string, args ...string) *Job {
 
 func (eng *Engine) Logf(format string, args ...interface{}) (n int, err error) {
 	prefixedFormat := fmt.Sprintf("[%s] %s\n", eng, strings.TrimRight(format, "\n"))
-	return fmt.Printf(prefixedFormat, args...)
+	return fmt.Fprintf(os.Stderr, prefixedFormat, args...)
 }
diff --git a/components/engine/engine/job.go b/components/engine/engine/job.go
index b6296eb91d..ece8d8f8d6 100644
--- a/components/engine/engine/job.go
+++ b/components/engine/engine/job.go
@@ -1,11 +1,16 @@
 package engine
 
 import (
+	"bufio"
 	"bytes"
 	"io"
+	"io/ioutil"
+	"strconv"
 	"strings"
 	"fmt"
+	"sync"
 	"encoding/json"
+	"os"
 )
 
 // A job is the fundamental unit of work in the docker engine.
@@ -26,20 +31,38 @@ type Job struct {
 	Name	string
 	Args	[]string
 	env	[]string
-	Stdin	io.ReadCloser
-	Stdout	io.WriteCloser
-	Stderr	io.WriteCloser
+	Stdin	io.Reader
+	Stdout	io.Writer
+	Stderr	io.Writer
 	handler	func(*Job) string
 	status	string
+	onExit	[]func()
 }
 
 // Run executes the job and blocks until the job completes.
 // If the job returns a failure status, an error is returned
 // which includes the status.
 func (job *Job) Run() error {
-	job.Logf("{")
 	defer func() {
-		job.Logf("}")
+		var wg sync.WaitGroup
+		for _, f := range job.onExit {
+			wg.Add(1)
+			go func(f func()) {
+				f()
+				wg.Done()
+			}(f)
+		}
+		wg.Wait()
+	}()
+	if job.Stdout != nil && job.Stdout != os.Stdout {
+		job.Stdout = io.MultiWriter(job.Stdout, os.Stdout)
+	}
+	if job.Stderr != nil && job.Stderr != os.Stderr {
+		job.Stderr = io.MultiWriter(job.Stderr, os.Stderr)
+	}
+	job.Eng.Logf("+job %s", job.CallString())
+	defer func() {
+		job.Eng.Logf("-job %s%s", job.CallString(), job.StatusString())
 	}()
 	if job.handler == nil {
 		job.status = "command not found"
@@ -52,9 +75,66 @@ func (job *Job) Run() error {
 	return nil
 }
 
-// String returns a human-readable description of `job`
-func (job *Job) String() string {
-	s := fmt.Sprintf("%s.%s(%s)", job.Eng, job.Name, strings.Join(job.Args, ", "))
+func (job *Job) StdoutParseLines(dst *[]string, limit int) {
+	job.parseLines(job.StdoutPipe(), dst, limit)
+}
+
+func (job *Job) StderrParseLines(dst *[]string, limit int) {
+	job.parseLines(job.StderrPipe(), dst, limit)
+}
+
+func (job *Job) parseLines(src io.Reader, dst *[]string, limit int) {
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		scanner := bufio.NewScanner(src)
+		for scanner.Scan() {
+			// If the limit is reached, flush the rest of the source and return
+			if limit > 0 && len(*dst) >= limit {
+				io.Copy(ioutil.Discard, src)
+				return
+			}
+			line := scanner.Text()
+			// Append the line (with delimitor removed)
+			*dst = append(*dst, line)
+		}
+	}()
+	job.onExit = append(job.onExit, wg.Wait)
+}
+
+func (job *Job) StdoutParseString(dst *string) {
+	lines := make([]string, 0, 1)
+	job.StdoutParseLines(&lines, 1)
+	job.onExit = append(job.onExit, func() { if len(lines) >= 1 { *dst = lines[0] }})
+}
+
+func (job *Job) StderrParseString(dst *string) {
+	lines := make([]string, 0, 1)
+	job.StderrParseLines(&lines, 1)
+	job.onExit = append(job.onExit, func() { *dst = lines[0]; })
+}
+
+func (job *Job) StdoutPipe() io.ReadCloser {
+	r, w := io.Pipe()
+	job.Stdout = w
+	job.onExit = append(job.onExit, func(){ w.Close() })
+	return r
+}
+
+func (job *Job) StderrPipe() io.ReadCloser {
+	r, w := io.Pipe()
+	job.Stderr = w
+	job.onExit = append(job.onExit, func(){ w.Close() })
+	return r
+}
+
+
+func (job *Job) CallString() string {
+	return fmt.Sprintf("%s(%s)", job.Name, strings.Join(job.Args, ", "))
+}
+
+func (job *Job) StatusString() string {
 	// FIXME: if a job returns the empty string, it will be printed
 	// as not having returned.
 	// (this only affects String which is a convenience function).
@@ -65,9 +145,14 @@ func (job *Job) String() string {
 		} else {
 			okerr = "ERR"
 		}
-		s = fmt.Sprintf("%s = %s (%s)", s, okerr, job.status)
+		return fmt.Sprintf(" = %s (%s)", okerr, job.status)
 	}
-	return s
+	return ""
+}
+
+// String returns a human-readable description of `job`
+func (job *Job) String() string {
+	return fmt.Sprintf("%s.%s%s", job.Eng, job.CallString(), job.StatusString())
 }
 
 func (job *Job) Getenv(key string) (value string) {
@@ -104,6 +189,19 @@ func (job *Job) SetenvBool(key string, value bool) {
 	}
 }
 
+func (job *Job) GetenvInt(key string) int64 {
+	s := strings.Trim(job.Getenv(key), " \t")
+	val, err := strconv.ParseInt(s, 10, 64)
+	if err != nil {
+		return -1
+	}
+	return val
+}
+
+func (job *Job) SetenvInt(key string, value int64) {
+	job.Setenv(key, fmt.Sprintf("%d", value))
+}
+
 func (job *Job) GetenvList(key string) []string {
 	sval := job.Getenv(key)
 	l := make([]string, 0, 1)
@@ -137,13 +235,21 @@ func (job *Job) DecodeEnv(src io.Reader) error {
 		return err
 	}
 	for k, v := range m {
-		if sval, ok := v.(string); ok {
+		// FIXME: we fix-convert float values to int, because
+		// encoding/json decodes integers to float64, but cannot encode them back.
+		// (See http://golang.org/src/pkg/encoding/json/decode.go#L46)
+		if fval, ok := v.(float64); ok {
+			job.Logf("Converted to float: %v->%v", v, fval)
+			job.SetenvInt(k, int64(fval))
+		} else if sval, ok := v.(string); ok {
+			job.Logf("Converted to string: %v->%v", v, sval)
 			job.Setenv(k, sval)
 		} else	if val, err := json.Marshal(v); err == nil {
 			job.Setenv(k, string(val))
 		} else {
 			job.Setenv(k, fmt.Sprintf("%v", v))
 		}
+		job.Logf("Decoded %s=%#v to %s=%#v", k, v, k, job.Getenv(k))
 	}
 	return nil
 }
@@ -153,10 +259,17 @@ func (job *Job) EncodeEnv(dst io.Writer) error {
 	for k, v := range job.Environ() {
 		var val interface{}
 		if err := json.Unmarshal([]byte(v), &val); err == nil {
+			// FIXME: we fix-convert float values to int, because
+			// encoding/json decodes integers to float64, but cannot encode them back.
+			// (See http://golang.org/src/pkg/encoding/json/decode.go#L46)
+			if fval, isFloat := val.(float64); isFloat {
+				val = int(fval)
+			}
 			m[k] = val
 		} else {
 			m[k] = v
 		}
+		job.Logf("Encoded %s=%#v to %s=%#v", k, v, k, m[k])
 	}
 	if err := json.NewEncoder(dst).Encode(&m); err != nil {
 		return err
@@ -165,21 +278,38 @@ func (job *Job) EncodeEnv(dst io.Writer) error {
 }
 
 func (job *Job) ExportEnv(dst interface{}) (err error) {
+	fmt.Fprintf(os.Stderr, "ExportEnv()\n")
+	defer func() {
+		if err != nil {
+			err = fmt.Errorf("ExportEnv %s", err)
+		}
+	}()
 	var buf bytes.Buffer
+	job.Logf("ExportEnv: step 1: encode/marshal the env to an intermediary json representation")
+	fmt.Fprintf(os.Stderr, "Printed ExportEnv step 1\n")
 	if err := job.EncodeEnv(&buf); err != nil {
 		return err
 	}
+	job.Logf("ExportEnv: step 1 complete: json=|%s|", buf)
+	job.Logf("ExportEnv: step 2: decode/unmarshal the intermediary json into the destination object")
 	if err := json.NewDecoder(&buf).Decode(dst); err != nil {
 		return err
 	}
+	job.Logf("ExportEnv: step 2 complete")
 	return nil
 }
 
-func (job *Job) ImportEnv(src interface{}) error {
+func (job *Job) ImportEnv(src interface{}) (err error) {
+	defer func() {
+		if err != nil {
+			err = fmt.Errorf("ImportEnv: %s", err)
+		}
+	}()
 	var buf bytes.Buffer
 	if err := json.NewEncoder(&buf).Encode(src); err != nil {
 		return err
 	}
+	job.Logf("ImportEnv: json=|%s|", buf)
 	if err := job.DecodeEnv(&buf); err != nil {
 		return err
 	}
@@ -197,5 +327,14 @@ func (job *Job) Environ() map[string]string {
 
 func (job *Job) Logf(format string, args ...interface{}) (n int, err error) {
 	prefixedFormat := fmt.Sprintf("[%s] %s\n", job, strings.TrimRight(format, "\n"))
-	return fmt.Fprintf(job.Stdout, prefixedFormat, args...)
+	return fmt.Fprintf(job.Stderr, prefixedFormat, args...)
+}
+
+func (job *Job) Printf(format string, args ...interface{}) (n int, err error) {
+	return fmt.Fprintf(job.Stdout, format, args...)
+}
+
+func (job *Job) Errorf(format string, args ...interface{}) (n int, err error) {
+	return fmt.Fprintf(job.Stderr, format, args...)
+
 }
diff --git a/components/engine/runtime_test.go b/components/engine/runtime_test.go
index 946a8ebf61..ce69465961 100644
--- a/components/engine/runtime_test.go
+++ b/components/engine/runtime_test.go
@@ -645,20 +645,17 @@ func TestReloadContainerLinks(t *testing.T) {
 }
 
 func TestDefaultContainerName(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
-	srv := &Server{runtime: runtime}
 
 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	shortId, _, err := srv.ContainerCreate(config, "some_name")
-	if err != nil {
-		t.Fatal(err)
-	}
-	container := runtime.Get(shortId)
+	container := runtime.Get(createNamedTestContainer(eng, config, t, "some_name"))
 	containerID := container.ID
 
 	if container.Name != "/some_name" {
@@ -682,20 +679,17 @@ func TestDefaultContainerName(t *testing.T) {
 }
 
 func TestRandomContainerName(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
-	srv := &Server{runtime: runtime}
 
 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	shortId, _, err := srv.ContainerCreate(config, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	container := runtime.Get(shortId)
+	container := runtime.Get(createTestContainer(eng, config, t))
 	containerID := container.ID
 
 	if container.Name == "" {
@@ -719,20 +713,17 @@ func TestRandomContainerName(t *testing.T) {
 }
 
 func TestLinkChildContainer(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
-	srv := &Server{runtime: runtime}
 
 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	shortId, _, err := srv.ContainerCreate(config, "/webapp")
-	if err != nil {
-		t.Fatal(err)
-	}
-	container := runtime.Get(shortId)
+	container := runtime.Get(createNamedTestContainer(eng, config, t, "/webapp"))
 
 	webapp, err := runtime.GetByName("/webapp")
 	if err != nil {
@@ -748,12 +739,7 @@ func TestLinkChildContainer(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	shortId, _, err = srv.ContainerCreate(config, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	childContainer := runtime.Get(shortId)
+	childContainer := runtime.Get(createTestContainer(eng, config, t))
 
 	if err := runtime.RegisterLink(webapp, childContainer, "db"); err != nil {
 		t.Fatal(err)
@@ -770,20 +756,17 @@ func TestLinkChildContainer(t *testing.T) {
 }
 
 func TestGetAllChildren(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
-	srv := &Server{runtime: runtime}
 
 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	shortId, _, err := srv.ContainerCreate(config, "/webapp")
-	if err != nil {
-		t.Fatal(err)
-	}
-	container := runtime.Get(shortId)
+	container := runtime.Get(createNamedTestContainer(eng, config, t, "/webapp"))
 
 	webapp, err := runtime.GetByName("/webapp")
 	if err != nil {
@@ -799,12 +782,7 @@ func TestGetAllChildren(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	shortId, _, err = srv.ContainerCreate(config, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	childContainer := runtime.Get(shortId)
+	childContainer := runtime.Get(createTestContainer(eng, config, t))
 
 	if err := runtime.RegisterLink(webapp, childContainer, "db"); err != nil {
 		t.Fatal(err)
diff --git a/components/engine/server.go b/components/engine/server.go
index 0a1270bede..6196df8981 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -62,6 +62,9 @@ func jobInitApi(job *engine.Job) string {
 		os.Exit(0)
 	}()
 	job.Eng.Hack_SetGlobalVar("httpapi.server", srv)
+	if err := job.Eng.Register("create", srv.ContainerCreate); err != nil {
+		return err.Error()
+	}
 	if err := job.Eng.Register("start", srv.ContainerStart); err != nil {
 		return err.Error()
 	}
@@ -1009,33 +1012,43 @@ func (srv *Server) ImageImport(src, repo, tag string, in io.Reader, out io.Write
 	return nil
 }
 
-func (srv *Server) ContainerCreate(config *Config, name string) (string, []string, error) {
-	if config.Memory != 0 && config.Memory < 524288 {
-		return "", nil, fmt.Errorf("Memory limit must be given in bytes (minimum 524288 bytes)")
+func (srv *Server) ContainerCreate(job *engine.Job) string {
+	var name string
+	if len(job.Args) == 1 {
+		name = job.Args[0]
+	} else if len(job.Args) > 1 {
+		return fmt.Sprintf("Usage: %s ", job.Name)
+	}
+	var config Config
+	if err := job.ExportEnv(&config); err != nil {
+		return err.Error()
+	}
+	if config.Memory != 0 && config.Memory < 524288 {
+		return "Memory limit must be given in bytes (minimum 524288 bytes)"
 	}
-
 	if config.Memory > 0 && !srv.runtime.capabilities.MemoryLimit {
 		config.Memory = 0
 	}
-
 	if config.Memory > 0 && !srv.runtime.capabilities.SwapLimit {
 		config.MemorySwap = -1
 	}
-	container, buildWarnings, err := srv.runtime.Create(config, name)
+	container, buildWarnings, err := srv.runtime.Create(&config, name)
 	if err != nil {
 		if srv.runtime.graph.IsNotExist(err) {
-
 			_, tag := utils.ParseRepositoryTag(config.Image)
 			if tag == "" {
 				tag = DEFAULTTAG
 			}
-
-			return "", nil, fmt.Errorf("No such image: %s (tag: %s)", config.Image, tag)
+			return fmt.Sprintf("No such image: %s (tag: %s)", config.Image, tag)
 		}
-		return "", nil, err
+		return err.Error()
 	}
 	srv.LogEvent("create", container.ShortID(), srv.runtime.repositories.ImageName(container.Image))
-	return container.ShortID(), buildWarnings, nil
+	job.Printf("%s\n", container.ShortID())
+	for _, warning := range buildWarnings {
+		job.Errorf("%s\n", warning)
+	}
+	return "0"
 }
 
 func (srv *Server) ContainerRestart(name string, t int) error {
diff --git a/components/engine/server_test.go b/components/engine/server_test.go
index a4bfb0155f..111043eca2 100644
--- a/components/engine/server_test.go
+++ b/components/engine/server_test.go
@@ -79,20 +79,17 @@ func TestContainerTagImageDelete(t *testing.T) {
 }
 
 func TestCreateRm(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
-
 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	id, _, err := srv.ContainerCreate(config, "")
-	if err != nil {
-		t.Fatal(err)
-	}
+	id := createTestContainer(eng, config, t)
 
 	if len(runtime.List()) != 1 {
 		t.Errorf("Expected 1 container, %v found", len(runtime.List()))
@@ -120,10 +117,7 @@ func TestCreateRmVolumes(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	id, _, err := srv.ContainerCreate(config, "")
-	if err != nil {
-		t.Fatal(err)
-	}
+	id := createTestContainer(eng, config, t)
 
 	if len(runtime.List()) != 1 {
 		t.Errorf("Expected 1 container, %v found", len(runtime.List()))
@@ -152,20 +146,17 @@ func TestCreateRmVolumes(t *testing.T) {
 }
 
 func TestCommit(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
-
 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "/bin/cat"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	id, _, err := srv.ContainerCreate(config, "")
-	if err != nil {
-		t.Fatal(err)
-	}
+	id := createTestContainer(eng, config, t)
 
 	if _, err := srv.ContainerCommit(id, "testrepo", "testtag", "", "", config); err != nil {
 		t.Fatal(err)
@@ -183,10 +174,7 @@ func TestCreateStartRestartStopStartKillRm(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	id, _, err := srv.ContainerCreate(config, "")
-	if err != nil {
-		t.Fatal(err)
-	}
+	id := createTestContainer(eng, config, t)
 
 	if len(runtime.List()) != 1 {
 		t.Errorf("Expected 1 container, %v found", len(runtime.List()))
@@ -232,22 +220,22 @@ func TestCreateStartRestartStopStartKillRm(t *testing.T) {
 }
 
 func TestRunWithTooLowMemoryLimit(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	runtime := srv.runtime
 	defer nuke(runtime)
 
 	// Try to create a container with a memory limit of 1 byte less than the minimum allowed limit.
-	if _, _, err := (*Server).ContainerCreate(&Server{runtime: runtime},
-		&Config{
-			Image:     GetTestImage(runtime).ID,
-			Memory:    524287,
-			CpuShares: 1000,
-			Cmd:       []string{"/bin/cat"},
-		},
-		"",
-	); err == nil {
+	job := eng.Job("create")
+	job.Setenv("Image", GetTestImage(runtime).ID)
+	job.Setenv("Memory", "524287")
+	job.Setenv("CpuShares", "1000")
+	job.SetenvList("Cmd", []string{"/bin/cat"})
+	var id string
+	job.StdoutParseString(&id)
+	if err := job.Run(); err == nil {
 		t.Errorf("Memory limit is smaller than the allowed limit. Container creation should've failed!")
 	}
-
 }
 
 func TestContainerTop(t *testing.T) {
@@ -411,10 +399,7 @@ func TestRmi(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	containerID, _, err := srv.ContainerCreate(config, "")
-	if err != nil {
-		t.Fatal(err)
-	}
+	containerID := createTestContainer(eng, config, t)
 
 	//To remove
 	job := eng.Job("start", containerID)
@@ -435,10 +420,7 @@ func TestRmi(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	containerID, _, err = srv.ContainerCreate(config, "")
-	if err != nil {
-		t.Fatal(err)
-	}
+	containerID = createTestContainer(eng, config, t)
 
 	//To remove
 	job = eng.Job("start", containerID)
diff --git a/components/engine/utils_test.go b/components/engine/utils_test.go
index 529af127e5..2e8c0ceb1b 100644
--- a/components/engine/utils_test.go
+++ b/components/engine/utils_test.go
@@ -38,6 +38,22 @@ func mkRuntime(f utils.Fataler) *Runtime {
 	return r
 }
 
+func createNamedTestContainer(eng *engine.Engine, config *Config, f utils.Fataler, name string) (shortId string) {
+	job := eng.Job("create", name)
+	if err := job.ImportEnv(config); err != nil {
+		f.Fatal(err)
+	}
+	job.StdoutParseString(&shortId)
+	if err := job.Run(); err != nil {
+		f.Fatal(err)
+	}
+	return
+}
+
+func createTestContainer(eng *engine.Engine, config *Config, f utils.Fataler) (shortId string) {
+	return createNamedTestContainer(eng, config, f, "")
+}
+
 func mkServerFromEngine(eng *engine.Engine, t utils.Fataler) *Server {
 	iSrv := eng.Hack_GetGlobalVar("httpapi.server")
 	if iSrv == nil {

From e83abd1b633af0240d7add404d88534ba90a5448 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Tue, 5 Nov 2013 22:22:37 +0000
Subject: [PATCH 023/184] Remove debug messages Upstream-commit:
 8d6df3a7e2080d4fad9743beb159f12caa0ff6f7 Component: engine

---
 components/engine/engine/job.go | 13 ++-----------
 components/engine/server.go     |  3 ---
 2 files changed, 2 insertions(+), 14 deletions(-)

diff --git a/components/engine/engine/job.go b/components/engine/engine/job.go
index ece8d8f8d6..419ac73466 100644
--- a/components/engine/engine/job.go
+++ b/components/engine/engine/job.go
@@ -239,17 +239,14 @@ func (job *Job) DecodeEnv(src io.Reader) error {
 		// encoding/json decodes integers to float64, but cannot encode them back.
 		// (See http://golang.org/src/pkg/encoding/json/decode.go#L46)
 		if fval, ok := v.(float64); ok {
-			job.Logf("Converted to float: %v->%v", v, fval)
 			job.SetenvInt(k, int64(fval))
 		} else if sval, ok := v.(string); ok {
-			job.Logf("Converted to string: %v->%v", v, sval)
 			job.Setenv(k, sval)
 		} else	if val, err := json.Marshal(v); err == nil {
 			job.Setenv(k, string(val))
 		} else {
 			job.Setenv(k, fmt.Sprintf("%v", v))
 		}
-		job.Logf("Decoded %s=%#v to %s=%#v", k, v, k, job.Getenv(k))
 	}
 	return nil
 }
@@ -269,7 +266,6 @@ func (job *Job) EncodeEnv(dst io.Writer) error {
 		} else {
 			m[k] = v
 		}
-		job.Logf("Encoded %s=%#v to %s=%#v", k, v, k, m[k])
 	}
 	if err := json.NewEncoder(dst).Encode(&m); err != nil {
 		return err
@@ -278,24 +274,20 @@ func (job *Job) EncodeEnv(dst io.Writer) error {
 }
 
 func (job *Job) ExportEnv(dst interface{}) (err error) {
-	fmt.Fprintf(os.Stderr, "ExportEnv()\n")
 	defer func() {
 		if err != nil {
 			err = fmt.Errorf("ExportEnv %s", err)
 		}
 	}()
 	var buf bytes.Buffer
-	job.Logf("ExportEnv: step 1: encode/marshal the env to an intermediary json representation")
-	fmt.Fprintf(os.Stderr, "Printed ExportEnv step 1\n")
+	// step 1: encode/marshal the env to an intermediary json representation
 	if err := job.EncodeEnv(&buf); err != nil {
 		return err
 	}
-	job.Logf("ExportEnv: step 1 complete: json=|%s|", buf)
-	job.Logf("ExportEnv: step 2: decode/unmarshal the intermediary json into the destination object")
+	// step 2: decode/unmarshal the intermediary json into the destination object
 	if err := json.NewDecoder(&buf).Decode(dst); err != nil {
 		return err
 	}
-	job.Logf("ExportEnv: step 2 complete")
 	return nil
 }
 
@@ -309,7 +301,6 @@ func (job *Job) ImportEnv(src interface{}) (err error) {
 	if err := json.NewEncoder(&buf).Encode(src); err != nil {
 		return err
 	}
-	job.Logf("ImportEnv: json=|%s|", buf)
 	if err := job.DecodeEnv(&buf); err != nil {
 		return err
 	}
diff --git a/components/engine/server.go b/components/engine/server.go
index 6196df8981..abcb001bb0 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -1332,14 +1332,11 @@ func (srv *Server) RegisterLinks(name string, hostConfig *HostConfig) error {
 }
 
 func (srv *Server) ContainerStart(job *engine.Job) string {
-	job.Logf("srv engine = %s", srv.Eng.Root())
-	job.Logf("job engine = %s", job.Eng.Root())
 	if len(job.Args) < 1 {
 		return fmt.Sprintf("Usage: %s container_id", job.Name)
 	}
 	name := job.Args[0]
 	runtime := srv.runtime
-	job.Logf("loading containers from %s", runtime.repository)
 	container := runtime.Get(name)
 	if container == nil {
 		return fmt.Sprintf("No such container: %s", name)

From 2a939ef85fc1938b0963c5a21514c5ae7af9ada3 Mon Sep 17 00:00:00 2001
From: Daniel Norberg <daniel.norberg@gmail.com>
Date: Tue, 5 Nov 2013 18:26:07 -0500
Subject: [PATCH 024/184] lock around read operations in graph

Writes and reads will fail with ErrBusy if there's
concurrent reads or writes, respectively. It is
not sufficient to only lock around writes.
Upstream-commit: 1dc34e2b965253a62d52f84a0f548334d4d6aa9d
Component: engine
---
 components/engine/gograph/gograph.go | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/components/engine/gograph/gograph.go b/components/engine/gograph/gograph.go
index 32b3a491bb..2b25464344 100644
--- a/components/engine/gograph/gograph.go
+++ b/components/engine/gograph/gograph.go
@@ -138,7 +138,14 @@ func (db *Database) Set(fullPath, id string) (*Entity, error) {
 
 // Return true if a name already exists in the database
 func (db *Database) Exists(name string) bool {
-	return db.Get(name) != nil
+	db.mux.Lock()
+	defer db.mux.Unlock()
+
+	e, err := db.get(name)
+	if err != nil {
+		return false
+	}
+	return e != nil
 }
 
 func (db *Database) setEdge(parentPath, name string, e *Entity) error {
@@ -165,6 +172,9 @@ func (db *Database) RootEntity() *Entity {
 
 // Return the entity for a given path
 func (db *Database) Get(name string) *Entity {
+	db.mux.Lock()
+	defer db.mux.Unlock()
+
 	e, err := db.get(name)
 	if err != nil {
 		return nil
@@ -200,6 +210,9 @@ func (db *Database) get(name string) (*Entity, error) {
 // List all entities by from the name
 // The key will be the full path of the entity
 func (db *Database) List(name string, depth int) Entities {
+	db.mux.Lock()
+	defer db.mux.Unlock()
+
 	out := Entities{}
 	e, err := db.get(name)
 	if err != nil {
@@ -212,6 +225,9 @@ func (db *Database) List(name string, depth int) Entities {
 }
 
 func (db *Database) Walk(name string, walkFunc WalkFunc, depth int) error {
+	db.mux.Lock()
+	defer db.mux.Unlock()
+
 	e, err := db.get(name)
 	if err != nil {
 		return err
@@ -226,6 +242,9 @@ func (db *Database) Walk(name string, walkFunc WalkFunc, depth int) error {
 
 // Return the refrence count for a specified id
 func (db *Database) Refs(id string) int {
+	db.mux.Lock()
+	defer db.mux.Unlock()
+
 	var count int
 	if err := db.conn.QueryRow("SELECT COUNT(*) FROM edge WHERE entity_id = ?;", id).Scan(&count); err != nil {
 		return 0
@@ -235,6 +254,9 @@ func (db *Database) Refs(id string) int {
 
 // Return all the id's path references
 func (db *Database) RefPaths(id string) Edges {
+	db.mux.Lock()
+	defer db.mux.Unlock()
+
 	refs := Edges{}
 
 	rows, err := db.conn.Query("SELECT name, parent_id FROM edge WHERE entity_id = ?;", id)

From b581ea208c28d7b2b8766c7d010661d78dd69e76 Mon Sep 17 00:00:00 2001
From: Daniel Norberg <dano@spotify.com>
Date: Tue, 5 Nov 2013 22:07:14 -0500
Subject: [PATCH 025/184] gograph: Use RWMutex to allow concurrent readers
 Upstream-commit: 04aca7c9e3edddc57a1fbc11e57e6c62e6847126 Component: engine

---
 components/engine/gograph/gograph.go | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/components/engine/gograph/gograph.go b/components/engine/gograph/gograph.go
index 2b25464344..626bf53ed8 100644
--- a/components/engine/gograph/gograph.go
+++ b/components/engine/gograph/gograph.go
@@ -48,7 +48,7 @@ type WalkFunc func(fullPath string, entity *Entity) error
 // Graph database for storing entities and their relationships
 type Database struct {
 	conn *sql.DB
-	mux  sync.Mutex
+	mux  sync.RWMutex
 }
 
 // Create a new graph database initialized with a root entity
@@ -138,8 +138,8 @@ func (db *Database) Set(fullPath, id string) (*Entity, error) {
 
 // Return true if a name already exists in the database
 func (db *Database) Exists(name string) bool {
-	db.mux.Lock()
-	defer db.mux.Unlock()
+	db.mux.RLock()
+	defer db.mux.RUnlock()
 
 	e, err := db.get(name)
 	if err != nil {
@@ -172,8 +172,8 @@ func (db *Database) RootEntity() *Entity {
 
 // Return the entity for a given path
 func (db *Database) Get(name string) *Entity {
-	db.mux.Lock()
-	defer db.mux.Unlock()
+	db.mux.RLock()
+	defer db.mux.RUnlock()
 
 	e, err := db.get(name)
 	if err != nil {
@@ -210,8 +210,8 @@ func (db *Database) get(name string) (*Entity, error) {
 // List all entities by from the name
 // The key will be the full path of the entity
 func (db *Database) List(name string, depth int) Entities {
-	db.mux.Lock()
-	defer db.mux.Unlock()
+	db.mux.RLock()
+	defer db.mux.RUnlock()
 
 	out := Entities{}
 	e, err := db.get(name)
@@ -225,8 +225,8 @@ func (db *Database) List(name string, depth int) Entities {
 }
 
 func (db *Database) Walk(name string, walkFunc WalkFunc, depth int) error {
-	db.mux.Lock()
-	defer db.mux.Unlock()
+	db.mux.RLock()
+	defer db.mux.RUnlock()
 
 	e, err := db.get(name)
 	if err != nil {
@@ -242,8 +242,8 @@ func (db *Database) Walk(name string, walkFunc WalkFunc, depth int) error {
 
 // Return the refrence count for a specified id
 func (db *Database) Refs(id string) int {
-	db.mux.Lock()
-	defer db.mux.Unlock()
+	db.mux.RLock()
+	defer db.mux.RUnlock()
 
 	var count int
 	if err := db.conn.QueryRow("SELECT COUNT(*) FROM edge WHERE entity_id = ?;", id).Scan(&count); err != nil {
@@ -254,8 +254,8 @@ func (db *Database) Refs(id string) int {
 
 // Return all the id's path references
 func (db *Database) RefPaths(id string) Edges {
-	db.mux.Lock()
-	defer db.mux.Unlock()
+	db.mux.RLock()
+	defer db.mux.RUnlock()
 
 	refs := Edges{}
 

From 59c6d9849856dca6d8e356668d3f672a3c12632a Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Sun, 6 Oct 2013 05:44:04 +0000
Subject: [PATCH 026/184] rework images JSON Upstream-commit:
 15867ff4308c5c1330a400be56410d404336100f Component: engine

---
 components/engine/api_params.go |  6 ++---
 components/engine/commands.go   | 36 ++++++++++++++++--------------
 components/engine/server.go     | 39 +++++++++++++++++++++++----------
 components/engine/sorter.go     |  2 +-
 4 files changed, 51 insertions(+), 32 deletions(-)

diff --git a/components/engine/api_params.go b/components/engine/api_params.go
index f666ac2393..d796b96542 100644
--- a/components/engine/api_params.go
+++ b/components/engine/api_params.go
@@ -9,12 +9,12 @@ type APIHistory struct {
 }
 
 type APIImages struct {
-	Repository  string `json:",omitempty"`
-	Tag         string `json:",omitempty"`
-	ID          string `json:"Id"`
+	ID          string   `json:"Id"`
+	RepoTags    []string `json:",omitempty"`
 	Created     int64
 	Size        int64
 	VirtualSize int64
+	ParentId    string `json:",omitempty"`
 }
 
 type APIInfo struct {
diff --git a/components/engine/commands.go b/components/engine/commands.go
index d52114553f..7fc3dceb43 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1097,27 +1097,29 @@ func (cli *DockerCli) CmdImages(args ...string) error {
 			fmt.Fprintln(w, "REPOSITORY\tTAG\tID\tCREATED\tSIZE")
 		}
 
+		var repo string
+		var tag string
 		for _, out := range outs {
-			if out.Repository == "" {
-				out.Repository = "<none>"
-			}
-			if out.Tag == "" {
-				out.Tag = "<none>"
-			}
+			for _, repotag := range out.RepoTags {
 
-			if !*noTrunc {
-				out.ID = utils.TruncateID(out.ID)
-			}
+				components := strings.SplitN(repotag, ":", 2)
+				repo = components[0]
+				tag = components[1]
 
-			if !*quiet {
-				fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t", out.Repository, out.Tag, out.ID, utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0))))
-				if out.VirtualSize > 0 {
-					fmt.Fprintf(w, "%s (virtual %s)\n", utils.HumanSize(out.Size), utils.HumanSize(out.VirtualSize))
-				} else {
-					fmt.Fprintf(w, "%s\n", utils.HumanSize(out.Size))
+				if !*noTrunc {
+					out.ID = utils.TruncateID(out.ID)
+				}
+
+				if !*quiet {
+					fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t", repo, tag, out.ID, utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0))))
+					if out.VirtualSize > 0 {
+						fmt.Fprintf(w, "%s (virtual %s)\n", utils.HumanSize(out.Size), utils.HumanSize(out.VirtualSize))
+					} else {
+						fmt.Fprintf(w, "%s\n", utils.HumanSize(out.Size))
+					}
+				} else {
+					fmt.Fprintln(w, out.ID)
 				}
-			} else {
-				fmt.Fprintln(w, out.ID)
 			}
 		}
 
diff --git a/components/engine/server.go b/components/engine/server.go
index cbe7c6435c..2492c88683 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -284,7 +284,7 @@ func (srv *Server) Images(all bool, filter string) ([]APIImages, error) {
 	if err != nil {
 		return nil, err
 	}
-	outs := []APIImages{} //produce [] when empty instead of 'null'
+	lookup := make(map[string]APIImages)
 	for name, repository := range srv.runtime.repositories.Repositories {
 		if filter != "" {
 			if match, _ := path.Match(filter, name); !match {
@@ -292,23 +292,40 @@ func (srv *Server) Images(all bool, filter string) ([]APIImages, error) {
 			}
 		}
 		for tag, id := range repository {
-			var out APIImages
 			image, err := srv.runtime.graph.Get(id)
 			if err != nil {
 				log.Printf("Warning: couldn't load %s from %s/%s: %s", id, name, tag, err)
 				continue
 			}
-			delete(allImages, id)
-			out.Repository = name
-			out.Tag = tag
-			out.ID = image.ID
-			out.Created = image.Created.Unix()
-			out.Size = image.Size
-			out.VirtualSize = image.getParentsSize(0) + image.Size
-			outs = append(outs, out)
+
+			if out, exists := lookup[id]; exists {
+				out.RepoTags = append(out.RepoTags, fmt.Sprintf("%s:%s", name, tag))
+
+				lookup[id] = out
+			} else {
+				var out APIImages
+
+				delete(allImages, id)
+
+				out.ParentId = image.Parent
+				out.RepoTags = []string{fmt.Sprintf("%s:%s", name, tag)}
+				out.ID = image.ID
+				out.Created = image.Created.Unix()
+				out.Size = image.Size
+				out.VirtualSize = image.getParentsSize(0) + image.Size
+
+				lookup[id] = out
+			}
+
 		}
 	}
-	// Display images which aren't part of a
+
+	outs := make([]APIImages, 0, len(lookup))
+	for _, value := range lookup {
+		outs = append(outs, value)
+	}
+
+	// Display images which aren't part of a repository/tag
 	if filter == "" {
 		for _, image := range allImages {
 			var out APIImages
diff --git a/components/engine/sorter.go b/components/engine/sorter.go
index d4331eaf1f..c9a86b45c0 100644
--- a/components/engine/sorter.go
+++ b/components/engine/sorter.go
@@ -25,7 +25,7 @@ func (s *imageSorter) Less(i, j int) bool {
 // Sort []ApiImages by most recent creation date and tag name.
 func sortImagesByCreationAndTag(images []APIImages) {
 	creationAndTag := func(i1, i2 *APIImages) bool {
-		return i1.Created > i2.Created || (i1.Created == i2.Created && i2.Tag > i1.Tag)
+		return i1.Created > i2.Created
 	}
 
 	sorter := &imageSorter{

From b5c0cbf91743269580effe18b5326aeca53b7f3e Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Sun, 6 Oct 2013 05:59:49 +0000
Subject: [PATCH 027/184] bump api version and ensure backward compat
 Upstream-commit: d7928b9a673e9b2aff36fa6961481312455c91f4 Component: engine

---
 components/engine/api.go        | 13 +++++++++++--
 components/engine/api_params.go | 31 +++++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+), 2 deletions(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index 0c06b2e6d1..00673de339 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -23,7 +23,7 @@ import (
 )
 
 const (
-	APIVERSION        = 1.6
+	APIVERSION        = 1.7
 	DEFAULTHTTPHOST   = "127.0.0.1"
 	DEFAULTHTTPPORT   = 4243
 	DEFAULTUNIXSOCKET = "/var/run/docker.sock"
@@ -191,7 +191,16 @@ func getImagesJSON(srv *Server, version float64, w http.ResponseWriter, r *http.
 		return err
 	}
 
-	return writeJSON(w, http.StatusOK, outs)
+	if version < 1.7 {
+		outs2 := []APIImagesOld{}
+		for _, ctnr := range outs {
+			outs2 = append(outs2, ctnr.ToLegacy()...)
+		}
+
+		return writeJSON(w, http.StatusOK, outs2)
+	} else {
+		return writeJSON(w, http.StatusOK, outs)
+	}
 }
 
 func getImagesViz(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
diff --git a/components/engine/api_params.go b/components/engine/api_params.go
index d796b96542..e4508542ef 100644
--- a/components/engine/api_params.go
+++ b/components/engine/api_params.go
@@ -1,5 +1,7 @@
 package docker
 
+import "strings"
+
 type APIHistory struct {
 	ID        string   `json:"Id"`
 	Tags      []string `json:",omitempty"`
@@ -17,6 +19,35 @@ type APIImages struct {
 	ParentId    string `json:",omitempty"`
 }
 
+type APIImagesOld struct {
+	Repository  string `json:",omitempty"`
+	Tag         string `json:",omitempty"`
+	ID          string `json:"Id"`
+	Created     int64
+	Size        int64
+	VirtualSize int64
+}
+
+func (self *APIImages) ToLegacy() []APIImagesOld {
+
+	outs := []APIImagesOld{}
+	for _, repotag := range self.RepoTags {
+
+		components := strings.SplitN(repotag, ":", 2)
+
+		outs = append(outs, APIImagesOld{
+			ID:          self.ID,
+			Repository:  components[0],
+			Tag:         components[1],
+			Created:     self.Created,
+			Size:        self.Size,
+			VirtualSize: self.VirtualSize,
+		})
+	}
+
+	return outs
+}
+
 type APIInfo struct {
 	Debug              bool
 	Containers         int

From 08d9fe490e2649027b08c8c40eb3702490e36bf2 Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Sun, 6 Oct 2013 16:36:38 +0000
Subject: [PATCH 028/184] fix "images -a" Upstream-commit:
 dcf0279a50e7a2eca97b205725df474a516b8f79 Component: engine

---
 components/engine/server.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/engine/server.go b/components/engine/server.go
index 2492c88683..ab8193f4c2 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -330,6 +330,7 @@ func (srv *Server) Images(all bool, filter string) ([]APIImages, error) {
 		for _, image := range allImages {
 			var out APIImages
 			out.ID = image.ID
+			out.RepoTags = []string{"<none>:<none>"}
 			out.Created = image.Created.Unix()
 			out.Size = image.Size
 			out.VirtualSize = image.getParentsSize(0) + image.Size

From cbbaa36a2b49fc7f26abe29e019aacaef48903bb Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Tue, 8 Oct 2013 13:41:44 +0000
Subject: [PATCH 029/184] move "images -viz" to client Upstream-commit:
 2a5998baf172f94a8d6866e46207a0d7d75e70e5 Component: engine

---
 components/engine/api.go      |  8 -------
 components/engine/commands.go | 24 +++++++++++++++++++--
 components/engine/server.go   | 39 +----------------------------------
 3 files changed, 23 insertions(+), 48 deletions(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index 00673de339..095095954e 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -203,13 +203,6 @@ func getImagesJSON(srv *Server, version float64, w http.ResponseWriter, r *http.
 	}
 }
 
-func getImagesViz(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := srv.ImagesViz(w); err != nil {
-		return err
-	}
-	return nil
-}
-
 func getInfo(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
 	return writeJSON(w, http.StatusOK, srv.DockerInfo())
 }
@@ -1046,7 +1039,6 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			"/info":                           getInfo,
 			"/version":                        getVersion,
 			"/images/json":                    getImagesJSON,
-			"/images/viz":                     getImagesViz,
 			"/images/search":                  getImagesSearch,
 			"/images/{name:.*}/history":       getImagesHistory,
 			"/images/{name:.*}/json":          getImagesByName,
diff --git a/components/engine/commands.go b/components/engine/commands.go
index 7fc3dceb43..b3cd7958a4 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1067,11 +1067,31 @@ func (cli *DockerCli) CmdImages(args ...string) error {
 	}
 
 	if *flViz {
-		body, _, err := cli.call("GET", "/images/viz", false)
+		body, _, err := cli.call("GET", "/images/json?all=1", nil)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(cli.out, "%s", body)
+
+		var outs []APIImages
+		err = json.Unmarshal(body, &outs)
+		if err != nil {
+			return err
+		}
+
+		fmt.Fprintf(cli.out, "digraph docker {\n")
+
+		for _, image := range outs {
+			if image.ParentId == "" {
+				fmt.Fprintf(cli.out, " base -> \"%s\" [style=invis]\n", utils.TruncateID(image.ID))
+			} else {
+				fmt.Fprintf(cli.out, " \"%s\" -> \"%s\"\n", utils.TruncateID(image.ParentId), utils.TruncateID(image.ID))
+			}
+			if image.RepoTags[0] != "<none>:<none>" {
+				fmt.Fprintf(cli.out, " \"%s\" [label=\"%s\\n%s\",shape=box,fillcolor=\"paleturquoise\",style=\"filled,rounded\"];\n", utils.TruncateID(image.ID), utils.TruncateID(image.ID), strings.Join(image.RepoTags, "\\n"))
+			}
+		}
+
+		fmt.Fprintf(cli.out, " base [style=invisible]\n}\n")
 	} else {
 		v := url.Values{}
 		if cmd.NArg() == 1 {
diff --git a/components/engine/server.go b/components/engine/server.go
index ab8193f4c2..644a433eeb 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -233,44 +233,6 @@ func (srv *Server) ImageInsert(name, url, path string, out io.Writer, sf *utils.
 	return img.ShortID(), nil
 }
 
-func (srv *Server) ImagesViz(out io.Writer) error {
-	images, _ := srv.runtime.graph.Map()
-	if images == nil {
-		return nil
-	}
-	out.Write([]byte("digraph docker {\n"))
-
-	var (
-		parentImage *Image
-		err         error
-	)
-	for _, image := range images {
-		parentImage, err = image.GetParent()
-		if err != nil {
-			return err
-		}
-		if parentImage != nil {
-			out.Write([]byte(" \"" + parentImage.ShortID() + "\" -> \"" + image.ShortID() + "\"\n"))
-		} else {
-			out.Write([]byte(" base -> \"" + image.ShortID() + "\" [style=invis]\n"))
-		}
-	}
-
-	reporefs := make(map[string][]string)
-
-	for name, repository := range srv.runtime.repositories.Repositories {
-		for tag, id := range repository {
-			reporefs[utils.TruncateID(id)] = append(reporefs[utils.TruncateID(id)], fmt.Sprintf("%s:%s", name, tag))
-		}
-	}
-
-	for id, repos := range reporefs {
-		out.Write([]byte(" \"" + id + "\" [label=\"" + id + "\\n" + strings.Join(repos, "\\n") + "\",shape=box,fillcolor=\"paleturquoise\",style=\"filled,rounded\"];\n"))
-	}
-	out.Write([]byte(" base [style=invisible]\n}\n"))
-	return nil
-}
-
 func (srv *Server) Images(all bool, filter string) ([]APIImages, error) {
 	var (
 		allImages map[string]*Image
@@ -330,6 +292,7 @@ func (srv *Server) Images(all bool, filter string) ([]APIImages, error) {
 		for _, image := range allImages {
 			var out APIImages
 			out.ID = image.ID
+			out.ParentId = image.Parent
 			out.RepoTags = []string{"<none>:<none>"}
 			out.Created = image.Created.Unix()
 			out.Size = image.Size

From 736f474973b1e20b009c82ea26083adfcc3d934d Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Tue, 8 Oct 2013 13:52:36 +0000
Subject: [PATCH 030/184] bring back /images/viz, but 404 for latest
 Upstream-commit: 8f64759881b3d48e42927ed9bdf1c9162d3c8bb3 Component: engine

---
 components/engine/api.go    | 13 +++++++++++++
 components/engine/server.go | 38 +++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+)

diff --git a/components/engine/api.go b/components/engine/api.go
index 095095954e..61252ab9af 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -203,6 +203,18 @@ func getImagesJSON(srv *Server, version float64, w http.ResponseWriter, r *http.
 	}
 }
 
+func getImagesViz(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
+	if version > 1.6 {
+		w.WriteHeader(http.StatusNotFound)
+		return fmt.Errorf("This is now implemented in the client.")
+	}
+
+	if err := srv.ImagesViz(w); err != nil {
+		return err
+	}
+	return nil
+}
+
 func getInfo(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
 	return writeJSON(w, http.StatusOK, srv.DockerInfo())
 }
@@ -1039,6 +1051,7 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			"/info":                           getInfo,
 			"/version":                        getVersion,
 			"/images/json":                    getImagesJSON,
+			"/images/viz":                     getImagesViz,
 			"/images/search":                  getImagesSearch,
 			"/images/{name:.*}/history":       getImagesHistory,
 			"/images/{name:.*}/json":          getImagesByName,
diff --git a/components/engine/server.go b/components/engine/server.go
index 644a433eeb..3441029027 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -233,6 +233,44 @@ func (srv *Server) ImageInsert(name, url, path string, out io.Writer, sf *utils.
 	return img.ShortID(), nil
 }
 
+func (srv *Server) ImagesViz(out io.Writer) error {
+	images, _ := srv.runtime.graph.Map()
+	if images == nil {
+		return nil
+	}
+	out.Write([]byte("digraph docker {\n"))
+
+	var (
+		parentImage *Image
+		err         error
+	)
+	for _, image := range images {
+		parentImage, err = image.GetParent()
+		if err != nil {
+			return fmt.Errorf("Error while getting parent image: %v", err)
+		}
+		if parentImage != nil {
+			out.Write([]byte(" \"" + parentImage.ShortID() + "\" -> \"" + image.ShortID() + "\"\n"))
+		} else {
+			out.Write([]byte(" base -> \"" + image.ShortID() + "\" [style=invis]\n"))
+		}
+	}
+
+	reporefs := make(map[string][]string)
+
+	for name, repository := range srv.runtime.repositories.Repositories {
+		for tag, id := range repository {
+			reporefs[utils.TruncateID(id)] = append(reporefs[utils.TruncateID(id)], fmt.Sprintf("%s:%s", name, tag))
+		}
+	}
+
+	for id, repos := range reporefs {
+		out.Write([]byte(" \"" + id + "\" [label=\"" + id + "\\n" + strings.Join(repos, "\\n") + "\",shape=box,fillcolor=\"paleturquoise\",style=\"filled,rounded\"];\n"))
+	}
+	out.Write([]byte(" base [style=invisible]\n}\n"))
+	return nil
+}
+
 func (srv *Server) Images(all bool, filter string) ([]APIImages, error) {
 	var (
 		allImages map[string]*Image

From 2dbd3407deb26687f4a8719a7862fb7af33e95a2 Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Wed, 9 Oct 2013 14:38:39 +0000
Subject: [PATCH 031/184] implement "images -tree" Upstream-commit:
 ec9a9a08b8b76079207ced5b55a7caade27fb3d3 Component: engine

---
 components/engine/commands.go | 88 +++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index b3cd7958a4..c793b27c08 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1057,6 +1057,7 @@ func (cli *DockerCli) CmdImages(args ...string) error {
 	all := cmd.Bool("a", false, "show all images")
 	noTrunc := cmd.Bool("notrunc", false, "Don't truncate output")
 	flViz := cmd.Bool("viz", false, "output graph in graphviz format")
+	flTree := cmd.Bool("tree", false, "output graph in tree format")
 
 	if err := cmd.Parse(args); err != nil {
 		return nil
@@ -1092,6 +1093,52 @@ func (cli *DockerCli) CmdImages(args ...string) error {
 		}
 
 		fmt.Fprintf(cli.out, " base [style=invisible]\n}\n")
+	} else if *flTree {
+		body, _, err := cli.call("GET", "/images/json?all=1", nil)
+		if err != nil {
+			return err
+		}
+
+		var outs []APIImages
+		err = json.Unmarshal(body, &outs)
+		if err != nil {
+			return err
+		}
+
+		var startImageArg = cmd.Arg(0)
+		var startImage APIImages
+
+		var roots []APIImages
+		var byParent = make(map[string][]APIImages)
+		for _, image := range outs {
+			if image.ParentId == "" {
+				roots = append(roots, image)
+			} else {
+				if children, exists := byParent[image.ParentId]; exists {
+					byParent[image.ParentId] = append(children, image)
+				} else {
+					byParent[image.ParentId] = []APIImages{image}
+				}
+			}
+
+			if startImageArg != "" {
+				if startImageArg == image.ID || startImageArg == utils.TruncateID(image.ID) {
+					startImage = image
+				}
+
+				for _, repotag := range image.RepoTags {
+					if repotag == startImageArg {
+						startImage = image
+					}
+				}
+			}
+		}
+
+		if startImageArg != "" {
+			WalkTree(cli, noTrunc, []APIImages{startImage}, byParent, "")
+		} else {
+			WalkTree(cli, noTrunc, roots, byParent, "")
+		}
 	} else {
 		v := url.Values{}
 		if cmd.NArg() == 1 {
@@ -1150,6 +1197,47 @@ func (cli *DockerCli) CmdImages(args ...string) error {
 	return nil
 }
 
+func WalkTree(cli *DockerCli, noTrunc *bool, images []APIImages, byParent map[string][]APIImages, prefix string) {
+	if len(images) > 1 {
+		length := len(images)
+		for index, image := range images {
+			if index+1 == length {
+				PrintTreeNode(cli, noTrunc, image, prefix+"└─")
+				if subimages, exists := byParent[image.ID]; exists {
+					WalkTree(cli, noTrunc, subimages, byParent, prefix+"  ")
+				}
+			} else {
+				PrintTreeNode(cli, noTrunc, image, prefix+"|─")
+				if subimages, exists := byParent[image.ID]; exists {
+					WalkTree(cli, noTrunc, subimages, byParent, prefix+"| ")
+				}
+			}
+		}
+	} else {
+		for _, image := range images {
+			PrintTreeNode(cli, noTrunc, image, prefix+"└─")
+			if subimages, exists := byParent[image.ID]; exists {
+				WalkTree(cli, noTrunc, subimages, byParent, prefix+"  ")
+			}
+		}
+	}
+}
+
+func PrintTreeNode(cli *DockerCli, noTrunc *bool, image APIImages, prefix string) {
+	var imageID string
+	if *noTrunc {
+		imageID = image.ID
+	} else {
+		imageID = utils.TruncateID(image.ID)
+	}
+
+	if image.RepoTags[0] != "<none>:<none>" {
+		fmt.Fprintf(cli.out, "%s%s Tags: %s\n", prefix, imageID, strings.Join(image.RepoTags, ","))
+	} else {
+		fmt.Fprintf(cli.out, "%s%s\n", prefix, imageID)
+	}
+}
+
 func displayablePorts(ports []APIPort) string {
 	result := []string{}
 	for _, port := range ports {

From f53ad091dd3386b2892109267b1e5c131e853487 Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Sun, 13 Oct 2013 13:42:01 +0000
Subject: [PATCH 032/184] make existing tests pass Upstream-commit:
 059bb7a262a7620d8c7c5fdd064af352ae242f65 Component: engine

---
 components/engine/api_test.go    | 31 +++----------------------------
 components/engine/server_test.go | 18 +++++++++---------
 components/engine/sorter_test.go | 32 +++++++++++++++++++++++++-------
 3 files changed, 37 insertions(+), 44 deletions(-)

diff --git a/components/engine/api_test.go b/components/engine/api_test.go
index fcca8ce83f..0027362009 100644
--- a/components/engine/api_test.go
+++ b/components/engine/api_test.go
@@ -184,7 +184,7 @@ func TestGetImagesJSON(t *testing.T) {
 
 	found := false
 	for _, img := range images {
-		if img.Repository == unitTestImageName {
+		if strings.Contains(img.RepoTags[0], unitTestImageName) {
 			found = true
 			break
 		}
@@ -275,31 +275,6 @@ func TestGetImagesJSON(t *testing.T) {
 	}
 }
 
-func TestGetImagesViz(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &Server{runtime: runtime}
-
-	r := httptest.NewRecorder()
-	if err := getImagesViz(srv, APIVERSION, r, nil, nil); err != nil {
-		t.Fatal(err)
-	}
-
-	if r.Code != http.StatusOK {
-		t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code)
-	}
-
-	reader := bufio.NewReader(r.Body)
-	line, err := reader.ReadString('\n')
-	if err != nil {
-		t.Fatal(err)
-	}
-	if line != "digraph docker {\n" {
-		t.Errorf("Expected digraph docker {\n, %s found", line)
-	}
-}
-
 func TestGetImagesHistory(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
@@ -1226,7 +1201,7 @@ func TestDeleteImages(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(images) != len(initialImages)+1 {
+	if len(images[0].RepoTags) != len(initialImages[0].RepoTags)+1 {
 		t.Errorf("Expected %d images, %d found", len(initialImages)+1, len(images))
 	}
 
@@ -1265,7 +1240,7 @@ func TestDeleteImages(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(images) != len(initialImages) {
+	if len(images[0].RepoTags) != len(initialImages[0].RepoTags) {
 		t.Errorf("Expected %d image, %d found", len(initialImages), len(images))
 	}
 
diff --git a/components/engine/server_test.go b/components/engine/server_test.go
index 7f9cbaadfd..4072344f35 100644
--- a/components/engine/server_test.go
+++ b/components/engine/server_test.go
@@ -34,8 +34,8 @@ func TestContainerTagImageDelete(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(images) != len(initialImages)+3 {
-		t.Errorf("Expected %d images, %d found", len(initialImages)+2, len(images))
+	if len(images[0].RepoTags) != len(initialImages[0].RepoTags)+3 {
+		t.Errorf("Expected %d images, %d found", len(initialImages)+3, len(images))
 	}
 
 	if _, err := srv.ImageDelete("utest/docker:tag2", true); err != nil {
@@ -47,7 +47,7 @@ func TestContainerTagImageDelete(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(images) != len(initialImages)+2 {
+	if len(images[0].RepoTags) != len(initialImages[0].RepoTags)+2 {
 		t.Errorf("Expected %d images, %d found", len(initialImages)+2, len(images))
 	}
 
@@ -60,7 +60,7 @@ func TestContainerTagImageDelete(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(images) != len(initialImages)+1 {
+	if len(images[0].RepoTags) != len(initialImages[0].RepoTags)+1 {
 		t.Errorf("Expected %d images, %d found", len(initialImages)+1, len(images))
 	}
 
@@ -462,7 +462,7 @@ func TestRmi(t *testing.T) {
 		if strings.Contains(unitTestImageID, image.ID) {
 			continue
 		}
-		if image.Repository == "" {
+		if image.RepoTags[0] == "<none>:<none>" {
 			t.Fatalf("Expected tagged image, got untagged one.")
 		}
 	}
@@ -490,7 +490,7 @@ func TestImagesFilter(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(images) != 2 {
+	if len(images[0].RepoTags) != 2 {
 		t.Fatal("incorrect number of matches returned")
 	}
 
@@ -499,7 +499,7 @@ func TestImagesFilter(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(images) != 1 {
+	if len(images[0].RepoTags) != 1 {
 		t.Fatal("incorrect number of matches returned")
 	}
 
@@ -508,7 +508,7 @@ func TestImagesFilter(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(images) != 1 {
+	if len(images[0].RepoTags) != 1 {
 		t.Fatal("incorrect number of matches returned")
 	}
 
@@ -517,7 +517,7 @@ func TestImagesFilter(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(images) != 1 {
+	if len(images[0].RepoTags) != 1 {
 		t.Fatal("incorrect number of matches returned")
 	}
 }
diff --git a/components/engine/sorter_test.go b/components/engine/sorter_test.go
index d61b1a7112..54f647132f 100644
--- a/components/engine/sorter_test.go
+++ b/components/engine/sorter_test.go
@@ -3,6 +3,7 @@ package docker
 import (
 	"fmt"
 	"testing"
+	"time"
 )
 
 func TestServerListOrderedImagesByCreationDate(t *testing.T) {
@@ -34,29 +35,46 @@ func TestServerListOrderedImagesByCreationDateAndTag(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	archive, err := fakeTar()
+	err := generateImage("bar", runtime)
 	if err != nil {
 		t.Fatal(err)
 	}
-	image, err := runtime.graph.Create(archive, nil, "Testing", "", nil)
+
+	time.Sleep(time.Second)
+
+	err = generateImage("zed", runtime)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	srv := &Server{runtime: runtime}
-	srv.ContainerTag(image.ID, "repo", "foo", false)
-	srv.ContainerTag(image.ID, "repo", "bar", false)
-
 	images, err := srv.Images(true, "")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if images[0].Created != images[1].Created || images[0].Tag >= images[1].Tag {
-		t.Error("Expected []APIImges to be ordered by most recent creation date and tag name.")
+	if images[0].RepoTags[0] != "repo:zed" && images[0].RepoTags[0] != "repo:bar" {
+		t.Errorf("Expected []APIImges to be ordered by most recent creation date. %s", images)
 	}
 }
 
+func generateImage(name string, runtime *Runtime) error {
+
+	archive, err := fakeTar()
+	if err != nil {
+		return err
+	}
+	image, err := runtime.graph.Create(archive, nil, "Testing", "", nil)
+	if err != nil {
+		return err
+	}
+
+	srv := &Server{runtime: runtime}
+	srv.ContainerTag(image.ID, "repo", name, false)
+
+	return nil
+}
+
 func TestSortUniquePorts(t *testing.T) {
 	ports := []Port{
 		Port("6379/tcp"),

From 7820a4a479c52553a3db625dedc9e4e79a7bc6bb Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Sun, 13 Oct 2013 22:36:05 +0000
Subject: [PATCH 033/184] adding test for "images -viz" Upstream-commit:
 d9fe0647cb464ccd6f79ac33fb1d1ac56441f6b0 Component: engine

---
 components/engine/commands_test.go | 48 ++++++++++++++++++++++++++++++
 components/engine/runtime_test.go  |  1 +
 2 files changed, 49 insertions(+)

diff --git a/components/engine/commands_test.go b/components/engine/commands_test.go
index 1ec005bdd1..28a19d2af8 100644
--- a/components/engine/commands_test.go
+++ b/components/engine/commands_test.go
@@ -6,6 +6,7 @@ import (
 	"github.com/dotcloud/docker/utils"
 	"io"
 	"io/ioutil"
+	"regexp"
 	"strings"
 	"testing"
 	"time"
@@ -699,3 +700,50 @@ func TestRunErrorBindNonExistingSource(t *testing.T) {
 		<-c
 	})
 }
+
+func TestImagesViz(t *testing.T) {
+	stdout, stdoutPipe := io.Pipe()
+
+	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)
+
+	c := make(chan struct{})
+	go func() {
+		defer close(c)
+		if err := cli.CmdImages("-viz"); err != nil {
+			t.Fatal(err)
+		}
+		stdoutPipe.Close()
+	}()
+
+	setTimeout(t, "Reading command output time out", 2*time.Second, func() {
+		cmdOutputBytes, err := ioutil.ReadAll(bufio.NewReader(stdout))
+		if err != nil {
+			t.Fatal(err)
+		}
+		cmdOutput := string(cmdOutputBytes)
+
+		regexpStrings := []string{
+			"digraph docker {",
+			fmt.Sprintf("base -> \"%s\" \\[style=invis]", unitTestImageIDShort),
+			fmt.Sprintf("label=\"%s\\\\n%s:latest\"", unitTestImageIDShort, unitTestImageName),
+			"base \\[style=invisible]",
+		}
+
+		compiledRegexps := []*regexp.Regexp{}
+		for _, regexpString := range regexpStrings {
+			regexp, err := regexp.Compile(regexpString)
+			if err != nil {
+				fmt.Println("Error in regex string: ", err)
+				return
+			}
+			compiledRegexps = append(compiledRegexps, regexp)
+		}
+
+		for _, regexp := range compiledRegexps {
+			if !regexp.MatchString(cmdOutput) {
+				t.Fatalf("images -viz content '%s' did not match regexp '%s'", cmdOutput, regexp)
+			}
+		}
+	})
+}
diff --git a/components/engine/runtime_test.go b/components/engine/runtime_test.go
index 4e46b7b6d0..e61f63d495 100644
--- a/components/engine/runtime_test.go
+++ b/components/engine/runtime_test.go
@@ -22,6 +22,7 @@ import (
 const (
 	unitTestImageName     = "docker-test-image"
 	unitTestImageID       = "83599e29c455eb719f77d799bc7c51521b9551972f5a850d7ad265bc1b5292f6" // 1.0
+	unitTestImageIDShort  = "83599e29c455"
 	unitTestNetworkBridge = "testdockbr0"
 	unitTestStoreBase     = "/var/lib/docker/unit-tests"
 	testDaemonAddr        = "127.0.0.1:4270"

From 377a3eb7ca6d4593635f3ef1fcde0c1038a6b4ea Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Sun, 27 Oct 2013 23:13:00 +0000
Subject: [PATCH 034/184] adding test for "images -tree" Upstream-commit:
 f1aeac361aadc90a35e1b839933afbf9ad27a1a1 Component: engine

---
 components/engine/commands_test.go | 78 ++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)

diff --git a/components/engine/commands_test.go b/components/engine/commands_test.go
index 28a19d2af8..bed9557bb1 100644
--- a/components/engine/commands_test.go
+++ b/components/engine/commands_test.go
@@ -707,6 +707,9 @@ func TestImagesViz(t *testing.T) {
 	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
 	defer cleanup(globalRuntime)
 
+	srv := &Server{runtime: globalRuntime}
+	image := buildTestImages(t, srv)
+
 	c := make(chan struct{})
 	go func() {
 		defer close(c)
@@ -727,6 +730,7 @@ func TestImagesViz(t *testing.T) {
 			"digraph docker {",
 			fmt.Sprintf("base -> \"%s\" \\[style=invis]", unitTestImageIDShort),
 			fmt.Sprintf("label=\"%s\\\\n%s:latest\"", unitTestImageIDShort, unitTestImageName),
+			fmt.Sprintf("label=\"%s\\\\n%s:%s\"", utils.TruncateID(image.ID), "test", "latest"),
 			"base \\[style=invisible]",
 		}
 
@@ -747,3 +751,77 @@ func TestImagesViz(t *testing.T) {
 		}
 	})
 }
+
+func TestImagesTree(t *testing.T) {
+	stdout, stdoutPipe := io.Pipe()
+
+	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)
+
+	srv := &Server{runtime: globalRuntime}
+	image := buildTestImages(t, srv)
+
+	c := make(chan struct{})
+	go func() {
+		defer close(c)
+		if err := cli.CmdImages("-tree"); err != nil {
+			t.Fatal(err)
+		}
+		stdoutPipe.Close()
+	}()
+
+	setTimeout(t, "Reading command output time out", 2*time.Second, func() {
+		cmdOutputBytes, err := ioutil.ReadAll(bufio.NewReader(stdout))
+		if err != nil {
+			t.Fatal(err)
+		}
+		cmdOutput := string(cmdOutputBytes)
+
+		regexpStrings := []string{
+			fmt.Sprintf("└─%s Tags: %s:latest", unitTestImageIDShort, unitTestImageName),
+			"(?m)^  └─[0-9a-f]+",
+			"(?m)^    └─[0-9a-f]+",
+			"(?m)^      └─[0-9a-f]+",
+			fmt.Sprintf("        └─%s Tags: test:latest", utils.TruncateID(image.ID)),
+		}
+
+		compiledRegexps := []*regexp.Regexp{}
+		for _, regexpString := range regexpStrings {
+			regexp, err := regexp.Compile(regexpString)
+			if err != nil {
+				fmt.Println("Error in regex string: ", err)
+				return
+			}
+			compiledRegexps = append(compiledRegexps, regexp)
+		}
+
+		for _, regexp := range compiledRegexps {
+			if !regexp.MatchString(cmdOutput) {
+				t.Fatalf("images -tree content '%s' did not match regexp '%s'", cmdOutput, regexp)
+			}
+		}
+	})
+}
+
+func buildTestImages(t *testing.T, srv *Server) *Image {
+
+	var testBuilder = testContextTemplate{
+		`
+from   {IMAGE}
+run    sh -c 'echo root:testpass > /tmp/passwd'
+run    mkdir -p /var/run/sshd
+run    [ "$(cat /tmp/passwd)" = "root:testpass" ]
+run    [ "$(ls -d /var/run/sshd)" = "/var/run/sshd" ]
+`,
+		nil,
+		nil,
+	}
+	image := buildImage(testBuilder, t, srv, true)
+
+	err := srv.ContainerTag(image.ID, "test", "latest", false)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return image
+}

From e9a1f4f7fff99b9858482221f5f64caabc5d0837 Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Sun, 27 Oct 2013 23:42:09 +0000
Subject: [PATCH 035/184] add image size to -tree Upstream-commit:
 b7d1d35c278c57ad4732dc23e529cf771158ee96 Component: engine

---
 components/engine/commands.go      | 5 +++--
 components/engine/commands_test.go | 4 ++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index c793b27c08..8cb51d4195 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1231,10 +1231,11 @@ func PrintTreeNode(cli *DockerCli, noTrunc *bool, image APIImages, prefix string
 		imageID = utils.TruncateID(image.ID)
 	}
 
+	fmt.Fprintf(cli.out, "%s%s Size: %s (virtual %s)", prefix, imageID, utils.HumanSize(image.Size), utils.HumanSize(image.VirtualSize))
 	if image.RepoTags[0] != "<none>:<none>" {
-		fmt.Fprintf(cli.out, "%s%s Tags: %s\n", prefix, imageID, strings.Join(image.RepoTags, ","))
+		fmt.Fprintf(cli.out, " Tags: %s\n", strings.Join(image.RepoTags, ","))
 	} else {
-		fmt.Fprintf(cli.out, "%s%s\n", prefix, imageID)
+		fmt.Fprint(cli.out, "\n")
 	}
 }
 
diff --git a/components/engine/commands_test.go b/components/engine/commands_test.go
index bed9557bb1..479e295dd8 100644
--- a/components/engine/commands_test.go
+++ b/components/engine/commands_test.go
@@ -778,11 +778,11 @@ func TestImagesTree(t *testing.T) {
 		cmdOutput := string(cmdOutputBytes)
 
 		regexpStrings := []string{
-			fmt.Sprintf("└─%s Tags: %s:latest", unitTestImageIDShort, unitTestImageName),
+			fmt.Sprintf("└─%s Size: (\\d+.\\d+ MB) \\(virtual \\d+.\\d+ MB\\) Tags: %s:latest", unitTestImageIDShort, unitTestImageName),
 			"(?m)^  └─[0-9a-f]+",
 			"(?m)^    └─[0-9a-f]+",
 			"(?m)^      └─[0-9a-f]+",
-			fmt.Sprintf("        └─%s Tags: test:latest", utils.TruncateID(image.ID)),
+			fmt.Sprintf("        └─%s Size: \\d+.\\d+ kB \\(virtual \\d+.\\d+ MB\\) Tags: test:latest", utils.TruncateID(image.ID)),
 		}
 
 		compiledRegexps := []*regexp.Regexp{}

From 2e403649d0b704d4c6bb40b7ed71567521ce9126 Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Mon, 28 Oct 2013 04:02:24 +0000
Subject: [PATCH 036/184] update "images" documentation Upstream-commit:
 6d5b73c2a6d668b11d6b5c643a45170265bf73c0 Component: engine

---
 .../docs/sources/api/docker_remote_api.rst    |  108 +-
 .../sources/api/docker_remote_api_v1.7.rst    | 1187 +++++++++++++++++
 .../engine/docs/sources/commandline/cli.rst   |   30 +
 3 files changed, 1323 insertions(+), 2 deletions(-)
 create mode 100644 components/engine/docs/sources/api/docker_remote_api_v1.7.rst

diff --git a/components/engine/docs/sources/api/docker_remote_api.rst b/components/engine/docs/sources/api/docker_remote_api.rst
index 86cacd17d9..d5cb1a44a9 100644
--- a/components/engine/docs/sources/api/docker_remote_api.rst
+++ b/components/engine/docs/sources/api/docker_remote_api.rst
@@ -26,14 +26,118 @@ Docker Remote API
 2. Versions
 ===========
 
-The current version of the API is 1.6
+The current version of the API is 1.7
 
 Calling /images/<name>/insert is the same as calling
-/v1.6/images/<name>/insert
+/v1.7/images/<name>/insert
 
 You can still call an old version of the api using
 /v1.0/images/<name>/insert
 
+v1.7
+****
+
+Full Documentation
+------------------
+
+:doc:`docker_remote_api_v1.7`
+
+What's new
+----------
+
+.. http:get:: /images/json
+
+   The format of the json returned from this uri changed.  Instead of an entry
+   for each repo/tag on an image, each image is only represented once, with a
+   nested attribute indicating the repo/tags that apply to that image.
+
+   Instead of:
+
+   .. sourcecode:: http
+
+      HTTP/1.1 200 OK
+      Content-Type: application/json
+
+      [
+        {
+          "VirtualSize": 131506275,
+          "Size": 131506275,
+          "Created": 1365714795,
+          "Id": "8dbd9e392a964056420e5d58ca5cc376ef18e2de93b5cc90e868a1bbc8318c1c",
+          "Tag": "12.04",
+          "Repository": "ubuntu"
+        },
+        {
+          "VirtualSize": 131506275,
+          "Size": 131506275,
+          "Created": 1365714795,
+          "Id": "8dbd9e392a964056420e5d58ca5cc376ef18e2de93b5cc90e868a1bbc8318c1c",
+          "Tag": "latest",
+          "Repository": "ubuntu"
+        },
+        {
+          "VirtualSize": 131506275,
+          "Size": 131506275,
+          "Created": 1365714795,
+          "Id": "8dbd9e392a964056420e5d58ca5cc376ef18e2de93b5cc90e868a1bbc8318c1c",
+          "Tag": "precise",
+          "Repository": "ubuntu"
+        },
+        {
+          "VirtualSize": 180116135,
+          "Size": 24653,
+          "Created": 1364102658,
+          "Id": "b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc",
+          "Tag": "12.10",
+          "Repository": "ubuntu"
+        },
+        {
+          "VirtualSize": 180116135,
+          "Size": 24653,
+          "Created": 1364102658,
+          "Id": "b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc",
+          "Tag": "quantal",
+          "Repository": "ubuntu"
+        }
+      ]
+
+   The returned json looks like this:
+
+   .. sourcecode:: http
+
+      HTTP/1.1 200 OK
+      Content-Type: application/json
+      
+      [
+        {
+           "RepoTag": [
+             "ubuntu:12.04",
+             "ubuntu:precise",
+             "ubuntu:latest"
+           ],
+           "Id": "8dbd9e392a964056420e5d58ca5cc376ef18e2de93b5cc90e868a1bbc8318c1c",
+           "Created": 1365714795,
+           "Size": 131506275,
+           "VirtualSize": 131506275
+        },
+        {
+           "RepoTag": [
+             "ubuntu:12.10",
+             "ubuntu:quantal"
+           ],
+           "ParentId": "27cf784147099545",
+           "Id": "b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc",
+           "Created": 1364102658,
+           "Size": 24653,
+           "VirtualSize": 180116135
+        }
+      ]
+
+.. http:get:: /images/viz
+
+   This URI no longer exists.  The ``images -viz`` output is now generated in
+   the client, using the ``/images/json`` data.
+
 v1.6
 ****
 
diff --git a/components/engine/docs/sources/api/docker_remote_api_v1.7.rst b/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
new file mode 100644
index 0000000000..d1b094c872
--- /dev/null
+++ b/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
@@ -0,0 +1,1187 @@
+:title: Remote API v1.7
+:description: API Documentation for Docker
+:keywords: API, Docker, rcli, REST, documentation
+
+:orphan:
+
+======================
+Docker Remote API v1.7
+======================
+
+.. contents:: Table of Contents
+
+1. Brief introduction
+=====================
+
+- The Remote API is replacing rcli
+- Default port in the docker daemon is 4243
+- The API tends to be REST, but for some complex commands, like attach or pull, the HTTP connection is hijacked to transport stdout stdin and stderr
+
+2. Endpoints
+============
+
+2.1 Containers
+--------------
+
+List containers
+***************
+
+.. http:get:: /containers/json
+
+	List containers
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   GET /containers/json?all=1&before=8dfafdbc3a40&size=1 HTTP/1.1
+	   
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/json
+	   
+	   [
+		{
+			"Id": "8dfafdbc3a40",
+			"Image": "base:latest",
+			"Command": "echo 1",
+			"Created": 1367854155,
+			"Status": "Exit 0",
+			"Ports":[{"PrivatePort": 2222, "PublicPort": 3333, "Type": "tcp"}],
+			"SizeRw":12288,
+			"SizeRootFs":0
+		},
+		{
+			"Id": "9cd87474be90",
+			"Image": "base:latest",
+			"Command": "echo 222222",
+			"Created": 1367854155,
+			"Status": "Exit 0",
+			"Ports":[],
+			"SizeRw":12288,
+			"SizeRootFs":0
+		},
+		{
+			"Id": "3176a2479c92",
+			"Image": "base:latest",
+			"Command": "echo 3333333333333333",
+			"Created": 1367854154,
+			"Status": "Exit 0",
+			"Ports":[],
+			"SizeRw":12288,
+			"SizeRootFs":0
+		},
+		{
+			"Id": "4cb07b47f9fb",
+			"Image": "base:latest",
+			"Command": "echo 444444444444444444444444444444444",
+			"Created": 1367854152,
+			"Status": "Exit 0",
+			"Ports":[],
+			"SizeRw":12288,
+			"SizeRootFs":0
+		}
+	   ]
+ 
+	:query all: 1/True/true or 0/False/false, Show all containers. Only running containers are shown by default
+	:query limit: Show ``limit`` last created containers, include non-running ones.
+	:query since: Show only containers created since Id, include non-running ones.
+	:query before: Show only containers created before Id, include non-running ones.
+	:query size: 1/True/true or 0/False/false, Show the containers sizes
+	:statuscode 200: no error
+	:statuscode 400: bad parameter
+	:statuscode 500: server error
+
+
+Create a container
+******************
+
+.. http:post:: /containers/create
+
+	Create a container
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   POST /containers/create HTTP/1.1
+	   Content-Type: application/json
+
+	   {
+		"Hostname":"",
+		"User":"",
+		"Memory":0,
+		"MemorySwap":0,
+		"AttachStdin":false,
+		"AttachStdout":true,
+		"AttachStderr":true,
+		"PortSpecs":null,
+		"Privileged": false,
+		"Tty":false,
+		"OpenStdin":false,
+		"StdinOnce":false,
+		"Env":null,
+		"Cmd":[
+			"date"
+		],
+		"Dns":null,
+		"Image":"base",
+		"Volumes":{},
+		"VolumesFrom":"",
+		"WorkingDir":""
+
+	   }
+	   
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 201 OK
+	   Content-Type: application/json
+
+	   {
+		"Id":"e90e34656806"
+		"Warnings":[]
+	   }
+	
+	:jsonparam config: the container's configuration
+	:statuscode 201: no error
+	:statuscode 404: no such container
+	:statuscode 406: impossible to attach (container not running)
+	:statuscode 500: server error
+
+
+Inspect a container
+*******************
+
+.. http:get:: /containers/(id)/json
+
+	Return low-level information on the container ``id``
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   GET /containers/4fa6e0f0c678/json HTTP/1.1
+	   
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/json
+
+	   {
+			"Id": "4fa6e0f0c6786287e131c3852c58a2e01cc697a68231826813597e4994f1d6e2",
+			"Created": "2013-05-07T14:51:42.041847+02:00",
+			"Path": "date",
+			"Args": [],
+			"Config": {
+				"Hostname": "4fa6e0f0c678",
+				"User": "",
+				"Memory": 0,
+				"MemorySwap": 0,
+				"AttachStdin": false,
+				"AttachStdout": true,
+				"AttachStderr": true,
+				"PortSpecs": null,
+				"Tty": false,
+				"OpenStdin": false,
+				"StdinOnce": false,
+				"Env": null,
+				"Cmd": [
+					"date"
+				],
+				"Dns": null,
+				"Image": "base",
+				"Volumes": {},
+				"VolumesFrom": "",
+				"WorkingDir":""
+
+			},
+			"State": {
+				"Running": false,
+				"Pid": 0,
+				"ExitCode": 0,
+				"StartedAt": "2013-05-07T14:51:42.087658+02:01360",
+				"Ghost": false
+			},
+			"Image": "b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc",
+			"NetworkSettings": {
+				"IpAddress": "",
+				"IpPrefixLen": 0,
+				"Gateway": "",
+				"Bridge": "",
+				"PortMapping": null
+			},
+			"SysInitPath": "/home/kitty/go/src/github.com/dotcloud/docker/bin/docker",
+			"ResolvConfPath": "/etc/resolv.conf",
+			"Volumes": {}
+	   }
+
+	:statuscode 200: no error
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+
+List processes running inside a container
+*****************************************
+
+.. http:get:: /containers/(id)/top
+
+	List processes running inside the container ``id``
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   GET /containers/4fa6e0f0c678/top HTTP/1.1
+
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/json
+
+	   {
+		"Titles":[
+			"USER",
+			"PID",
+			"%CPU",
+			"%MEM",
+			"VSZ",
+			"RSS",
+			"TTY",
+			"STAT",
+			"START",
+			"TIME",
+			"COMMAND"
+			],
+		"Processes":[
+			["root","20147","0.0","0.1","18060","1864","pts/4","S","10:06","0:00","bash"],
+			["root","20271","0.0","0.0","4312","352","pts/4","S+","10:07","0:00","sleep","10"]
+		]
+	   }
+
+	:query ps_args: ps arguments to use (eg. aux)
+	:statuscode 200: no error
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+
+Inspect changes on a container's filesystem
+*******************************************
+
+.. http:get:: /containers/(id)/changes
+
+	Inspect changes on container ``id`` 's filesystem
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   GET /containers/4fa6e0f0c678/changes HTTP/1.1
+
+	   
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/json
+	   
+	   [
+		{
+			"Path":"/dev",
+			"Kind":0
+		},
+		{
+			"Path":"/dev/kmsg",
+			"Kind":1
+		},
+		{
+			"Path":"/test",
+			"Kind":1
+		}
+	   ]
+
+	:statuscode 200: no error
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+
+Export a container
+******************
+
+.. http:get:: /containers/(id)/export
+
+	Export the contents of container ``id``
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   GET /containers/4fa6e0f0c678/export HTTP/1.1
+
+	   
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/octet-stream
+	   
+	   {{ STREAM }}
+
+	:statuscode 200: no error
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+
+Start a container
+*****************
+
+.. http:post:: /containers/(id)/start
+
+        Start the container ``id``
+
+        **Example request**:
+
+        .. sourcecode:: http
+
+           POST /containers/(id)/start HTTP/1.1
+           Content-Type: application/json
+
+           {
+                "Binds":["/tmp:/tmp"],
+                "LxcConf":{"lxc.utsname":"docker"}
+           }
+
+        **Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 204 No Content
+           Content-Type: text/plain
+
+        :jsonparam hostConfig: the container's host configuration (optional)
+        :statuscode 204: no error
+        :statuscode 404: no such container
+        :statuscode 500: server error
+
+
+Stop a container
+****************
+
+.. http:post:: /containers/(id)/stop
+
+	Stop the container ``id``
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   POST /containers/e90e34656806/stop?t=5 HTTP/1.1
+	   
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 204 OK
+	   	
+	:query t: number of seconds to wait before killing the container
+	:statuscode 204: no error
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+
+Restart a container
+*******************
+
+.. http:post:: /containers/(id)/restart
+
+	Restart the container ``id``
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   POST /containers/e90e34656806/restart?t=5 HTTP/1.1
+	   
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 204 OK
+	   	
+	:query t: number of seconds to wait before killing the container
+	:statuscode 204: no error
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+
+Kill a container
+****************
+
+.. http:post:: /containers/(id)/kill
+
+	Kill the container ``id``
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   POST /containers/e90e34656806/kill HTTP/1.1
+	   
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 204 OK
+	   	
+	:statuscode 204: no error
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+
+Attach to a container
+*********************
+
+.. http:post:: /containers/(id)/attach
+
+	Attach to the container ``id``
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   POST /containers/16253994b7c4/attach?logs=1&stream=0&stdout=1 HTTP/1.1
+	   
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/vnd.docker.raw-stream
+
+	   {{ STREAM }}
+	   	
+	:query logs: 1/True/true or 0/False/false, return logs. Default false
+	:query stream: 1/True/true or 0/False/false, return stream. Default false
+	:query stdin: 1/True/true or 0/False/false, if stream=true, attach to stdin. Default false
+	:query stdout: 1/True/true or 0/False/false, if logs=true, return stdout log, if stream=true, attach to stdout. Default false
+	:query stderr: 1/True/true or 0/False/false, if logs=true, return stderr log, if stream=true, attach to stderr. Default false
+	:statuscode 200: no error
+	:statuscode 400: bad parameter
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+	**Stream details**:
+
+	When using the TTY setting is enabled in
+	:http:post:`/containers/create`, the stream is the raw data
+	from the process PTY and client's stdin.  When the TTY is
+	disabled, then the stream is multiplexed to separate stdout
+	and stderr.
+
+	The format is a **Header** and a **Payload** (frame).
+
+	**HEADER**
+
+	The header will contain the information on which stream write
+	the stream (stdout or stderr). It also contain the size of
+	the associated frame encoded on the last 4 bytes (uint32).
+
+	It is encoded on the first 8 bytes like this::
+
+	    header := [8]byte{STREAM_TYPE, 0, 0, 0, SIZE1, SIZE2, SIZE3, SIZE4}
+
+	``STREAM_TYPE`` can be:
+
+	- 0: stdin (will be writen on stdout)
+	- 1: stdout
+	- 2: stderr
+
+	``SIZE1, SIZE2, SIZE3, SIZE4`` are the 4 bytes of the uint32 size encoded as big endian.
+
+	**PAYLOAD**
+
+	The payload is the raw stream.
+
+	**IMPLEMENTATION**
+
+	The simplest way to implement the Attach protocol is the following:
+
+	1) Read 8 bytes
+	2) chose stdout or stderr depending on the first byte
+	3) Extract the frame size from the last 4 byets
+	4) Read the extracted size and output it on the correct output
+	5) Goto 1)
+
+
+
+Wait a container
+****************
+
+.. http:post:: /containers/(id)/wait
+
+	Block until container ``id`` stops, then returns the exit code
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   POST /containers/16253994b7c4/wait HTTP/1.1
+	   
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/json
+
+	   {"StatusCode":0}
+	   	
+	:statuscode 200: no error
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+
+Remove a container
+*******************
+
+.. http:delete:: /containers/(id)
+
+	Remove the container ``id`` from the filesystem
+
+	**Example request**:
+
+        .. sourcecode:: http
+
+           DELETE /containers/16253994b7c4?v=1 HTTP/1.1
+
+        **Example response**:
+
+        .. sourcecode:: http
+
+	   HTTP/1.1 204 OK
+
+	:query v: 1/True/true or 0/False/false, Remove the volumes associated to the container. Default false
+        :statuscode 204: no error
+	:statuscode 400: bad parameter
+        :statuscode 404: no such container
+        :statuscode 500: server error
+
+
+Copy files or folders from a container
+**************************************
+
+.. http:post:: /containers/(id)/copy
+
+	Copy files or folders of container ``id``
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   POST /containers/4fa6e0f0c678/copy HTTP/1.1
+	   Content-Type: application/json
+
+	   {
+		"Resource":"test.txt"
+	   }
+
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/octet-stream
+	   
+	   {{ STREAM }}
+
+	:statuscode 200: no error
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+
+2.2 Images
+----------
+
+List Images
+***********
+
+.. http:get:: /images/(format)
+
+	List images ``format`` could be json or viz (json default)
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   GET /images/json?all=0 HTTP/1.1
+
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/json
+	   
+	   [
+	     {
+	   	"RepoTag": [
+	   	  "ubuntu:12.04",
+	   	  "ubuntu:precise",
+	   	  "ubuntu:latest"
+	   	],
+	   	"Id": "8dbd9e392a964056420e5d58ca5cc376ef18e2de93b5cc90e868a1bbc8318c1c",
+	   	"Created": 1365714795,
+	   	"Size": 131506275,
+	   	"VirtualSize": 131506275
+	     },
+	     {
+	   	"RepoTag": [
+	   	  "ubuntu:12.10",
+	   	  "ubuntu:quantal"
+	   	],
+	   	"ParentId": "27cf784147099545",
+	   	"Id": "b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc",
+	   	"Created": 1364102658,
+	   	"Size": 24653,
+	   	"VirtualSize": 180116135
+	     }
+	   ]
+
+
+Create an image
+***************
+
+.. http:post:: /images/create
+
+	Create an image, either by pull it from the registry or by importing it
+
+	**Example request**:
+
+        .. sourcecode:: http
+
+           POST /images/create?fromImage=base HTTP/1.1
+
+        **Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 200 OK
+	   Content-Type: application/json
+
+	   {"status":"Pulling..."}
+	   {"status":"Pulling", "progress":"1/? (n/a)"}
+	   {"error":"Invalid..."}
+	   ...
+
+	When using this endpoint to pull an image from the registry,
+	the ``X-Registry-Auth`` header can be used to include a
+	base64-encoded AuthConfig object.
+
+        :query fromImage: name of the image to pull
+	:query fromSrc: source to import, - means stdin
+        :query repo: repository
+	:query tag: tag
+	:query registry: the registry to pull from
+        :statuscode 200: no error
+        :statuscode 500: server error
+
+
+Insert a file in an image
+*************************
+
+.. http:post:: /images/(name)/insert
+
+	Insert a file from ``url`` in the image ``name`` at ``path``
+
+	**Example request**:
+
+        .. sourcecode:: http
+
+           POST /images/test/insert?path=/usr&url=myurl HTTP/1.1
+
+	**Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 200 OK
+	   Content-Type: application/json
+
+	   {"status":"Inserting..."}
+	   {"status":"Inserting", "progress":"1/? (n/a)"}
+	   {"error":"Invalid..."}
+	   ...
+
+	:statuscode 200: no error
+        :statuscode 500: server error
+
+
+Inspect an image
+****************
+
+.. http:get:: /images/(name)/json
+
+	Return low-level information on the image ``name``
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   GET /images/base/json HTTP/1.1
+
+	**Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 200 OK
+	   Content-Type: application/json
+
+	   {
+		"id":"b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc",
+		"parent":"27cf784147099545",
+		"created":"2013-03-23T22:24:18.818426-07:00",
+		"container":"3d67245a8d72ecf13f33dffac9f79dcdf70f75acb84d308770391510e0c23ad0",
+		"container_config":
+			{
+				"Hostname":"",
+				"User":"",
+				"Memory":0,
+				"MemorySwap":0,
+				"AttachStdin":false,
+				"AttachStdout":false,
+				"AttachStderr":false,
+				"PortSpecs":null,
+				"Tty":true,
+				"OpenStdin":true,
+				"StdinOnce":false,
+				"Env":null,
+				"Cmd": ["/bin/bash"]
+				,"Dns":null,
+				"Image":"base",
+				"Volumes":null,
+				"VolumesFrom":"",
+				"WorkingDir":""
+			},
+		"Size": 6824592
+	   }
+
+	:statuscode 200: no error
+	:statuscode 404: no such image
+        :statuscode 500: server error
+
+
+Get the history of an image
+***************************
+
+.. http:get:: /images/(name)/history
+
+        Return the history of the image ``name``
+
+        **Example request**:
+
+        .. sourcecode:: http
+
+           GET /images/base/history HTTP/1.1
+
+        **Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 200 OK
+	   Content-Type: application/json
+
+	   [
+		{
+			"Id":"b750fe79269d",
+			"Created":1364102658,
+			"CreatedBy":"/bin/bash"
+		},
+		{
+			"Id":"27cf78414709",
+			"Created":1364068391,
+			"CreatedBy":""
+		}
+	   ]
+
+        :statuscode 200: no error
+        :statuscode 404: no such image
+        :statuscode 500: server error
+
+
+Push an image on the registry
+*****************************
+
+.. http:post:: /images/(name)/push
+
+   Push the image ``name`` on the registry
+
+   **Example request**:
+
+   .. sourcecode:: http
+
+      POST /images/test/push HTTP/1.1
+
+   **Example response**:
+
+   .. sourcecode:: http
+
+    HTTP/1.1 200 OK
+    Content-Type: application/json
+
+   {"status":"Pushing..."}
+   {"status":"Pushing", "progress":"1/? (n/a)"}
+   {"error":"Invalid..."}
+   ...
+
+	The ``X-Registry-Auth`` header can be used to include a
+	base64-encoded AuthConfig object.
+
+   :query registry: the registry you wan to push, optional
+   :statuscode 200: no error
+        :statuscode 404: no such image
+        :statuscode 500: server error
+
+
+Tag an image into a repository
+******************************
+
+.. http:post:: /images/(name)/tag
+
+	Tag the image ``name`` into a repository
+
+        **Example request**:
+
+        .. sourcecode:: http
+			
+	   POST /images/test/tag?repo=myrepo&force=0 HTTP/1.1
+
+	**Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 200 OK
+
+	:query repo: The repository to tag in
+	:query force: 1/True/true or 0/False/false, default false
+	:statuscode 200: no error
+	:statuscode 400: bad parameter
+	:statuscode 404: no such image
+	:statuscode 409: conflict
+        :statuscode 500: server error
+
+
+Remove an image
+***************
+
+.. http:delete:: /images/(name)
+
+	Remove the image ``name`` from the filesystem 
+	
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   DELETE /images/test HTTP/1.1
+
+	**Example response**:
+
+        .. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-type: application/json
+
+	   [
+	    {"Untagged":"3e2f21a89f"},
+	    {"Deleted":"3e2f21a89f"},
+	    {"Deleted":"53b4f83ac9"}
+	   ]
+
+	:statuscode 200: no error
+        :statuscode 404: no such image
+	:statuscode 409: conflict
+        :statuscode 500: server error
+
+
+Search images
+*************
+
+.. http:get:: /images/search
+
+	Search for an image in the docker index
+	
+	**Example request**:
+
+        .. sourcecode:: http
+
+           GET /images/search?term=sshd HTTP/1.1
+
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/json
+	   
+	   [
+		{
+			"Name":"cespare/sshd",
+			"Description":""
+		},
+		{
+			"Name":"johnfuller/sshd",
+			"Description":""
+		},
+		{
+			"Name":"dhrp/mongodb-sshd",
+			"Description":""
+		}
+	   ]
+
+	   :query term: term to search
+	   :statuscode 200: no error
+	   :statuscode 500: server error
+
+
+2.3 Misc
+--------
+
+Build an image from Dockerfile via stdin
+****************************************
+
+.. http:post:: /build
+
+   Build an image from Dockerfile via stdin
+
+   **Example request**:
+
+   .. sourcecode:: http
+
+      POST /build HTTP/1.1
+
+      {{ STREAM }}
+
+   **Example response**:
+
+   .. sourcecode:: http
+
+      HTTP/1.1 200 OK
+
+      {{ STREAM }}
+
+
+       The stream must be a tar archive compressed with one of the following algorithms:
+       identity (no compression), gzip, bzip2, xz. The archive must include a file called
+       `Dockerfile` at its root. It may include any number of other files, which will be
+       accessible in the build context (See the ADD build command).
+
+       The Content-type header should be set to "application/tar".
+
+	:query t: repository name (and optionally a tag) to be applied to the resulting image in case of success
+	:query q: suppress verbose build output
+    :query nocache: do not use the cache when building the image
+	:statuscode 200: no error
+    :statuscode 500: server error
+
+
+Check auth configuration
+************************
+
+.. http:post:: /auth
+
+        Get the default username and email
+
+        **Example request**:
+
+        .. sourcecode:: http
+
+           POST /auth HTTP/1.1
+	   Content-Type: application/json
+
+	   {
+		"username":"hannibal",
+		"password:"xxxx",
+		"email":"hannibal@a-team.com",
+		"serveraddress":"https://index.docker.io/v1/"
+	   }
+
+        **Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 200 OK
+
+        :statuscode 200: no error
+        :statuscode 204: no error
+        :statuscode 500: server error
+
+
+Display system-wide information
+*******************************
+
+.. http:get:: /info
+
+	Display system-wide information
+	
+	**Example request**:
+
+        .. sourcecode:: http
+
+           GET /info HTTP/1.1
+
+        **Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 200 OK
+	   Content-Type: application/json
+
+	   {
+		"Containers":11,
+		"Images":16,
+		"Debug":false,
+		"NFd": 11,
+		"NGoroutines":21,
+		"MemoryLimit":true,
+		"SwapLimit":false,
+		"IPv4Forwarding":true
+	   }
+
+        :statuscode 200: no error
+        :statuscode 500: server error
+
+
+Show the docker version information
+***********************************
+
+.. http:get:: /version
+
+	Show the docker version information
+
+	**Example request**:
+
+        .. sourcecode:: http
+
+           GET /version HTTP/1.1
+
+        **Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 200 OK
+	   Content-Type: application/json
+
+	   {
+		"Version":"0.2.2",
+		"GitCommit":"5a2a5cc+CHANGES",
+		"GoVersion":"go1.0.3"
+	   }
+
+        :statuscode 200: no error
+	:statuscode 500: server error
+
+
+Create a new image from a container's changes
+*********************************************
+
+.. http:post:: /commit
+
+    Create a new image from a container's changes
+
+    **Example request**:
+
+    .. sourcecode:: http
+
+        POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1
+
+    **Example response**:
+
+    .. sourcecode:: http
+
+        HTTP/1.1 201 OK
+	    Content-Type: application/vnd.docker.raw-stream
+
+        {"Id":"596069db4bf5"}
+
+    :query container: source container
+    :query repo: repository
+    :query tag: tag
+    :query m: commit message
+    :query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
+    :query run: config automatically applied when the image is run. (ex: {"Cmd": ["cat", "/world"], "PortSpecs":["22"]})
+    :statuscode 201: no error
+    :statuscode 404: no such container
+    :statuscode 500: server error
+
+
+Monitor Docker's events
+***********************
+
+.. http:get:: /events
+
+	Get events from docker, either in real time via streaming, or via polling (using `since`)
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+           POST /events?since=1374067924
+
+        **Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 200 OK
+	   Content-Type: application/json
+
+	   {"status":"create","id":"dfdf82bd3881","from":"base:latest","time":1374067924}
+	   {"status":"start","id":"dfdf82bd3881","from":"base:latest","time":1374067924}
+	   {"status":"stop","id":"dfdf82bd3881","from":"base:latest","time":1374067966}
+	   {"status":"destroy","id":"dfdf82bd3881","from":"base:latest","time":1374067970}
+
+	:query since: timestamp used for polling
+        :statuscode 200: no error
+        :statuscode 500: server error
+
+
+3. Going further
+================
+
+3.1 Inside 'docker run'
+-----------------------
+
+Here are the steps of 'docker run' :
+
+* Create the container
+* If the status code is 404, it means the image doesn't exists:
+        * Try to pull it
+        * Then retry to create the container
+* Start the container
+* If you are not in detached mode:
+        * Attach to the container, using logs=1 (to have stdout and stderr from the container's start) and stream=1
+* If in detached mode or only stdin is attached:
+	* Display the container's id
+
+
+3.2 Hijacking
+-------------
+
+In this version of the API, /attach, uses hijacking to transport stdin, stdout and stderr on the same socket. This might change in the future.
+
+3.3 CORS Requests
+-----------------
+
+To enable cross origin requests to the remote api add the flag "-api-enable-cors" when running docker in daemon mode.
+
+.. code-block:: bash
+
+   docker -d -H="192.168.1.9:4243" -api-enable-cors
+
diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 6c2826567b..c064a3cef2 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -328,6 +328,36 @@ Displaying images visually
 .. image:: docker_images.gif
    :alt: Example inheritance graph of Docker images.
 
+
+Displaying image hierarchy
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+::
+
+    sudo docker images -tree
+
+    |─8dbd9e392a96 Size: 131.5 MB (virtual 131.5 MB) Tags: ubuntu:12.04,ubuntu:latest,ubuntu:precise
+    └─27cf78414709 Size: 180.1 MB (virtual 180.1 MB)
+      └─b750fe79269d Size: 24.65 kB (virtual 180.1 MB) Tags: ubuntu:12.10,ubuntu:quantal
+        |─f98de3b610d5 Size: 12.29 kB (virtual 180.1 MB)
+        | └─7da80deb7dbf Size: 16.38 kB (virtual 180.1 MB)
+        |   └─65ed2fee0a34 Size: 20.66 kB (virtual 180.2 MB)
+        |     └─a2b9ea53dddc Size: 819.7 MB (virtual 999.8 MB)
+        |       └─a29b932eaba8 Size: 28.67 kB (virtual 999.9 MB)
+        |         └─e270a44f124d Size: 12.29 kB (virtual 999.9 MB) Tags: progrium/buildstep:latest
+        └─17e74ac162d8 Size: 53.93 kB (virtual 180.2 MB)
+          └─339a3f56b760 Size: 24.65 kB (virtual 180.2 MB)
+            └─904fcc40e34d Size: 96.7 MB (virtual 276.9 MB)
+              └─b1b0235328dd Size: 363.3 MB (virtual 640.2 MB)
+                └─7cb05d1acb3b Size: 20.48 kB (virtual 640.2 MB)
+                  └─47bf6f34832d Size: 20.48 kB (virtual 640.2 MB)
+                    └─f165104e82ed Size: 12.29 kB (virtual 640.2 MB)
+                      └─d9cf85a47b7e Size: 1.911 MB (virtual 642.2 MB)
+                        └─3ee562df86ca Size: 17.07 kB (virtual 642.2 MB)
+                          └─b05fc2d00e4a Size: 24.96 kB (virtual 642.2 MB)
+                            └─c96a99614930 Size: 12.29 kB (virtual 642.2 MB)
+                              └─a6a357a48c49 Size: 12.29 kB (virtual 642.2 MB) Tags: ndj/mongodb:latest
+
 .. _cli_import:
 
 ``import``

From 02bfc139c1a1b49a8bc0541b1214d5f54604b2e4 Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Mon, 28 Oct 2013 04:35:24 +0000
Subject: [PATCH 037/184] fixup for rebase Upstream-commit:
 22ef38ee79c2f353578f3642918a44126b4cb48c Component: engine

---
 components/engine/commands_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/commands_test.go b/components/engine/commands_test.go
index 479e295dd8..6c6a8e975b 100644
--- a/components/engine/commands_test.go
+++ b/components/engine/commands_test.go
@@ -782,7 +782,7 @@ func TestImagesTree(t *testing.T) {
 			"(?m)^  └─[0-9a-f]+",
 			"(?m)^    └─[0-9a-f]+",
 			"(?m)^      └─[0-9a-f]+",
-			fmt.Sprintf("        └─%s Size: \\d+.\\d+ kB \\(virtual \\d+.\\d+ MB\\) Tags: test:latest", utils.TruncateID(image.ID)),
+			fmt.Sprintf("        └─%s Size: \\d+ B \\(virtual \\d+.\\d+ MB\\) Tags: test:latest", utils.TruncateID(image.ID)),
 		}
 
 		compiledRegexps := []*regexp.Regexp{}

From c0461f4ee438b056fc173133ce8fde7fd4a4656e Mon Sep 17 00:00:00 2001
From: Marc Kuo <kuomarc2@gmail.com>
Date: Tue, 5 Nov 2013 20:48:16 -0800
Subject: [PATCH 038/184] Add -p when running the container

Without it, docker was not mapping/exposing the private port

Docker version 0.6.5, build 3ff8459
Upstream-commit: 3108f0526ef25596c7f6f545b07c95d90e966a7d
Component: engine
---
 components/engine/docs/sources/examples/nodejs_web_app.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/components/engine/docs/sources/examples/nodejs_web_app.rst b/components/engine/docs/sources/examples/nodejs_web_app.rst
index 19b10f6cbb..68c073da7b 100644
--- a/components/engine/docs/sources/examples/nodejs_web_app.rst
+++ b/components/engine/docs/sources/examples/nodejs_web_app.rst
@@ -176,11 +176,11 @@ Run the image
 +++++++++++++
 
 Running your image with ``-d`` runs the container in detached mode, leaving the
-container running in the background. Run the image you previously built:
+container running in the background. The ``-p`` flag redirects a public port to a private port in the container. Run the image you previously built:
 
 .. code-block:: bash
 
-    sudo docker run -d <your username>/centos-node-hello
+    sudo docker run -p 49160:8080 -d <your username>/centos-node-hello
 
 Print the output of your app:
 

From f530e76f7fb6c14225e6d2c97c2a7835055247a6 Mon Sep 17 00:00:00 2001
From: Daniel Norberg <dano@spotify.com>
Date: Tue, 5 Nov 2013 22:15:41 -0500
Subject: [PATCH 039/184] gograph: allow Walk() reentrance

Hold the read lock while reading the child graph,
then walk over the children without any lock, in
order to avoid deadlock.
Upstream-commit: 20881f1f787e093a6f3e9360624d8b436b9f7379
Component: engine
---
 components/engine/gograph/gograph.go | 101 +++++++++++++++------------
 1 file changed, 58 insertions(+), 43 deletions(-)

diff --git a/components/engine/gograph/gograph.go b/components/engine/gograph/gograph.go
index 626bf53ed8..aa6a4126a0 100644
--- a/components/engine/gograph/gograph.go
+++ b/components/engine/gograph/gograph.go
@@ -218,21 +218,28 @@ func (db *Database) List(name string, depth int) Entities {
 	if err != nil {
 		return out
 	}
-	for c := range db.children(e, name, depth) {
+
+	children, err := db.children(e, name, depth, nil)
+	if err != nil {
+		return out
+	}
+
+	for _, c := range children {
 		out[c.FullPath] = c.Entity
 	}
 	return out
 }
 
+// Walk through the child graph of an entity, calling walkFunc for each child entity.
+// It is safe for walkFunc to call graph functions.
 func (db *Database) Walk(name string, walkFunc WalkFunc, depth int) error {
-	db.mux.RLock()
-	defer db.mux.RUnlock()
-
-	e, err := db.get(name)
+	children, err := db.Children(name, depth)
 	if err != nil {
 		return err
 	}
-	for c := range db.children(e, name, depth) {
+
+	// Note: the database lock must not be held while calling walkFunc
+	for _, c := range children {
 		if err := walkFunc(c.FullPath, c.Entity); err != nil {
 			return err
 		}
@@ -240,6 +247,19 @@ func (db *Database) Walk(name string, walkFunc WalkFunc, depth int) error {
 	return nil
 }
 
+// Return the children of the specified entity
+func (db *Database) Children(name string, depth int) ([]WalkMeta, error) {
+	db.mux.RLock()
+	defer db.mux.RUnlock()
+
+	e, err := db.get(name)
+	if err != nil {
+		return nil, err
+	}
+
+	return db.children(e, name, depth, nil)
+}
+
 // Return the refrence count for a specified id
 func (db *Database) Refs(id string) int {
 	db.mux.RLock()
@@ -378,56 +398,51 @@ type WalkMeta struct {
 	Edge     *Edge
 }
 
-func (db *Database) children(e *Entity, name string, depth int) <-chan WalkMeta {
-	out := make(chan WalkMeta)
+func (db *Database) children(e *Entity, name string, depth int, entities []WalkMeta) ([]WalkMeta, error) {
 	if e == nil {
-		close(out)
-		return out
+		return entities, nil
 	}
 
-	go func() {
-		rows, err := db.conn.Query("SELECT entity_id, name FROM edge where parent_id = ?;", e.id)
-		if err != nil {
-			close(out)
+	rows, err := db.conn.Query("SELECT entity_id, name FROM edge where parent_id = ?;", e.id)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var entityId, entityName string
+		if err := rows.Scan(&entityId, &entityName); err != nil {
+			return nil, err
+		}
+		child := &Entity{entityId}
+		edge := &Edge{
+			ParentID: e.id,
+			Name:     entityName,
+			EntityID: child.id,
 		}
-		defer rows.Close()
 
-		for rows.Next() {
-			var entityId, entityName string
-			if err := rows.Scan(&entityId, &entityName); err != nil {
-				// Log error
-				continue
-			}
-			child := &Entity{entityId}
-			edge := &Edge{
-				ParentID: e.id,
-				Name:     entityName,
-				EntityID: child.id,
-			}
+		meta := WalkMeta{
+			Parent:   e,
+			Entity:   child,
+			FullPath: path.Join(name, edge.Name),
+			Edge:     edge,
+		}
 
-			meta := WalkMeta{
-				Parent:   e,
-				Entity:   child,
-				FullPath: path.Join(name, edge.Name),
-				Edge:     edge,
-			}
+		entities = append(entities, meta)
 
-			out <- meta
-			if depth == 0 {
-				continue
-			}
+		if depth != 0 {
 			nDepth := depth
 			if depth != -1 {
 				nDepth -= 1
 			}
-			sc := db.children(child, meta.FullPath, nDepth)
-			for c := range sc {
-				out <- c
+			entities, err = db.children(child, meta.FullPath, nDepth, entities)
+			if err != nil {
+				return nil, err
 			}
 		}
-		close(out)
-	}()
-	return out
+	}
+
+	return entities, nil
 }
 
 // Return the entity based on the parent path and name

From 563816191a6bc28c1559500aa1199f5e183a455e Mon Sep 17 00:00:00 2001
From: "Guillaume J. Charmes" <charmes.guillaume@gmail.com>
Date: Wed, 6 Nov 2013 07:37:43 -0800
Subject: [PATCH 040/184] Add debug to iptables Upstream-commit:
 00f1398f7a8543e2448723635d93ea6ddf1eaadb Component: engine

---
 components/engine/iptables/iptables.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/components/engine/iptables/iptables.go b/components/engine/iptables/iptables.go
index 8139b9881e..82ecf8bb5b 100644
--- a/components/engine/iptables/iptables.go
+++ b/components/engine/iptables/iptables.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"net"
+	"os"
 	"os/exec"
 	"strconv"
 	"strings"
@@ -122,10 +123,12 @@ func Raw(args ...string) ([]byte, error) {
 	if err != nil {
 		return nil, ErrIptablesNotFound
 	}
+	if os.Getenv("DEBUG") != "" {
+		fmt.Printf("[DEBUG] [iptables]: %s, %v\n", path, args)
+	}
 	output, err := exec.Command(path, args...).CombinedOutput()
 	if err != nil {
 		return nil, fmt.Errorf("iptables failed: iptables %v: %s (%s)", strings.Join(args, " "), output, err)
 	}
 	return output, err
-
 }

From a135b385fd0008ef5e7609f3b068a944f2f9bc46 Mon Sep 17 00:00:00 2001
From: Michael Crosby <crosby.michael@gmail.com>
Date: Wed, 6 Nov 2013 10:00:24 -0800
Subject: [PATCH 041/184] Update documentation to reflect changes in Config and
 HostConfig Upstream-commit: 70f44d5531a5c6dcb96b7e608a96beb52e93b506
 Component: engine

---
 .../docs/sources/api/docker_remote_api_v1.6.rst | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/components/engine/docs/sources/api/docker_remote_api_v1.6.rst b/components/engine/docs/sources/api/docker_remote_api_v1.6.rst
index defe145d06..09da63d8d9 100644
--- a/components/engine/docs/sources/api/docker_remote_api_v1.6.rst
+++ b/components/engine/docs/sources/api/docker_remote_api_v1.6.rst
@@ -121,8 +121,7 @@ Create a container
 		"AttachStdin":false,
 		"AttachStdout":true,
 		"AttachStderr":true,
-		"PortSpecs":null,
-		"Privileged": false,
+		"ExposedPorts":{},
 		"Tty":false,
 		"OpenStdin":false,
 		"StdinOnce":false,
@@ -135,7 +134,6 @@ Create a container
 		"Volumes":{},
 		"VolumesFrom":"",
 		"WorkingDir":""
-
 	   }
 	   
 	**Example response**:
@@ -191,7 +189,7 @@ Inspect a container
 				"AttachStdin": false,
 				"AttachStdout": true,
 				"AttachStderr": true,
-				"PortSpecs": null,
+				"ExposedPorts": {},
 				"Tty": false,
 				"OpenStdin": false,
 				"StdinOnce": false,
@@ -362,7 +360,12 @@ Start a container
 
            {
                 "Binds":["/tmp:/tmp"],
-                "LxcConf":{"lxc.utsname":"docker"}
+                "LxcConf":{"lxc.utsname":"docker"},
+                "ContainerIDFile": "",
+                "Privileged": false,
+                "PortBindings": {"22/tcp": [{HostIp:"", HostPort:""}]},
+                "Links": [],
+                "PublishAllPorts": false
            }
 
         **Example response**:
@@ -795,7 +798,7 @@ Inspect an image
 				"AttachStdin":false,
 				"AttachStdout":false,
 				"AttachStderr":false,
-				"PortSpecs":null,
+				"ExposedPorts":{},
 				"Tty":true,
 				"OpenStdin":true,
 				"StdinOnce":false,
@@ -1141,7 +1144,7 @@ Create a new image from a container's changes
        
        {
            "Cmd": ["cat", "/world"],
-           "PortSpecs":["22"]
+           "ExposedPorts":{"22/tcp":{}}
        }
 
     **Example response**:

From 143de969f1b1e9b2f92e7b9fd768b3b223e9db85 Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Wed, 6 Nov 2013 11:30:04 -0800
Subject: [PATCH 042/184] fix /images/json doc for 1.7 Upstream-commit:
 16eba6bbb514fb4082e6779e175a29698a6734ce Component: engine

---
 components/engine/docs/sources/api/docker_remote_api_v1.7.rst | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/components/engine/docs/sources/api/docker_remote_api_v1.7.rst b/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
index d1b094c872..3985f7aa0a 100644
--- a/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
+++ b/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
@@ -615,9 +615,7 @@ Copy files or folders from a container
 List Images
 ***********
 
-.. http:get:: /images/(format)
-
-	List images ``format`` could be json or viz (json default)
+.. http:get:: /images/json
 
 	**Example request**:
 

From 58f4b4c19fc4f1cb9663a680176be09705f05dec Mon Sep 17 00:00:00 2001
From: Alexander Larsson <alexl@redhat.com>
Date: Thu, 12 Sep 2013 15:17:39 +0200
Subject: [PATCH 043/184] Utils: Add ShellQuoteArguments Upstream-commit:
 c5bc7d515836cffee90ba5bb342272bba64d9f37 Component: engine

---
 components/engine/utils/utils.go | 35 ++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/components/engine/utils/utils.go b/components/engine/utils/utils.go
index 4941eae42d..623f00296e 100644
--- a/components/engine/utils/utils.go
+++ b/components/engine/utils/utils.go
@@ -1139,6 +1139,41 @@ func (e *StatusError) Error() string {
 	return fmt.Sprintf("Status: %d", e.Status)
 }
 
+func quote(word string, buf *bytes.Buffer) {
+	// Bail out early for "simple" strings
+	if word != "" && !strings.ContainsAny(word, "\\'\"`${[|&;<>()~*?! \t\n") {
+		buf.WriteString(word)
+		return
+	}
+
+	buf.WriteString("'")
+
+	for i := 0; i < len(word); i++ {
+		b := word[i]
+		if b == '\'' {
+			// Replace literal ' with a close ', a \', and a open '
+			buf.WriteString("'\\''")
+		} else {
+			buf.WriteByte(b)
+		}
+	}
+
+	buf.WriteString("'")
+}
+
+// Take a list of strings and escape them so they will be handled right
+// when passed as arguments to an program via a shell
+func ShellQuoteArguments(args []string) string {
+	var buf bytes.Buffer
+	for i, arg := range args {
+		if i != 0 {
+			buf.WriteByte(' ')
+		}
+		quote(arg, &buf)
+	}
+	return buf.String()
+}
+
 func IsClosedError(err error) bool {
 	/* This comparison is ugly, but unfortunately, net.go doesn't export errClosing.
 	 * See:

From 5edb2719224f88f9410a65801f160edd2928012d Mon Sep 17 00:00:00 2001
From: Alexander Larsson <alexl@redhat.com>
Date: Tue, 29 Oct 2013 16:16:51 +0100
Subject: [PATCH 044/184] lxc: Work around lxc-start need for private mounts

lxc-start requires / to be mounted private, otherwise the changes
it does inside the container (both mounts and unmounts) will propagate
out to the host.

We work around this by starting up lxc-start in its own namespace where
we set / to rshared.

Unfortunately go can't really execute any code between clone and exec,
so we can't do this in a nice way. Instead we have a horrible hack that
use the unshare command, the shell and the mount command...
Upstream-commit: 157d99a72786c454dfaad8b0800914cc80879aa8
Component: engine
---
 components/engine/container.go | 27 +++++++++++++++++++++++----
 components/engine/utils.go     | 15 +++++++++++++++
 2 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index 50bf2ec674..ac21119d1a 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -863,7 +863,13 @@ func (container *Container) Start() (err error) {
 		return err
 	}
 
+	var lxcStart string = "lxc-start"
+	if container.hostConfig.Privileged && container.runtime.capabilities.AppArmor {
+		lxcStart = path.Join(container.runtime.config.Root, "lxc-start-unconfined")
+	}
+
 	params := []string{
+		lxcStart,
 		"-n", container.ID,
 		"-f", container.lxcConfigPath(),
 		"--",
@@ -956,11 +962,24 @@ func (container *Container) Start() (err error) {
 	params = append(params, "--", container.Path)
 	params = append(params, container.Args...)
 
-	var lxcStart string = "lxc-start"
-	if container.hostConfig.Privileged && container.runtime.capabilities.AppArmor {
-		lxcStart = path.Join(container.runtime.config.Root, "lxc-start-unconfined")
+	if RootIsShared() {
+		// lxc-start really needs / to be non-shared, or all kinds of stuff break
+		// when lxc-start unmount things and those unmounts propagate to the main
+		// mount namespace.
+		// What we really want is to clone into a new namespace and then
+		// mount / MS_REC|MS_SLAVE, but since we can't really clone or fork
+		// without exec in go we have to do this horrible shell hack...
+		shellString :=
+			"mount --make-rslave /; exec " +
+				utils.ShellQuoteArguments(params)
+
+		params = []string{
+			"unshare", "-m", "--", "/bin/sh", "-c", shellString,
+		}
 	}
-	container.cmd = exec.Command(lxcStart, params...)
+
+	container.cmd = exec.Command(params[0], params[1:]...)
+
 	// Setup logging of stdout and stderr to disk
 	if err := container.runtime.LogToDisk(container.stdout, container.logPath("json"), "stdout"); err != nil {
 		return err
diff --git a/components/engine/utils.go b/components/engine/utils.go
index 81715881ae..22d83d6bee 100644
--- a/components/engine/utils.go
+++ b/components/engine/utils.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"github.com/dotcloud/docker/namesgenerator"
 	"github.com/dotcloud/docker/utils"
+	"io/ioutil"
 	"strconv"
 	"strings"
 )
@@ -301,6 +302,20 @@ func parseLink(rawLink string) (map[string]string, error) {
 	return utils.PartParser("name:alias", rawLink)
 }
 
+func RootIsShared() bool {
+	if data, err := ioutil.ReadFile("/proc/self/mountinfo"); err == nil {
+		for _, line := range strings.Split(string(data), "\n") {
+			cols := strings.Split(line, " ")
+			if len(cols) >= 6 && cols[4] == "/" {
+				return strings.HasPrefix(cols[6], "shared")
+			}
+		}
+	}
+
+	// No idea, probably safe to assume so
+	return true
+}
+
 type checker struct {
 	runtime *Runtime
 }

From 85bf6b92cb28738c6c55b0cef88763f08e09b995 Mon Sep 17 00:00:00 2001
From: Nate Jones <nate@endot.org>
Date: Wed, 6 Nov 2013 12:03:45 -0800
Subject: [PATCH 045/184] updating cli help doc for images Upstream-commit:
 363738b8f21d02c2e4fac84bd2776c2d4a5e6755 Component: engine

---
 components/engine/docs/sources/commandline/cli.rst | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index c064a3cef2..6d56bccc38 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -315,8 +315,10 @@ Shell 1: (Again .. now showing events)
     List images
 
       -a=false: show all images
+      -notrunc=false: Don't truncate output
       -q=false: only show numeric IDs
-      -viz=false: output in graphviz format
+      -tree=false: output graph in tree format
+      -viz=false: output graph in graphviz format
 
 Displaying images visually
 ~~~~~~~~~~~~~~~~~~~~~~~~~~

From 9970f516fc2a3653f12f67800f24f5916b333b81 Mon Sep 17 00:00:00 2001
From: andy diller <dillera@gmail.com>
Date: Wed, 6 Nov 2013 12:37:01 -0500
Subject: [PATCH 046/184] updated create, showing how to set expose port and
 bind to public port for ssh Upstream-commit:
 2d1155407a6e24b595d2627af6fa9f9f702483d2 Component: engine

---
 .../sources/api/docker_remote_api_v1.6.rst    | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/components/engine/docs/sources/api/docker_remote_api_v1.6.rst b/components/engine/docs/sources/api/docker_remote_api_v1.6.rst
index defe145d06..8585470735 100644
--- a/components/engine/docs/sources/api/docker_remote_api_v1.6.rst
+++ b/components/engine/docs/sources/api/docker_remote_api_v1.6.rst
@@ -157,6 +157,57 @@ Create a container
 	:statuscode 406: impossible to attach (container not running)
 	:statuscode 500: server error
 
+	**More Complex Example request, in 2 steps.**
+	**First, use create to expose a Private Port, which can be bound back to a Public Port at startup**:
+
+	.. sourcecode:: http
+
+	   POST /containers/create HTTP/1.1
+	   Content-Type: application/json
+
+	   {
+		"Cmd":[
+			"/usr/sbin/sshd","-D"
+		],
+		"Image":"image-with-sshd",
+		"ExposedPorts":{"22/tcp":{}}
+		}
+
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 201 OK
+	   Content-Type: application/json
+
+	   {
+		"Id":"e90e34656806"
+		"Warnings":[]
+	   }
+
+	** Second, start (using the ID returned above) the image we just created, mapping the ssh port 22 to something on the host**:
+
+	.. sourcecode:: http
+
+	   POST /containers/e90e34656806/start HTTP/1.1
+	   Content-Type: application/json
+
+	   {
+		"PortBindings": { "22/tcp": [{ "HostPort": "11022" }]} 
+		}
+
+	**Example response**:
+
+	.. sourcecode:: http
+
+		HTTP/1.1 204 No Content
+		Content-Type: text/plain; charset=utf-8
+		Content-Length: 0
+
+	** Now you can ssh into your new container on port 11022.**
+
+
+
 
 Inspect a container
 *******************

From 80db89881c137f0107033b669432c79fd070c4a5 Mon Sep 17 00:00:00 2001
From: Andy Rothfusz <github@metaliveblog.com>
Date: Wed, 6 Nov 2013 18:07:38 -0800
Subject: [PATCH 047/184] Fix bold Upstream-commit:
 9990db2f5a762fdbc198cbfc5e96370d859739bb Component: engine

---
 components/engine/docs/sources/api/docker_remote_api_v1.6.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/components/engine/docs/sources/api/docker_remote_api_v1.6.rst b/components/engine/docs/sources/api/docker_remote_api_v1.6.rst
index 8585470735..461ffefd6b 100644
--- a/components/engine/docs/sources/api/docker_remote_api_v1.6.rst
+++ b/components/engine/docs/sources/api/docker_remote_api_v1.6.rst
@@ -185,7 +185,7 @@ Create a container
 		"Warnings":[]
 	   }
 
-	** Second, start (using the ID returned above) the image we just created, mapping the ssh port 22 to something on the host**:
+	**Second, start (using the ID returned above) the image we just created, mapping the ssh port 22 to something on the host**:
 
 	.. sourcecode:: http
 
@@ -204,7 +204,7 @@ Create a container
 		Content-Type: text/plain; charset=utf-8
 		Content-Length: 0
 
-	** Now you can ssh into your new container on port 11022.**
+	**Now you can ssh into your new container on port 11022.**
 
 
 

From 6b8ac9d25776b62f614f2a1c0b3196e5aeb0a401 Mon Sep 17 00:00:00 2001
From: Daniel Mizyrycki <mzdaniel@glidelink.net>
Date: Fri, 18 Oct 2013 09:27:34 -0700
Subject: [PATCH 048/184] testing infrastructure, issue #1800: Refactor docker
 testing using Docker in Docker Upstream-commit:
 50dd9791f75efef77a85bbe6556c85de0d845c0a Component: engine

---
 components/engine/hack/infrastructure/docker-ci/deployment.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/components/engine/hack/infrastructure/docker-ci/deployment.py b/components/engine/hack/infrastructure/docker-ci/deployment.py
index 655bdd43bc..453fad7590 100755
--- a/components/engine/hack/infrastructure/docker-ci/deployment.py
+++ b/components/engine/hack/infrastructure/docker-ci/deployment.py
@@ -138,6 +138,9 @@ sudo('curl -s https://phantomjs.googlecode.com/files/'
 # Preventively reboot docker-ci daily
 sudo('ln -s /sbin/reboot /etc/cron.daily')
 
+# Preventively reboot docker-ci daily
+sudo('ln -s /sbin/reboot /etc/cron.daily')
+
 # Build docker-ci containers
 sudo('cd {}; docker build -t docker .'.format(DOCKER_PATH))
 sudo('cd {}/nightlyrelease; docker build -t dockerbuilder .'.format(

From aac90cd92e4389ce099b59cb7313755538ca4d48 Mon Sep 17 00:00:00 2001
From: Daniel Mizyrycki <mzdaniel@glidelink.net>
Date: Sun, 27 Oct 2013 12:13:03 -0700
Subject: [PATCH 049/184] docker-ci 0.35. Push docker coverage and testing into
 docker-ci production. Update docker nightlyrelease Upstream-commit:
 17172276366fc3114ae52eb6c83aafbec004d5f3 Component: engine

---
 .../hack/infrastructure/docker-ci/Dockerfile  |  6 ++-
 .../docker-ci/buildbot/master.cfg             | 27 ++++++----
 .../infrastructure/docker-ci/deployment.py    |  6 ++-
 .../docker-ci/docker-test/test_docker.sh      | 15 ++----
 .../functionaltests/test_registry.sh          |  1 +
 .../docker-ci/nightlyrelease/Dockerfile       | 18 +++----
 .../docker-ci/nightlyrelease/dockerbuild      | 50 -------------------
 .../docker-ci/nightlyrelease/dockerbuild.sh   | 40 +++++++++++++++
 .../nightlyrelease/release_credentials.json   |  1 -
 .../docker-ci/registry-coverage/Dockerfile    | 18 +++++++
 .../registry-coverage/registry_coverage.sh    | 18 +++++++
 11 files changed, 113 insertions(+), 87 deletions(-)
 delete mode 100644 components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild
 create mode 100644 components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild.sh
 delete mode 100644 components/engine/hack/infrastructure/docker-ci/nightlyrelease/release_credentials.json
 create mode 100644 components/engine/hack/infrastructure/docker-ci/registry-coverage/Dockerfile
 create mode 100755 components/engine/hack/infrastructure/docker-ci/registry-coverage/registry_coverage.sh

diff --git a/components/engine/hack/infrastructure/docker-ci/Dockerfile b/components/engine/hack/infrastructure/docker-ci/Dockerfile
index 3ac8d90d24..bb49944d1b 100644
--- a/components/engine/hack/infrastructure/docker-ci/Dockerfile
+++ b/components/engine/hack/infrastructure/docker-ci/Dockerfile
@@ -33,8 +33,10 @@
 
 from ubuntu:12.04
 
-run echo 'deb http://archive.ubuntu.com/ubuntu precise main universe' > /etc/apt/sources.list
-run apt-get update; apt-get install -y python2.7 python-dev python-pip ssh rsync less vim
+run echo 'deb http://archive.ubuntu.com/ubuntu precise main universe' \
+    > /etc/apt/sources.list
+run apt-get update; apt-get install -y git python2.7 python-dev libevent-dev \
+    python-pip ssh rsync less vim
 run pip install boto fabric
 
 # Add deployment code and set default container command
diff --git a/components/engine/hack/infrastructure/docker-ci/buildbot/master.cfg b/components/engine/hack/infrastructure/docker-ci/buildbot/master.cfg
index 52bf495df3..9ca5fc035a 100644
--- a/components/engine/hack/infrastructure/docker-ci/buildbot/master.cfg
+++ b/components/engine/hack/infrastructure/docker-ci/buildbot/master.cfg
@@ -43,7 +43,7 @@ c['slavePortnum'] = PORT_MASTER
 
 # Schedulers
 c['schedulers'] = [ForceScheduler(name='trigger', builderNames=['docker',
-    'index','registry','coverage','nightlyrelease'])]
+    'index','registry','docker-coverage','registry-coverage','nightlyrelease'])]
 c['schedulers'] += [SingleBranchScheduler(name="all", treeStableTimer=None,
     change_filter=filter.ChangeFilter(branch='master',
     repository='https://github.com/dotcloud/docker'), builderNames=['docker'])]
@@ -51,7 +51,7 @@ c['schedulers'] += [SingleBranchScheduler(name='pullrequest',
     change_filter=filter.ChangeFilter(category='github_pullrequest'), treeStableTimer=None,
     builderNames=['pullrequest'])]
 c['schedulers'] += [Nightly(name='daily', branch=None, builderNames=['nightlyrelease',
-    'coverage'], hour=7, minute=00)]
+    'docker-coverage','registry-coverage'], hour=7, minute=00)]
 c['schedulers'] += [Nightly(name='every4hrs', branch=None, builderNames=['registry','index'],
     hour=range(0,24,4), minute=15)]
 
@@ -76,17 +76,25 @@ c['builders'] += [BuilderConfig(name='pullrequest',slavenames=['buildworker'],
 
 # Docker coverage test
 factory = BuildFactory()
-factory.addStep(ShellCommand(description='Coverage', logEnviron=False,
+factory.addStep(ShellCommand(description='docker-coverage', logEnviron=False,
     usePTY=True, command='{0}/docker-coverage/coverage-docker.sh'.format(
     DOCKER_CI_PATH)))
-c['builders'] += [BuilderConfig(name='coverage',slavenames=['buildworker'],
+c['builders'] += [BuilderConfig(name='docker-coverage',slavenames=['buildworker'],
+    factory=factory)]
+
+# Docker registry coverage test
+factory = BuildFactory()
+factory.addStep(ShellCommand(description='registry-coverage', logEnviron=False,
+    usePTY=True, command='docker run registry_coverage'.format(
+    DOCKER_CI_PATH)))
+c['builders'] += [BuilderConfig(name='registry-coverage',slavenames=['buildworker'],
     factory=factory)]
 
 # Registry functional test
 factory = BuildFactory()
 factory.addStep(ShellCommand(description='registry', logEnviron=False,
     command='. {0}/master/credentials.cfg; '
-    '/docker-ci/functionaltests/test_registry.sh'.format(BUILDBOT_PATH),
+    '{1}/functionaltests/test_registry.sh'.format(BUILDBOT_PATH, DOCKER_CI_PATH),
     usePTY=True))
 c['builders'] += [BuilderConfig(name='registry',slavenames=['buildworker'],
     factory=factory)]
@@ -95,16 +103,17 @@ c['builders'] += [BuilderConfig(name='registry',slavenames=['buildworker'],
 factory = BuildFactory()
 factory.addStep(ShellCommand(description='index', logEnviron=False,
     command='. {0}/master/credentials.cfg; '
-    '/docker-ci/functionaltests/test_index.py'.format(BUILDBOT_PATH),
+    '{1}/functionaltests/test_index.py'.format(BUILDBOT_PATH, DOCKER_CI_PATH),
     usePTY=True))
 c['builders'] += [BuilderConfig(name='index',slavenames=['buildworker'],
     factory=factory)]
 
 # Docker nightly release
+nightlyrelease_cmd = ('docker version; docker run -i -t -privileged -e AWS_S3_BUCKET='
+    'test.docker.io dockerbuilder hack/dind dockerbuild.sh')
 factory = BuildFactory()
-factory.addStep(ShellCommand(description='NightlyRelease', logEnviron=False,
-    usePTY=True, command='docker run -privileged'
-    ' -e AWS_S3_BUCKET=test.docker.io dockerbuilder'))
+factory.addStep(ShellCommand(description='NightlyRelease',logEnviron=False,
+    usePTY=True, command=nightlyrelease_cmd))
 c['builders'] += [BuilderConfig(name='nightlyrelease',slavenames=['buildworker'],
     factory=factory)]
 
diff --git a/components/engine/hack/infrastructure/docker-ci/deployment.py b/components/engine/hack/infrastructure/docker-ci/deployment.py
index 453fad7590..1a389d2771 100755
--- a/components/engine/hack/infrastructure/docker-ci/deployment.py
+++ b/components/engine/hack/infrastructure/docker-ci/deployment.py
@@ -100,8 +100,7 @@ sudo("echo '{}' >> /root/.ssh/authorized_keys".format(env['DOCKER_CI_PUB']))
 credentials = {
     'AWS_ACCESS_KEY': env['PKG_ACCESS_KEY'],
     'AWS_SECRET_KEY': env['PKG_SECRET_KEY'],
-    'GPG_PASSPHRASE': env['PKG_GPG_PASSPHRASE'],
-    'INDEX_AUTH': env['INDEX_AUTH']}
+    'GPG_PASSPHRASE': env['PKG_GPG_PASSPHRASE']}
 open(DOCKER_CI_PATH + '/nightlyrelease/release_credentials.json', 'w').write(
     base64.b64encode(json.dumps(credentials)))
 
@@ -143,8 +142,11 @@ sudo('ln -s /sbin/reboot /etc/cron.daily')
 
 # Build docker-ci containers
 sudo('cd {}; docker build -t docker .'.format(DOCKER_PATH))
+sudo('cd {}; docker build -t docker-ci .'.format(DOCKER_CI_PATH))
 sudo('cd {}/nightlyrelease; docker build -t dockerbuilder .'.format(
     DOCKER_CI_PATH))
+sudo('cd {}/registry-coverage; docker build -t registry_coverage .'.format(
+    DOCKER_CI_PATH))
 
 # Download docker-ci testing container
 sudo('docker pull mzdaniel/test_docker')
diff --git a/components/engine/hack/infrastructure/docker-ci/docker-test/test_docker.sh b/components/engine/hack/infrastructure/docker-ci/docker-test/test_docker.sh
index 895e4d9642..c8cfe147e6 100755
--- a/components/engine/hack/infrastructure/docker-ci/docker-test/test_docker.sh
+++ b/components/engine/hack/infrastructure/docker-ci/docker-test/test_docker.sh
@@ -9,30 +9,21 @@ BRANCH=${3-master}
 DOCKER_PATH=/go/src/github.com/dotcloud/docker
 
 # Fetch latest master
+cd /
 rm -rf /go
-mkdir -p $DOCKER_PATH
+git clone -q -b master http://github.com/dotcloud/docker $DOCKER_PATH
 cd $DOCKER_PATH
-git init .
-git fetch -q http://github.com/dotcloud/docker master
-git reset --hard FETCH_HEAD
 
 # Merge commit
-#echo FIXME. Temporarily skip TestPrivilegedCanMount until DinD works reliable on AWS
-git pull -q https://github.com/mzdaniel/docker.git dind-aws || exit 1
-
-# Merge commit in top of master
 git fetch -q "$REPO" "$BRANCH"
 git merge --no-edit $COMMIT || exit 1
 
 # Test commit
-go test -v; exit_status=$?
+./hack/make.sh test; exit_status=$?
 
 # Display load if test fails
 if [ $exit_status -eq 1 ] ; then
     uptime; echo; free
 fi
 
-# Cleanup testing directory
-rm -rf $BASE_PATH
-
 exit $exit_status
diff --git a/components/engine/hack/infrastructure/docker-ci/functionaltests/test_registry.sh b/components/engine/hack/infrastructure/docker-ci/functionaltests/test_registry.sh
index 8bcd355c7c..d175f66d16 100755
--- a/components/engine/hack/infrastructure/docker-ci/functionaltests/test_registry.sh
+++ b/components/engine/hack/infrastructure/docker-ci/functionaltests/test_registry.sh
@@ -12,6 +12,7 @@ export DOCKER_REGISTRY_CONFIG=config_test.yml
 # Get latest docker registry
 git clone -q https://github.com/dotcloud/docker-registry.git
 cd docker-registry
+sed -Ei "s#(boto_bucket: ).+#\1_env:S3_BUCKET#" config_test.yml
 
 # Get dependencies
 pip install -q -r requirements.txt
diff --git a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile
index 541f3a9584..953d7c11cc 100644
--- a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile
+++ b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile
@@ -1,5 +1,5 @@
-# VERSION:        1.2
-# DOCKER-VERSION  0.6.3
+# VERSION:        1.5
+# DOCKER-VERSION  0.6.4
 # AUTHOR:         Daniel Mizyrycki <daniel@dotcloud.com>
 # DESCRIPTION:    Build docker nightly release using Docker in Docker.
 # REFERENCES:     This code reuses the excellent implementation of docker in docker
@@ -7,11 +7,10 @@
 # COMMENTS:
 #   release_credentials.json is a base64 json encoded file containing:
 #       { "AWS_ACCESS_KEY": "Test_docker_AWS_S3_bucket_id",
-#         "AWS_SECRET_KEY='Test_docker_AWS_S3_bucket_key'
-#         "GPG_PASSPHRASE='Test_docker_GPG_passphrase_signature'
-#         "INDEX_AUTH='Encripted_index_authentication' }
+#         "AWS_SECRET_KEY": "Test_docker_AWS_S3_bucket_key",
+#         "GPG_PASSPHRASE": "Test_docker_GPG_passphrase_signature" }
 # TO_BUILD:       docker build -t dockerbuilder .
-# TO_RELEASE:     docker run -i -t -privileged  -e AWS_S3_BUCKET="test.docker.io" dockerbuilder
+# TO_RELEASE:     docker run -i -t -privileged -e AWS_S3_BUCKET="test.docker.io" dockerbuilder hack/dind dockerbuild.sh
 
 from docker
 maintainer Daniel Mizyrycki <daniel@dotcloud.com>
@@ -24,11 +23,8 @@ run apt-get update; apt-get install -y -q wget python2.7
 run wget -q -O /usr/bin/docker http://get.docker.io/builds/Linux/x86_64/docker-latest; chmod +x /usr/bin/docker
 
 # Add proto docker builder
-add ./dockerbuild /usr/bin/dockerbuild
-run chmod +x /usr/bin/dockerbuild
+add ./dockerbuild.sh /usr/bin/dockerbuild.sh
+run chmod +x /usr/bin/dockerbuild.sh
 
 # Add release credentials
 add ./release_credentials.json /root/release_credentials.json
-
-# Launch build process in a container
-cmd dockerbuild
diff --git a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild
deleted file mode 100644
index 83a7157a3e..0000000000
--- a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild
+++ /dev/null
@@ -1,50 +0,0 @@
-#!/bin/bash
-
-# Variables AWS_ACCESS_KEY, AWS_SECRET_KEY, PG_PASSPHRASE and INDEX_AUTH
-# are decoded from /root/release_credentials.json
-# Variable AWS_S3_BUCKET is passed to the environment from docker run -e
-
-# Enable debugging
-set -x
-
-# Fetch docker master branch
-rm -rf  /go/src/github.com/dotcloud/docker
-cd /
-git clone -q http://github.com/dotcloud/docker /go/src/github.com/dotcloud/docker
-cd /go/src/github.com/dotcloud/docker
-
-# Launch docker daemon using dind inside the container
-./hack/dind /usr/bin/docker -d &
-sleep 5
-
-# Add an uncommitted change to generate a timestamped release
-date > timestamp
-
-# Build the docker package using /Dockerfile
-docker build -t docker .
-
-# Run Docker unittests binary and Ubuntu package
-docker run -privileged docker hack/make.sh
-exit_status=$?
-
-# Display load if test fails
-if [ $exit_status -eq 1 ] ; then
-    uptime; echo; free
-    exit 1
-fi
-
-# Commit binary and ubuntu bundles for release
-docker commit -run '{"Env": ["PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin"], "WorkingDir": "/go/src/github.com/dotcloud/docker"}' $(docker ps -l -q) release
-
-# Turn debug off to load credentials from the environment
-set +x
-eval $(cat /root/release_credentials.json  | python -c '
-import sys,json,base64;
-d=json.loads(base64.b64decode(sys.stdin.read()));
-exec("""for k in d: print "export {0}=\\"{1}\\"".format(k,d[k])""")')
-set -x
-
-# Push docker nightly
-echo docker run -i -t -privileged -e AWS_S3_BUCKET=$AWS_S3_BUCKET -e AWS_ACCESS_KEY=XXXXX -e AWS_SECRET_KEY=XXXXX -e GPG_PASSPHRASE=XXXXX release  hack/release.sh
-set +x
-docker run -i -t -privileged -e AWS_S3_BUCKET=$AWS_S3_BUCKET -e AWS_ACCESS_KEY=$AWS_ACCESS_KEY -e AWS_SECRET_KEY=$AWS_SECRET_KEY -e GPG_PASSPHRASE=$GPG_PASSPHRASE  release  hack/release.sh
diff --git a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild.sh b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild.sh
new file mode 100644
index 0000000000..457db3f889
--- /dev/null
+++ b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Variables AWS_ACCESS_KEY, AWS_SECRET_KEY and PG_PASSPHRASE are decoded
+# from /root/release_credentials.json
+# Variable AWS_S3_BUCKET is passed to the environment from docker run -e
+
+# Turn debug off to load credentials from the environment
+set +x
+eval $(cat /root/release_credentials.json  | python -c '
+import sys,json,base64;
+d=json.loads(base64.b64decode(sys.stdin.read()));
+exec("""for k in d: print "export {0}=\\"{1}\\"".format(k,d[k])""")')
+
+# Fetch docker master branch
+set -x
+cd /
+rm -rf /go
+git clone -q -b master http://github.com/dotcloud/docker /go/src/github.com/dotcloud/docker
+cd /go/src/github.com/dotcloud/docker
+
+# Launch docker daemon using dind inside the container
+/usr/bin/docker version
+/usr/bin/docker -d &
+sleep 5
+
+# Build Docker release container
+docker build -t docker .
+
+# Test docker and if everything works well, release
+echo docker run -i -t -privileged -e AWS_S3_BUCKET=$AWS_S3_BUCKET -e AWS_ACCESS_KEY=XXXXX -e AWS_SECRET_KEY=XXXXX -e GPG_PASSPHRASE=XXXXX docker hack/release.sh
+set +x
+docker run -privileged -i -t -e AWS_S3_BUCKET=$AWS_S3_BUCKET -e AWS_ACCESS_KEY=$AWS_ACCESS_KEY -e AWS_SECRET_KEY=$AWS_SECRET_KEY -e GPG_PASSPHRASE=$GPG_PASSPHRASE docker hack/release.sh
+exit_status=$?
+
+# Display load if test fails
+set -x
+if [ $exit_status -eq 1 ] ; then
+    uptime; echo; free
+    exit 1
+fi
diff --git a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/release_credentials.json b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/release_credentials.json
deleted file mode 100644
index ed6d53ecd1..0000000000
--- a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/release_credentials.json
+++ /dev/null
@@ -1 +0,0 @@
-eyAiQVdTX0FDQ0VTU19LRVkiOiAiIiwKICAiQVdTX1NFQ1JFVF9LRVkiOiAiIiwKICAiR1BHX1BBU1NQSFJBU0UiOiAiIiwKICAiSU5ERVhfQVVUSCI6ICIiIH0=
diff --git a/components/engine/hack/infrastructure/docker-ci/registry-coverage/Dockerfile b/components/engine/hack/infrastructure/docker-ci/registry-coverage/Dockerfile
new file mode 100644
index 0000000000..59c914fb2b
--- /dev/null
+++ b/components/engine/hack/infrastructure/docker-ci/registry-coverage/Dockerfile
@@ -0,0 +1,18 @@
+# VERSION:        0.1
+# DOCKER-VERSION  0.6.4
+# AUTHOR:         Daniel Mizyrycki <daniel@dotcloud.com>
+# DESCRIPTION:    Docker registry coverage
+# COMMENTS:       Add registry coverage into the docker-ci image
+# TO_BUILD:       docker build -t registry_coverage .
+# TO_RUN:         docker run registry_coverage
+
+from docker-ci
+maintainer Daniel Mizyrycki <daniel@dotcloud.com>
+
+# Add registry_coverager.sh and dependencies
+run pip install coverage flask pyyaml requests simplejson python-glanceclient \
+    blinker redis gevent
+add registry_coverage.sh /usr/bin/registry_coverage.sh
+run chmod +x /usr/bin/registry_coverage.sh
+
+cmd "/usr/bin/registry_coverage.sh"
diff --git a/components/engine/hack/infrastructure/docker-ci/registry-coverage/registry_coverage.sh b/components/engine/hack/infrastructure/docker-ci/registry-coverage/registry_coverage.sh
new file mode 100755
index 0000000000..e9f0172651
--- /dev/null
+++ b/components/engine/hack/infrastructure/docker-ci/registry-coverage/registry_coverage.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -x
+
+# Compute test paths
+REGISTRY_PATH=/data/docker-registry
+
+# Fetch latest docker-registry master
+rm -rf $REGISTRY_PATH
+git clone https://github.com/dotcloud/docker-registry -b master $REGISTRY_PATH
+cd $REGISTRY_PATH
+
+# Generate coverage
+export SETTINGS_FLAVOR=test
+export DOCKER_REGISTRY_CONFIG=config_test.yml
+
+coverage run -m unittest discover test || exit 1
+coverage report --include='./*' --omit='./test/*'

From 7a7c9f0f1d41534dd4afd66f7d8fa56e38ed94e1 Mon Sep 17 00:00:00 2001
From: Daniel Mizyrycki <mzdaniel@glidelink.net>
Date: Mon, 28 Oct 2013 16:51:31 -0700
Subject: [PATCH 050/184] docker-ci 0.36. Patch hack/dind with latest code for
 nightly release to work. Upstream-commit:
 0cbeda73910d6d1d3336da93c5f94df0bdd5fa44 Component: engine

---
 .../hack/infrastructure/docker-ci/nightlyrelease/Dockerfile  | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile
index 953d7c11cc..6762cb4686 100644
--- a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile
+++ b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile
@@ -22,6 +22,11 @@ run apt-get update; apt-get install -y -q wget python2.7
 # Add production docker binary
 run wget -q -O /usr/bin/docker http://get.docker.io/builds/Linux/x86_64/docker-latest; chmod +x /usr/bin/docker
 
+#### FIXME. Temporarily install docker and dind with proper apparmor handling
+run wget -q -O /usr/bin/docker http://test.docker.io/test/docker; chmod +x /usr/bin/docker
+run wget -q -O /go/src/github.com/dotcloud/docker/hack/dind http://raw.github.com/jpetazzo/docker/escape-apparmor-confinement/hack/dind
+run chmod +x /go/src/github.com/dotcloud/docker/hack/dind
+
 # Add proto docker builder
 add ./dockerbuild.sh /usr/bin/dockerbuild.sh
 run chmod +x /usr/bin/dockerbuild.sh

From 837c6b480c6859db6bf3f3fb044b070afb3f336d Mon Sep 17 00:00:00 2001
From: Daniel Mizyrycki <mzdaniel@glidelink.net>
Date: Tue, 29 Oct 2013 19:37:56 -0700
Subject: [PATCH 051/184] docker-ci 0.37. Patch hack/dind with latest code for
 docker-test. Upstream-commit: efb4c800a7c8167cf2202466a720c0fad7001a5d
 Component: engine

---
 .../infrastructure/docker-ci/docker-test/Dockerfile | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/components/engine/hack/infrastructure/docker-ci/docker-test/Dockerfile b/components/engine/hack/infrastructure/docker-ci/docker-test/Dockerfile
index 66cb9762eb..229d696b87 100644
--- a/components/engine/hack/infrastructure/docker-ci/docker-test/Dockerfile
+++ b/components/engine/hack/infrastructure/docker-ci/docker-test/Dockerfile
@@ -17,13 +17,12 @@
 from docker
 maintainer Daniel Mizyrycki <daniel@dotcloud.com>
 
-# Setup go environment. Extracted from /Dockerfile
-env     CGO_ENABLED 0
-env     GOROOT  /goroot
-env     PATH    $PATH:/goroot/bin
-env     GOPATH  /go:/go/src/github.com/dotcloud/docker/vendor
-volume  /var/lib/docker
-workdir /go/src/github.com/dotcloud/docker
+#### FIXME. Temporarily install docker and dind with proper apparmor handling
+run wget -q -O /go/src/github.com/dotcloud/docker/hack/dind http://raw.github.com/jpetazzo/docker/escape-apparmor-confinement/hack/dind
+run chmod +x /go/src/github.com/dotcloud/docker/hack/dind
+
+# Setup go to the PATH. Extracted from /Dockerfile
+env PATH /usr/local/go/bin:$PATH
 
 # Add test_docker.sh
 add test_docker.sh /usr/bin/test_docker.sh

From 83a4080e0363cdd389311d22ee7e22f08c24aab3 Mon Sep 17 00:00:00 2001
From: Daniel Mizyrycki <mzdaniel@glidelink.net>
Date: Tue, 29 Oct 2013 22:14:28 -0700
Subject: [PATCH 052/184] docker-ci 0.40. Migrate docker-ci to Digital Ocean.
 Upstream-commit: e7df38dbd0c7bf2d27632809fc49cacb0cc7f869 Component: engine

---
 .../hack/infrastructure/docker-ci/Dockerfile  |  12 +-
 .../infrastructure/docker-ci/deployment.py    | 112 ++++++++++--------
 2 files changed, 68 insertions(+), 56 deletions(-)

diff --git a/components/engine/hack/infrastructure/docker-ci/Dockerfile b/components/engine/hack/infrastructure/docker-ci/Dockerfile
index bb49944d1b..3f6c34441d 100644
--- a/components/engine/hack/infrastructure/docker-ci/Dockerfile
+++ b/components/engine/hack/infrastructure/docker-ci/Dockerfile
@@ -1,14 +1,16 @@
 # VERSION:        0.22
 # DOCKER-VERSION  0.6.3
 # AUTHOR:         Daniel Mizyrycki <daniel@dotcloud.com>
-# DESCRIPTION:    Deploy docker-ci on Amazon EC2
+# DESCRIPTION:    Deploy docker-ci on Digital Ocean
 # COMMENTS:
 #     CONFIG_JSON is an environment variable json string loaded as:
 #
 # export CONFIG_JSON='
-#     { "AWS_TAG":             "EC2_instance_name",
-#       "AWS_ACCESS_KEY":      "EC2_access_key",
-#       "AWS_SECRET_KEY":      "EC2_secret_key",
+#     { "DROPLET_NAME":        "docker-ci",
+#       "DO_CLIENT_ID":        "Digital_Ocean_client_id",
+#       "DO_API_KEY":          "Digital_Ocean_api_key",
+#       "DOCKER_KEY_ID":       "Digital_Ocean_ssh_key_id",
+#       "DOCKER_CI_KEY_PATH":  "docker-ci_private_key_path",
 #       "DOCKER_CI_PUB":       "$(cat docker-ci_ssh_public_key.pub)",
 #       "DOCKER_CI_KEY":       "$(cat docker-ci_ssh_private_key.key)",
 #       "BUILDBOT_PWD":        "Buildbot_server_password",
@@ -37,7 +39,7 @@ run echo 'deb http://archive.ubuntu.com/ubuntu precise main universe' \
     > /etc/apt/sources.list
 run apt-get update; apt-get install -y git python2.7 python-dev libevent-dev \
     python-pip ssh rsync less vim
-run pip install boto fabric
+run pip install requests fabric
 
 # Add deployment code and set default container command
 add . /docker-ci
diff --git a/components/engine/hack/infrastructure/docker-ci/deployment.py b/components/engine/hack/infrastructure/docker-ci/deployment.py
index 1a389d2771..ee000eb7ba 100755
--- a/components/engine/hack/infrastructure/docker-ci/deployment.py
+++ b/components/engine/hack/infrastructure/docker-ci/deployment.py
@@ -1,11 +1,11 @@
 #!/usr/bin/env python
 
-import os, sys, re, json, base64
-from boto.ec2.connection import EC2Connection
+import os, sys, re, json, requests, base64
 from subprocess import call
 from fabric import api
 from fabric.api import cd, run, put, sudo
 from os import environ as env
+from datetime import datetime
 from time import sleep
 
 # Remove SSH private key as it needs more processing
@@ -20,42 +20,41 @@ for key in CONFIG:
 env['DOCKER_CI_KEY'] = re.sub('^.+"DOCKER_CI_KEY".+?"(.+?)".+','\\1',
     env['CONFIG_JSON'],flags=re.DOTALL)
 
-
-AWS_TAG = env.get('AWS_TAG','docker-ci')
-AWS_KEY_NAME = 'dotcloud-dev'       # Same as CONFIG_JSON['DOCKER_CI_PUB']
-AWS_AMI = 'ami-d582d6bc'            # Ubuntu 13.04
-AWS_REGION = 'us-east-1'
-AWS_TYPE = 'm1.small'
-AWS_SEC_GROUPS = 'gateway'
-AWS_IMAGE_USER = 'ubuntu'
+DROPLET_NAME = env.get('DROPLET_NAME','docker-ci')
+TIMEOUT = 120            # Seconds before timeout droplet creation
+IMAGE_ID = 1004145       # Docker on Ubuntu 13.04
+REGION_ID = 4            # New York 2
+SIZE_ID = 62             # memory 2GB
+DO_IMAGE_USER = 'root'   # Image user on Digital Ocean
+API_URL = 'https://api.digitalocean.com/'
 DOCKER_PATH = '/go/src/github.com/dotcloud/docker'
 DOCKER_CI_PATH = '/docker-ci'
 CFG_PATH = '{}/buildbot'.format(DOCKER_CI_PATH)
 
 
-class AWS_EC2:
-    '''Amazon EC2'''
-    def __init__(self, access_key, secret_key):
+class digital_ocean():
+
+    def __init__(self, key, client):
         '''Set default API parameters'''
-        self.handler = EC2Connection(access_key, secret_key)
-    def create_instance(self, tag, instance_type):
-        reservation = self.handler.run_instances(**instance_type)
-        instance = reservation.instances[0]
-        sleep(10)
-        while instance.state != 'running':
-            sleep(5)
-            instance.update()
-            print "Instance state: %s" % (instance.state)
-        instance.add_tag("Name",tag)
-        print "instance %s done!" % (instance.id)
-        return instance.ip_address
-    def get_instances(self):
-        return self.handler.get_all_instances()
-    def get_tags(self):
-        return dict([(i.instances[0].id, i.instances[0].tags['Name'])
-            for i in self.handler.get_all_instances() if i.instances[0].tags])
-    def del_instance(self, instance_id):
-        self.handler.terminate_instances(instance_ids=[instance_id])
+        self.key = key
+        self.client = client
+        self.api_url = API_URL
+
+    def api(self, cmd_path, api_arg={}):
+        '''Make api call'''
+        api_arg.update({'api_key':self.key, 'client_id':self.client})
+        resp = requests.get(self.api_url + cmd_path, params=api_arg).text
+        resp = json.loads(resp)
+        if resp['status'] != 'OK':
+            raise Exception(resp['error_message'])
+        return resp
+
+    def droplet_data(self, name):
+        '''Get droplet data'''
+        data = self.api('droplets')
+        data = [droplet for droplet in data['droplets']
+            if droplet['name'] == name]
+        return data[0] if data else {}
 
 
 def json_fmt(data):
@@ -63,20 +62,36 @@ def json_fmt(data):
     return json.dumps(data, sort_keys = True, indent = 2)
 
 
-# Create EC2 API handler
-ec2 = AWS_EC2(env['AWS_ACCESS_KEY'], env['AWS_SECRET_KEY'])
+do = digital_ocean(env['DO_API_KEY'], env['DO_CLIENT_ID'])
 
-# Stop processing if AWS_TAG exists on EC2
-if AWS_TAG in ec2.get_tags().values():
-    print ('Instance: {} already deployed. Not further processing.'
-        .format(AWS_TAG))
+# Get DROPLET_NAME data
+data = do.droplet_data(DROPLET_NAME)
+
+# Stop processing if DROPLET_NAME exists on Digital Ocean
+if data:
+    print ('Droplet: {} already deployed. Not further processing.'
+        .format(DROPLET_NAME))
     exit(1)
 
-ip = ec2.create_instance(AWS_TAG, {'image_id':AWS_AMI, 'instance_type':AWS_TYPE,
-    'security_groups':[AWS_SEC_GROUPS], 'key_name':AWS_KEY_NAME})
+# Create droplet
+do.api('droplets/new', {'name':DROPLET_NAME, 'region_id':REGION_ID,
+    'image_id':IMAGE_ID, 'size_id':SIZE_ID,
+    'ssh_key_ids':[env['DOCKER_KEY_ID']]})
 
-# Wait 30 seconds for the machine to boot
-sleep(30)
+# Wait for droplet to be created.
+start_time = datetime.now()
+while (data.get('status','') != 'active' and (
+ datetime.now()-start_time).seconds < TIMEOUT):
+    data = do.droplet_data(DROPLET_NAME)
+    print data['status']
+    sleep(3)
+
+# Wait for the machine to boot
+sleep(15)
+
+# Get droplet IP
+ip = str(data['ip_address'])
+print 'droplet: {}    ip: {}'.format(DROPLET_NAME, ip)
 
 # Create docker-ci ssh private key so docker-ci docker container can communicate
 # with its EC2 instance
@@ -86,7 +101,7 @@ os.chmod('/root/.ssh/id_rsa',0600)
 open('/root/.ssh/config','w').write('StrictHostKeyChecking no\n')
 
 api.env.host_string = ip
-api.env.user = AWS_IMAGE_USER
+api.env.user = DO_IMAGE_USER
 api.env.key_filename = '/root/.ssh/id_rsa'
 
 # Correct timezone
@@ -106,13 +121,11 @@ open(DOCKER_CI_PATH + '/nightlyrelease/release_credentials.json', 'w').write(
 
 # Transfer docker
 sudo('mkdir -p ' + DOCKER_CI_PATH)
-sudo('chown {}.{} {}'.format(AWS_IMAGE_USER, AWS_IMAGE_USER, DOCKER_CI_PATH))
-call('/usr/bin/rsync -aH {} {}@{}:{}'.format(DOCKER_CI_PATH, AWS_IMAGE_USER, ip,
+sudo('chown {}.{} {}'.format(DO_IMAGE_USER, DO_IMAGE_USER, DOCKER_CI_PATH))
+call('/usr/bin/rsync -aH {} {}@{}:{}'.format(DOCKER_CI_PATH, DO_IMAGE_USER, ip,
     os.path.dirname(DOCKER_CI_PATH)), shell=True)
 
 # Install Docker and Buildbot dependencies
-sudo('addgroup docker')
-sudo('usermod -a -G docker ubuntu')
 sudo('mkdir /mnt/docker; ln -s /mnt/docker /var/lib/docker')
 sudo('wget -q -O - https://get.docker.io/gpg | apt-key add -')
 sudo('echo deb https://get.docker.io/ubuntu docker main >'
@@ -122,7 +135,7 @@ sudo('echo -e "deb http://archive.ubuntu.com/ubuntu raring main universe\n'
     ' > /etc/apt/sources.list; apt-get update')
 sudo('DEBIAN_FRONTEND=noninteractive apt-get install -q -y wget python-dev'
     ' python-pip supervisor git mercurial linux-image-extra-$(uname -r)'
-    ' aufs-tools make libfontconfig libevent-dev')
+    ' aufs-tools make libfontconfig libevent-dev libsqlite3-dev libssl-dev')
 sudo('wget -O - https://go.googlecode.com/files/go1.1.2.linux-amd64.tar.gz | '
     'tar -v -C /usr/local -xz; ln -s /usr/local/go/bin/go /usr/bin/go')
 sudo('GOPATH=/go go get -d github.com/dotcloud/docker')
@@ -137,9 +150,6 @@ sudo('curl -s https://phantomjs.googlecode.com/files/'
 # Preventively reboot docker-ci daily
 sudo('ln -s /sbin/reboot /etc/cron.daily')
 
-# Preventively reboot docker-ci daily
-sudo('ln -s /sbin/reboot /etc/cron.daily')
-
 # Build docker-ci containers
 sudo('cd {}; docker build -t docker .'.format(DOCKER_PATH))
 sudo('cd {}; docker build -t docker-ci .'.format(DOCKER_CI_PATH))

From ba4e682cde6ad56a7fe88c5e61c976e1db93338b Mon Sep 17 00:00:00 2001
From: Daniel Mizyrycki <mzdaniel@glidelink.net>
Date: Wed, 6 Nov 2013 20:05:26 -0800
Subject: [PATCH 053/184] docker-ci 0.4.5: Sync tests with progress in docker
 and docker-registry. Use revamped shiny DinD. Upstream-commit:
 249f76bebdb3c24ae0a59e3be7ae73fd1d88c065 Component: engine

---
 components/engine/.gitignore                       |  1 +
 .../hack/infrastructure/docker-ci/Dockerfile       |  6 +++---
 .../engine/hack/infrastructure/docker-ci/VERSION   |  1 +
 .../hack/infrastructure/docker-ci/deployment.py    | 10 +++++-----
 .../docker-ci/docker-test/Dockerfile               | 14 +++++---------
 .../docker-ci/docker-test/test_docker.sh           |  8 ++++++--
 .../docker-ci/functionaltests/test_registry.sh     |  2 +-
 .../docker-ci/nightlyrelease/Dockerfile            | 13 ++++---------
 .../docker-ci/nightlyrelease/dockerbuild.sh        |  2 +-
 .../docker-ci/registry-coverage/Dockerfile         |  2 +-
 .../registry-coverage/registry_coverage.sh         |  8 ++++----
 .../infrastructure/docker-ci/report/deployment.py  |  2 +-
 12 files changed, 33 insertions(+), 36 deletions(-)
 create mode 100644 components/engine/hack/infrastructure/docker-ci/VERSION

diff --git a/components/engine/.gitignore b/components/engine/.gitignore
index 8cf66168eb..00d66de3ed 100644
--- a/components/engine/.gitignore
+++ b/components/engine/.gitignore
@@ -18,3 +18,4 @@ bundles/
 .hg/
 .git/
 vendor/pkg/
+pyenv
diff --git a/components/engine/hack/infrastructure/docker-ci/Dockerfile b/components/engine/hack/infrastructure/docker-ci/Dockerfile
index 3f6c34441d..d894330ffa 100644
--- a/components/engine/hack/infrastructure/docker-ci/Dockerfile
+++ b/components/engine/hack/infrastructure/docker-ci/Dockerfile
@@ -1,6 +1,6 @@
-# VERSION:        0.22
-# DOCKER-VERSION  0.6.3
-# AUTHOR:         Daniel Mizyrycki <daniel@dotcloud.com>
+# VERSION:        0.25
+# DOCKER-VERSION  0.6.6
+# AUTHOR:         Daniel Mizyrycki <daniel@docker.com>
 # DESCRIPTION:    Deploy docker-ci on Digital Ocean
 # COMMENTS:
 #     CONFIG_JSON is an environment variable json string loaded as:
diff --git a/components/engine/hack/infrastructure/docker-ci/VERSION b/components/engine/hack/infrastructure/docker-ci/VERSION
new file mode 100644
index 0000000000..0bfccb0804
--- /dev/null
+++ b/components/engine/hack/infrastructure/docker-ci/VERSION
@@ -0,0 +1 @@
+0.4.5
diff --git a/components/engine/hack/infrastructure/docker-ci/deployment.py b/components/engine/hack/infrastructure/docker-ci/deployment.py
index ee000eb7ba..c04219d523 100755
--- a/components/engine/hack/infrastructure/docker-ci/deployment.py
+++ b/components/engine/hack/infrastructure/docker-ci/deployment.py
@@ -32,7 +32,7 @@ DOCKER_CI_PATH = '/docker-ci'
 CFG_PATH = '{}/buildbot'.format(DOCKER_CI_PATH)
 
 
-class digital_ocean():
+class DigitalOcean():
 
     def __init__(self, key, client):
         '''Set default API parameters'''
@@ -62,7 +62,7 @@ def json_fmt(data):
     return json.dumps(data, sort_keys = True, indent = 2)
 
 
-do = digital_ocean(env['DO_API_KEY'], env['DO_CLIENT_ID'])
+do = DigitalOcean(env['DO_API_KEY'], env['DO_CLIENT_ID'])
 
 # Get DROPLET_NAME data
 data = do.droplet_data(DROPLET_NAME)
@@ -147,9 +147,6 @@ sudo('curl -s https://phantomjs.googlecode.com/files/'
     'phantomjs-1.9.1-linux-x86_64.tar.bz2 | tar jx -C /usr/bin'
     ' --strip-components=2 phantomjs-1.9.1-linux-x86_64/bin/phantomjs')
 
-# Preventively reboot docker-ci daily
-sudo('ln -s /sbin/reboot /etc/cron.daily')
-
 # Build docker-ci containers
 sudo('cd {}; docker build -t docker .'.format(DOCKER_PATH))
 sudo('cd {}; docker build -t docker-ci .'.format(DOCKER_CI_PATH))
@@ -169,3 +166,6 @@ sudo('{0}/setup.sh root {0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10}'
     env['SMTP_PWD'], env['EMAIL_RCP'], env['REGISTRY_USER'],
     env['REGISTRY_PWD'], env['REGISTRY_BUCKET'], env['REGISTRY_ACCESS_KEY'],
     env['REGISTRY_SECRET_KEY']))
+
+# Preventively reboot docker-ci daily
+sudo('ln -s /sbin/reboot /etc/cron.daily')
diff --git a/components/engine/hack/infrastructure/docker-ci/docker-test/Dockerfile b/components/engine/hack/infrastructure/docker-ci/docker-test/Dockerfile
index 229d696b87..0f3a63f5f1 100644
--- a/components/engine/hack/infrastructure/docker-ci/docker-test/Dockerfile
+++ b/components/engine/hack/infrastructure/docker-ci/docker-test/Dockerfile
@@ -1,6 +1,6 @@
-# VERSION:        0.3
-# DOCKER-VERSION  0.6.3
-# AUTHOR:         Daniel Mizyrycki <daniel@dotcloud.com>
+# VERSION:        0.4
+# DOCKER-VERSION  0.6.6
+# AUTHOR:         Daniel Mizyrycki <daniel@docker.com>
 # DESCRIPTION:    Testing docker PRs and commits on top of master using
 # REFERENCES:     This code reuses the excellent implementation of
 #                 Docker in Docker made by Jerome Petazzoni.
@@ -15,13 +15,9 @@
 # TO_RUN:         docker run -privileged test_docker hack/dind test_docker.sh [commit] [repo] [branch]
 
 from docker
-maintainer Daniel Mizyrycki <daniel@dotcloud.com>
+maintainer Daniel Mizyrycki <daniel@docker.com>
 
-#### FIXME. Temporarily install docker and dind with proper apparmor handling
-run wget -q -O /go/src/github.com/dotcloud/docker/hack/dind http://raw.github.com/jpetazzo/docker/escape-apparmor-confinement/hack/dind
-run chmod +x /go/src/github.com/dotcloud/docker/hack/dind
-
-# Setup go to the PATH. Extracted from /Dockerfile
+# Setup go in PATH. Extracted from /Dockerfile
 env PATH /usr/local/go/bin:$PATH
 
 # Add test_docker.sh
diff --git a/components/engine/hack/infrastructure/docker-ci/docker-test/test_docker.sh b/components/engine/hack/infrastructure/docker-ci/docker-test/test_docker.sh
index c8cfe147e6..cf8fdb90bb 100755
--- a/components/engine/hack/infrastructure/docker-ci/docker-test/test_docker.sh
+++ b/components/engine/hack/infrastructure/docker-ci/docker-test/test_docker.sh
@@ -8,6 +8,10 @@ BRANCH=${3-master}
 # Compute test paths
 DOCKER_PATH=/go/src/github.com/dotcloud/docker
 
+# Timestamp
+echo
+date; echo
+
 # Fetch latest master
 cd /
 rm -rf /go
@@ -16,13 +20,13 @@ cd $DOCKER_PATH
 
 # Merge commit
 git fetch -q "$REPO" "$BRANCH"
-git merge --no-edit $COMMIT || exit 1
+git merge --no-edit $COMMIT || exit 255
 
 # Test commit
 ./hack/make.sh test; exit_status=$?
 
 # Display load if test fails
-if [ $exit_status -eq 1 ] ; then
+if [ $exit_status -ne 0 ] ; then
     uptime; echo; free
 fi
 
diff --git a/components/engine/hack/infrastructure/docker-ci/functionaltests/test_registry.sh b/components/engine/hack/infrastructure/docker-ci/functionaltests/test_registry.sh
index d175f66d16..58642529cc 100755
--- a/components/engine/hack/infrastructure/docker-ci/functionaltests/test_registry.sh
+++ b/components/engine/hack/infrastructure/docker-ci/functionaltests/test_registry.sh
@@ -8,6 +8,7 @@ rm -rf docker-registry
 # Setup the environment
 export SETTINGS_FLAVOR=test
 export DOCKER_REGISTRY_CONFIG=config_test.yml
+export PYTHONPATH=$(pwd)/docker-registry/test
 
 # Get latest docker registry
 git clone -q https://github.com/dotcloud/docker-registry.git
@@ -21,7 +22,6 @@ pip install -q tox
 
 # Run registry tests
 tox || exit 1
-export PYTHONPATH=$(pwd)/docker-registry
 python -m unittest discover -p s3.py -s test || exit 1
 python -m unittest discover -p workflow.py -s test
 
diff --git a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile
index 6762cb4686..2100a9e8e9 100644
--- a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile
+++ b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/Dockerfile
@@ -1,6 +1,6 @@
-# VERSION:        1.5
-# DOCKER-VERSION  0.6.4
-# AUTHOR:         Daniel Mizyrycki <daniel@dotcloud.com>
+# VERSION:        1.6
+# DOCKER-VERSION  0.6.6
+# AUTHOR:         Daniel Mizyrycki <daniel@docker.com>
 # DESCRIPTION:    Build docker nightly release using Docker in Docker.
 # REFERENCES:     This code reuses the excellent implementation of docker in docker
 #                 made by Jerome Petazzoni.  https://github.com/jpetazzo/dind
@@ -13,7 +13,7 @@
 # TO_RELEASE:     docker run -i -t -privileged -e AWS_S3_BUCKET="test.docker.io" dockerbuilder hack/dind dockerbuild.sh
 
 from docker
-maintainer Daniel Mizyrycki <daniel@dotcloud.com>
+maintainer Daniel Mizyrycki <daniel@docker.com>
 
 # Add docker dependencies and downloading packages
 run echo 'deb http://archive.ubuntu.com/ubuntu precise main universe' > /etc/apt/sources.list
@@ -22,11 +22,6 @@ run apt-get update; apt-get install -y -q wget python2.7
 # Add production docker binary
 run wget -q -O /usr/bin/docker http://get.docker.io/builds/Linux/x86_64/docker-latest; chmod +x /usr/bin/docker
 
-#### FIXME. Temporarily install docker and dind with proper apparmor handling
-run wget -q -O /usr/bin/docker http://test.docker.io/test/docker; chmod +x /usr/bin/docker
-run wget -q -O /go/src/github.com/dotcloud/docker/hack/dind http://raw.github.com/jpetazzo/docker/escape-apparmor-confinement/hack/dind
-run chmod +x /go/src/github.com/dotcloud/docker/hack/dind
-
 # Add proto docker builder
 add ./dockerbuild.sh /usr/bin/dockerbuild.sh
 run chmod +x /usr/bin/dockerbuild.sh
diff --git a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild.sh b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild.sh
index 457db3f889..80caaec25e 100644
--- a/components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild.sh
+++ b/components/engine/hack/infrastructure/docker-ci/nightlyrelease/dockerbuild.sh
@@ -34,7 +34,7 @@ exit_status=$?
 
 # Display load if test fails
 set -x
-if [ $exit_status -eq 1 ] ; then
+if [ $exit_status -ne 0 ] ; then
     uptime; echo; free
     exit 1
 fi
diff --git a/components/engine/hack/infrastructure/docker-ci/registry-coverage/Dockerfile b/components/engine/hack/infrastructure/docker-ci/registry-coverage/Dockerfile
index 59c914fb2b..e544645b67 100644
--- a/components/engine/hack/infrastructure/docker-ci/registry-coverage/Dockerfile
+++ b/components/engine/hack/infrastructure/docker-ci/registry-coverage/Dockerfile
@@ -11,7 +11,7 @@ maintainer Daniel Mizyrycki <daniel@dotcloud.com>
 
 # Add registry_coverager.sh and dependencies
 run pip install coverage flask pyyaml requests simplejson python-glanceclient \
-    blinker redis gevent
+    blinker redis boto gevent rsa mock
 add registry_coverage.sh /usr/bin/registry_coverage.sh
 run chmod +x /usr/bin/registry_coverage.sh
 
diff --git a/components/engine/hack/infrastructure/docker-ci/registry-coverage/registry_coverage.sh b/components/engine/hack/infrastructure/docker-ci/registry-coverage/registry_coverage.sh
index e9f0172651..e16cea8e3c 100755
--- a/components/engine/hack/infrastructure/docker-ci/registry-coverage/registry_coverage.sh
+++ b/components/engine/hack/infrastructure/docker-ci/registry-coverage/registry_coverage.sh
@@ -2,8 +2,11 @@
 
 set -x
 
-# Compute test paths
+# Setup the environment
 REGISTRY_PATH=/data/docker-registry
+export SETTINGS_FLAVOR=test
+export DOCKER_REGISTRY_CONFIG=config_test.yml
+export PYTHONPATH=$REGISTRY_PATH/test
 
 # Fetch latest docker-registry master
 rm -rf $REGISTRY_PATH
@@ -11,8 +14,5 @@ git clone https://github.com/dotcloud/docker-registry -b master $REGISTRY_PATH
 cd $REGISTRY_PATH
 
 # Generate coverage
-export SETTINGS_FLAVOR=test
-export DOCKER_REGISTRY_CONFIG=config_test.yml
-
 coverage run -m unittest discover test || exit 1
 coverage report --include='./*' --omit='./test/*'
diff --git a/components/engine/hack/infrastructure/docker-ci/report/deployment.py b/components/engine/hack/infrastructure/docker-ci/report/deployment.py
index d5efb4a960..5b2eaf3cab 100755
--- a/components/engine/hack/infrastructure/docker-ci/report/deployment.py
+++ b/components/engine/hack/infrastructure/docker-ci/report/deployment.py
@@ -34,7 +34,7 @@ env['DOCKER_CI_KEY'] = open(env['DOCKER_CI_KEY_PATH']).read()
 
 DROPLET_NAME = env.get('DROPLET_NAME','report')
 TIMEOUT = 120            # Seconds before timeout droplet creation
-IMAGE_ID = 894856        # Docker on Ubuntu 13.04
+IMAGE_ID = 1004145       # Docker on Ubuntu 13.04
 REGION_ID = 4            # New York 2
 SIZE_ID = 66             # memory 512MB
 DO_IMAGE_USER = 'root'   # Image user on Digital Ocean

From 9fe27fc82518da45c4886678eb5aaedb62a2d26c Mon Sep 17 00:00:00 2001
From: Andy Rothfusz <github@metaliveblog.com>
Date: Thu, 7 Nov 2013 12:20:23 -0800
Subject: [PATCH 054/184] Fix 2585 and clean up warning in contributing.rst
 Upstream-commit: 97c3de7e6b92b13efa30c5c840ce2fab07b8794e Component: engine

---
 .../engine/docs/sources/api/remote_api_client_libraries.rst   | 2 ++
 components/engine/docs/sources/contributing/contributing.rst  | 4 ++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/components/engine/docs/sources/api/remote_api_client_libraries.rst b/components/engine/docs/sources/api/remote_api_client_libraries.rst
index bd8610eaf1..8243d02c80 100644
--- a/components/engine/docs/sources/api/remote_api_client_libraries.rst
+++ b/components/engine/docs/sources/api/remote_api_client_libraries.rst
@@ -35,3 +35,5 @@ and we will add the libraries here.
 +----------------------+----------------+--------------------------------------------+
 | Go                   | go-dockerclient| https://github.com/fsouza/go-dockerclient  |
 +----------------------+----------------+--------------------------------------------+
+| PHP                  | Alvine         | http://pear.alvine.io/ (alpha)             |
++----------------------+----------------+--------------------------------------------+
diff --git a/components/engine/docs/sources/contributing/contributing.rst b/components/engine/docs/sources/contributing/contributing.rst
index 3cdb0b6f14..f4a6b472ff 100644
--- a/components/engine/docs/sources/contributing/contributing.rst
+++ b/components/engine/docs/sources/contributing/contributing.rst
@@ -10,13 +10,13 @@ Want to hack on Docker? Awesome!
 The repository includes `all the instructions you need to get
 started <https://github.com/dotcloud/docker/blob/master/CONTRIBUTING.md>`_.
 
-The developer environment `Dockerfile <https://github.com/dotcloud/docker/blob/master/Dockerfile>`_
+The `developer environment Dockerfile <https://github.com/dotcloud/docker/blob/master/Dockerfile>`_
 specifies the tools and versions used to test and build Docker.
 
 If you're making changes to the documentation, see the
 `README.md <https://github.com/dotcloud/docker/blob/master/docs/README.md>`_.
 
-The documentation environment `Dockerfile <https://github.com/dotcloud/docker/blob/master/docs/Dockerfile>`_
+The `documentation environment Dockerfile <https://github.com/dotcloud/docker/blob/master/docs/Dockerfile>`_
 specifies the tools and versions used to build the Documentation.
 
 Further interesting details can be found in the `Packaging hints <https://github.com/dotcloud/docker/blob/master/hack/PACKAGERS.md>`_.

From b5fe937fc97111aa19b628499645edd0608c74af Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Thu, 7 Nov 2013 12:23:29 -0800
Subject: [PATCH 055/184] fix Assign id as name when all else fails
 Upstream-commit: 26f846bf779c97a69e85db356dff8c1fff76161c Component: engine

---
 components/engine/runtime.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/components/engine/runtime.go b/components/engine/runtime.go
index 0ef6786b21..671694fce5 100644
--- a/components/engine/runtime.go
+++ b/components/engine/runtime.go
@@ -286,13 +286,12 @@ func (runtime *Runtime) restore() error {
 	// Any containers that are left over do not exist in the graph
 	for _, container := range containers {
 		// Try to set the default name for a container if it exists prior to links
-		name, err := generateRandomName(runtime)
+		container.Name, err = generateRandomName(runtime)
 		if err != nil {
 			container.Name = container.ShortID()
 		}
-		container.Name = name
 
-		if _, err := runtime.containerGraph.Set(name, container.ID); err != nil {
+		if _, err := runtime.containerGraph.Set(container.Name, container.ID); err != nil {
 			utils.Debugf("Setting default id - %s", err)
 		}
 		register(container)

From 6d241424236f7887bc5bd8853f0e55ed3d2d816f Mon Sep 17 00:00:00 2001
From: "Guillaume J. Charmes" <charmes.guillaume@gmail.com>
Date: Thu, 7 Nov 2013 12:19:24 -0800
Subject: [PATCH 056/184] go fmt Upstream-commit:
 6998c3c387518ba8e06ceff00b10be583c95d6cd Component: engine

---
 components/engine/config.go                   |  2 +-
 components/engine/container.go                |  6 +-
 components/engine/docker/docker.go            |  2 +-
 components/engine/engine/engine.go            | 28 +++++----
 components/engine/engine/init_test.go         | 10 ++--
 components/engine/engine/job.go               | 58 +++++++++----------
 .../engine/namesgenerator/names-generator.go  |  2 +-
 components/engine/netlink/netlink_darwin.go   |  2 -
 components/engine/utils/daemon.go             |  2 +-
 components/engine/utils/random.go             |  2 +-
 components/engine/utils/utils.go              |  4 +-
 components/engine/utils/utils_test.go         | 26 ++++-----
 components/engine/utils_test.go               |  2 +-
 13 files changed, 71 insertions(+), 75 deletions(-)

diff --git a/components/engine/config.go b/components/engine/config.go
index 40c47e692c..42ae23a90f 100644
--- a/components/engine/config.go
+++ b/components/engine/config.go
@@ -1,8 +1,8 @@
 package docker
 
 import (
-	"net"
 	"github.com/dotcloud/docker/engine"
+	"net"
 )
 
 // FIXME: separate runtime configuration from http api configuration
diff --git a/components/engine/container.go b/components/engine/container.go
index 50bf2ec674..8238628131 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -394,9 +394,9 @@ func (container *Container) Inject(file io.Reader, pth string) error {
 	if _, err := os.Stat(path.Join(container.rwPath(), pth)); err == nil {
 		// Since err is nil, the path could be stat'd and it exists
 		return fmt.Errorf("%s exists", pth)
-	} else if ! os.IsNotExist(err) {
+	} else if !os.IsNotExist(err) {
 		// Expect err might be that the file doesn't exist, so
-		// if it's some other error, return that. 
+		// if it's some other error, return that.
 
 		return err
 	}
@@ -1086,7 +1086,7 @@ func (container *Container) allocateNetwork() error {
 				Gateway: manager.bridgeNetwork.IP,
 				manager: manager,
 			}
-			if iface !=nil && iface.IPNet.IP != nil {
+			if iface != nil && iface.IPNet.IP != nil {
 				ipNum := ipToInt(iface.IPNet.IP)
 				manager.ipAllocator.inUse[ipNum] = struct{}{}
 			} else {
diff --git a/components/engine/docker/docker.go b/components/engine/docker/docker.go
index c500633a71..877e7f67d0 100644
--- a/components/engine/docker/docker.go
+++ b/components/engine/docker/docker.go
@@ -4,9 +4,9 @@ import (
 	"flag"
 	"fmt"
 	"github.com/dotcloud/docker"
+	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/sysinit"
 	"github.com/dotcloud/docker/utils"
-	"github.com/dotcloud/docker/engine"
 	"log"
 	"os"
 	"strings"
diff --git a/components/engine/engine/engine.go b/components/engine/engine/engine.go
index 8d67242ca2..10cc077253 100644
--- a/components/engine/engine/engine.go
+++ b/components/engine/engine/engine.go
@@ -2,13 +2,12 @@ package engine
 
 import (
 	"fmt"
-	"os"
-	"log"
-	"runtime"
 	"github.com/dotcloud/docker/utils"
+	"log"
+	"os"
+	"runtime"
 )
 
-
 type Handler func(*Job) string
 
 var globalHandlers map[string]Handler
@@ -25,8 +24,8 @@ func Register(name string, handler Handler) error {
 // It acts as a store for *containers*, and allows manipulation of these
 // containers by executing *jobs*.
 type Engine struct {
-	root		string
-	handlers	map[string]Handler
+	root     string
+	handlers map[string]Handler
 }
 
 // New initializes a new engine managing the directory specified at `root`.
@@ -56,8 +55,8 @@ func New(root string) (*Engine, error) {
 		return nil, err
 	}
 	eng := &Engine{
-		root:		root,
-		handlers:	globalHandlers,
+		root:     root,
+		handlers: globalHandlers,
 	}
 	return eng, nil
 }
@@ -66,12 +65,12 @@ func New(root string) (*Engine, error) {
 // This function mimics `Command` from the standard os/exec package.
 func (eng *Engine) Job(name string, args ...string) *Job {
 	job := &Job{
-		eng:		eng,
-		Name:		name,
-		Args:		args,
-		Stdin:		os.Stdin,
-		Stdout:		os.Stdout,
-		Stderr:		os.Stderr,
+		eng:    eng,
+		Name:   name,
+		Args:   args,
+		Stdin:  os.Stdin,
+		Stdout: os.Stdout,
+		Stderr: os.Stderr,
 	}
 	handler, exists := eng.handlers[name]
 	if exists {
@@ -79,4 +78,3 @@ func (eng *Engine) Job(name string, args ...string) *Job {
 	}
 	return job
 }
-
diff --git a/components/engine/engine/init_test.go b/components/engine/engine/init_test.go
index 5c03ded87d..48d9009171 100644
--- a/components/engine/engine/init_test.go
+++ b/components/engine/engine/init_test.go
@@ -1,18 +1,18 @@
 package engine
 
 import (
-	"testing"
+	"fmt"
+	"github.com/dotcloud/docker/utils"
+	"io/ioutil"
 	"runtime"
 	"strings"
-	"fmt"
-	"io/ioutil"
-	"github.com/dotcloud/docker/utils"
+	"testing"
 )
 
 var globalTestID string
 
 func init() {
-	Register("dummy", func(job *Job) string { return ""; })
+	Register("dummy", func(job *Job) string { return "" })
 }
 
 func mkEngine(t *testing.T) *Engine {
diff --git a/components/engine/engine/job.go b/components/engine/engine/job.go
index 0bde2a0beb..c2b14d55c2 100644
--- a/components/engine/engine/job.go
+++ b/components/engine/engine/job.go
@@ -1,11 +1,11 @@
 package engine
 
 import (
+	"encoding/json"
+	"fmt"
+	"github.com/dotcloud/docker/utils"
 	"io"
 	"strings"
-	"fmt"
-	"encoding/json"
-	"github.com/dotcloud/docker/utils"
 )
 
 // A job is the fundamental unit of work in the docker engine.
@@ -20,17 +20,17 @@ import (
 // One slight variation is that jobs report their status as a string. The
 // string "0" indicates success, and any other strings indicates an error.
 // This allows for richer error reporting.
-// 
+//
 type Job struct {
-	eng	*Engine
-	Name	string
-	Args	[]string
-	env	[]string
-	Stdin	io.ReadCloser
-	Stdout	io.WriteCloser
-	Stderr	io.WriteCloser
-	handler	func(*Job) string
-	status	string
+	eng     *Engine
+	Name    string
+	Args    []string
+	env     []string
+	Stdin   io.ReadCloser
+	Stdout  io.WriteCloser
+	Stderr  io.WriteCloser
+	handler func(*Job) string
+	status  string
 }
 
 // Run executes the job and blocks until the job completes.
@@ -57,21 +57,21 @@ func (job *Job) String() string {
 }
 
 func (job *Job) Getenv(key string) (value string) {
-        for _, kv := range job.env {
-                if strings.Index(kv, "=") == -1 {
-                        continue
-                }
-                parts := strings.SplitN(kv, "=", 2)
-                if parts[0] != key {
-                        continue
-                }
-                if len(parts) < 2 {
-                        value = ""
-                } else {
-                        value = parts[1]
-                }
-        }
-        return
+	for _, kv := range job.env {
+		if strings.Index(kv, "=") == -1 {
+			continue
+		}
+		parts := strings.SplitN(kv, "=", 2)
+		if parts[0] != key {
+			continue
+		}
+		if len(parts) < 2 {
+			value = ""
+		} else {
+			value = parts[1]
+		}
+	}
+	return
 }
 
 func (job *Job) GetenvBool(key string) (value bool) {
@@ -109,5 +109,5 @@ func (job *Job) SetenvList(key string, value []string) error {
 }
 
 func (job *Job) Setenv(key, value string) {
-	job.env = append(job.env, key + "=" + value)
+	job.env = append(job.env, key+"="+value)
 }
diff --git a/components/engine/namesgenerator/names-generator.go b/components/engine/namesgenerator/names-generator.go
index 076bb1cba7..c0dd26830c 100644
--- a/components/engine/namesgenerator/names-generator.go
+++ b/components/engine/namesgenerator/names-generator.go
@@ -12,7 +12,7 @@ type NameChecker interface {
 
 var (
 	colors  = [...]string{"white", "silver", "gray", "black", "blue", "green", "cyan", "yellow", "gold", "orange", "brown", "red", "violet", "pink", "magenta", "purple", "maroon", "crimson", "plum", "fuchsia", "lavender", "slate", "navy", "azure", "aqua", "olive", "teal", "lime", "beige", "tan", "sienna"}
-  animals = [...]string{"ant", "bear", "bird", "cat", "chicken", "cow", "deer", "dog", "donkey", "duck", "fish", "fox", "frog", "horse", "kangaroo", "koala", "lemur", "lion", "lizard", "monkey", "octopus", "pig", "shark", "sheep", "sloth", "spider", "squirrel", "tiger", "toad", "weasel", "whale", "wolf"}
+	animals = [...]string{"ant", "bear", "bird", "cat", "chicken", "cow", "deer", "dog", "donkey", "duck", "fish", "fox", "frog", "horse", "kangaroo", "koala", "lemur", "lion", "lizard", "monkey", "octopus", "pig", "shark", "sheep", "sloth", "spider", "squirrel", "tiger", "toad", "weasel", "whale", "wolf"}
 )
 
 func GenerateRandomName(checker NameChecker) (string, error) {
diff --git a/components/engine/netlink/netlink_darwin.go b/components/engine/netlink/netlink_darwin.go
index becfb87759..9a972fe63f 100644
--- a/components/engine/netlink/netlink_darwin.go
+++ b/components/engine/netlink/netlink_darwin.go
@@ -9,7 +9,6 @@ func NetworkGetRoutes() ([]*net.IPNet, error) {
 	return nil, fmt.Errorf("Not implemented")
 }
 
-
 func NetworkLinkAdd(name string, linkType string) error {
 	return fmt.Errorf("Not implemented")
 }
@@ -18,7 +17,6 @@ func NetworkLinkUp(iface *net.Interface) error {
 	return fmt.Errorf("Not implemented")
 }
 
-
 func NetworkLinkAddIp(iface *net.Interface, ip net.IP, ipNet *net.IPNet) error {
 	return fmt.Errorf("Not implemented")
 }
diff --git a/components/engine/utils/daemon.go b/components/engine/utils/daemon.go
index 179ff90e10..871122ed59 100644
--- a/components/engine/utils/daemon.go
+++ b/components/engine/utils/daemon.go
@@ -1,10 +1,10 @@
 package utils
 
 import (
-	"os"
 	"fmt"
 	"io/ioutil"
 	"log"
+	"os"
 	"strconv"
 )
 
diff --git a/components/engine/utils/random.go b/components/engine/utils/random.go
index d5c37e44d0..d4d33c690a 100644
--- a/components/engine/utils/random.go
+++ b/components/engine/utils/random.go
@@ -1,9 +1,9 @@
 package utils
 
 import (
-	"io"
 	"crypto/rand"
 	"encoding/hex"
+	"io"
 )
 
 func RandomString() string {
diff --git a/components/engine/utils/utils.go b/components/engine/utils/utils.go
index 4941eae42d..152c41d86c 100644
--- a/components/engine/utils/utils.go
+++ b/components/engine/utils/utils.go
@@ -15,8 +15,8 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"runtime"
 	"regexp"
+	"runtime"
 	"strconv"
 	"strings"
 	"sync"
@@ -904,7 +904,7 @@ func StripComments(input []byte, commentMarker []byte) []byte {
 	return output
 }
 
-// GetNameserversAsCIDR returns nameservers (if any) listed in 
+// GetNameserversAsCIDR returns nameservers (if any) listed in
 // /etc/resolv.conf as CIDR blocks (e.g., "1.2.3.4/32")
 // This function's output is intended for net.ParseCIDR
 func GetNameserversAsCIDR(resolvConf []byte) []string {
diff --git a/components/engine/utils/utils_test.go b/components/engine/utils/utils_test.go
index f10bb40d3b..5377c181c4 100644
--- a/components/engine/utils/utils_test.go
+++ b/components/engine/utils/utils_test.go
@@ -453,20 +453,20 @@ search example.com`: {"1.2.3.4/32", "4.3.2.1/32"},
 		`search example.com`: {},
 		`nameserver 1.2.3.4
 search example.com
-nameserver 4.3.2.1`: []string{"1.2.3.4/32", "4.3.2.1/32"},
-    ``: []string{},
-    `  nameserver 1.2.3.4   `: []string{"1.2.3.4/32"},
-    `search example.com
+nameserver 4.3.2.1`: {"1.2.3.4/32", "4.3.2.1/32"},
+		``: {},
+		`  nameserver 1.2.3.4   `: {"1.2.3.4/32"},
+		`search example.com
 nameserver 1.2.3.4
-#nameserver 4.3.2.1`: []string{"1.2.3.4/32"},
-    `search example.com
-nameserver 1.2.3.4 # not 4.3.2.1`: []string{"1.2.3.4/32"},
-    } {
-        test := GetNameserversAsCIDR([]byte(resolv))
-        if !StrSlicesEqual(test, result) {
-            t.Fatalf("Wrong nameserver string {%s} should be %v. Input: %s", test, result, resolv)
-        }
-    }
+#nameserver 4.3.2.1`: {"1.2.3.4/32"},
+		`search example.com
+nameserver 1.2.3.4 # not 4.3.2.1`: {"1.2.3.4/32"},
+	} {
+		test := GetNameserversAsCIDR([]byte(resolv))
+		if !StrSlicesEqual(test, result) {
+			t.Fatalf("Wrong nameserver string {%s} should be %v. Input: %s", test, result, resolv)
+		}
+	}
 }
 
 func StrSlicesEqual(a, b []string) bool {
diff --git a/components/engine/utils_test.go b/components/engine/utils_test.go
index 14cbd7c6be..87426f38ea 100644
--- a/components/engine/utils_test.go
+++ b/components/engine/utils_test.go
@@ -67,7 +67,7 @@ func newTestRuntime(prefix string) (runtime *Runtime, err error) {
 	}
 
 	config := &DaemonConfig{
-		Root:   root,
+		Root:        root,
 		AutoRestart: false,
 	}
 	runtime, err = NewRuntimeFromDirectory(config)

From c81beb4bbc1304af17f188064b69e0ea7cdbeb72 Mon Sep 17 00:00:00 2001
From: Roberto Gandolfo Hashioka <roberto_hashioka@hotmail.com>
Date: Thu, 7 Nov 2013 14:06:49 -0800
Subject: [PATCH 057/184] - Fix the attach examples according to the new attach
 behavior - Add the option of adding the user to docker's group and avoid the
 usage of "sudo" before each command Upstream-commit:
 304d39cc505ff51682dd7e1337f9f0ab7536eec3 Component: engine

---
 components/engine/docs/sources/examples/hello_world.rst    | 3 ++-
 components/engine/docs/sources/examples/python_web_app.rst | 5 +++--
 .../engine/docs/sources/examples/running_ssh_service.rst   | 3 ++-
 components/engine/docs/sources/use/basics.rst              | 7 +++++++
 4 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/components/engine/docs/sources/examples/hello_world.rst b/components/engine/docs/sources/examples/hello_world.rst
index 6d6c1b28a6..d6f75de09c 100644
--- a/components/engine/docs/sources/examples/hello_world.rst
+++ b/components/engine/docs/sources/examples/hello_world.rst
@@ -127,10 +127,11 @@ Check the logs make sure it is working correctly.
 
     sudo docker attach $CONTAINER_ID
 
-Attach to the container to see the results in realtime.
+Attach to the container to see the results in real-time.
 
 - **"docker attach**" This will allow us to attach to a background
   process to see what is going on.
+- **"-sig-proxy=true" Proxify all received signal to the process (even in non-tty mode)
 - **$CONTAINER_ID** The Id of the container we want to attach too.
 
 Exit from the container attachment by pressing Control-C.
diff --git a/components/engine/docs/sources/examples/python_web_app.rst b/components/engine/docs/sources/examples/python_web_app.rst
index c707fcdec6..71e7ae4e08 100644
--- a/components/engine/docs/sources/examples/python_web_app.rst
+++ b/components/engine/docs/sources/examples/python_web_app.rst
@@ -39,11 +39,12 @@ container. The ``BUILD_JOB`` environment variable will be set with the new conta
 
 .. code-block:: bash
 
-    sudo docker attach $BUILD_JOB
+    sudo docker attach -sig-proxy=false $BUILD_JOB
     [...]
 
 While this container is running, we can attach to the new container to
-see what is going on. You can use Ctrl-C to disconnect.
+see what is going on. The flag ``-sig-proxy`` set as ``false`` allows you to connect and
+disconnect (Ctrl-C) to it without stopping the container.
 
 .. code-block:: bash
 
diff --git a/components/engine/docs/sources/examples/running_ssh_service.rst b/components/engine/docs/sources/examples/running_ssh_service.rst
index 59a80fbf6e..e0d406bc0e 100644
--- a/components/engine/docs/sources/examples/running_ssh_service.rst
+++ b/components/engine/docs/sources/examples/running_ssh_service.rst
@@ -21,7 +21,8 @@ smooth, but gives you a good idea.
    daemon is unprotected and available via a TCP port. When you run
    through the same steps in a newer version of Docker, you will
    need to add ``sudo`` in front of each ``docker`` command in order
-   to reach the daemon over its protected Unix socket.
+   to reach the daemon over its protected Unix socket or you can add
+   your user to docker's group: ``sudo usermod -a -G docker <user>``.
 
 .. raw:: html
 
diff --git a/components/engine/docs/sources/use/basics.rst b/components/engine/docs/sources/use/basics.rst
index 0097b6836d..8773fa9492 100644
--- a/components/engine/docs/sources/use/basics.rst
+++ b/components/engine/docs/sources/use/basics.rst
@@ -54,6 +54,13 @@ the daemon starts. The ``docker`` daemon must always run as root, but
 if you run the ``docker`` client as a user in the *docker* group then
 you don't need to add ``sudo`` to all the client commands.
 
+Alternative to ``sudo``?
+-------------
+
+You can add your current ``<username>`` to docker's group and get rid of
+``sudo`` before each ``docker`` command. You just need to type:
+``$ sudo usermod -a -G docker <username>``
+
 .. code-block:: bash
 
   # Add the docker group

From 07f796bd964dc308e5c1d97595456ef5b9c22ac6 Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Fri, 1 Nov 2013 18:29:25 -0500
Subject: [PATCH 058/184] network: add iptables rules to explicitly allow
 forwarding

Explicitly enable container networking for Fedora and other distros that
have a REJECT all rule at the end of their FORWARD table.
Upstream-commit: ec4657b28a3e97447921357d454df974e0979ac6
Component: engine
---
 components/engine/AUTHORS    |  1 +
 components/engine/network.go | 38 ++++++++++++++++++++++++++++++------
 2 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/components/engine/AUTHORS b/components/engine/AUTHORS
index 64f2ce21aa..d002104e82 100644
--- a/components/engine/AUTHORS
+++ b/components/engine/AUTHORS
@@ -94,6 +94,7 @@ Jonathan Rudenberg <jonathan@titanous.com>
 Joost Cassee <joost@cassee.net>
 Jordan Arentsen <blissdev@gmail.com>
 Joseph Anthony Pasquale Holsten <joseph@josephholsten.com>
+Josh Poimboeuf <jpoimboe@redhat.com>
 Julien Barbier <write0@gmail.com>
 Jérôme Petazzoni <jerome.petazzoni@dotcloud.com>
 Karan Lyons <karan@karanlyons.com>
diff --git a/components/engine/network.go b/components/engine/network.go
index 638fd94de0..3864cca8cd 100644
--- a/components/engine/network.go
+++ b/components/engine/network.go
@@ -168,12 +168,28 @@ func CreateBridgeIface(config *DaemonConfig) error {
 	}
 
 	if config.EnableIptables {
+		// Enable NAT
 		if output, err := iptables.Raw("-t", "nat", "-A", "POSTROUTING", "-s", ifaceAddr,
 			"!", "-d", ifaceAddr, "-j", "MASQUERADE"); err != nil {
 			return fmt.Errorf("Unable to enable network bridge NAT: %s", err)
 		} else if len(output) != 0 {
 			return fmt.Errorf("Error iptables postrouting: %s", output)
 		}
+
+		// Accept incoming packets for existing connections
+		if output, err := iptables.Raw("-I", "FORWARD", "-o", config.BridgeIface, "-m", "conntrack", "--ctstate", "RELATED,ESTABLISHED", "-j", "ACCEPT"); err != nil {
+			return fmt.Errorf("Unable to allow incoming packets: %s", err)
+		} else if len(output) != 0 {
+			return fmt.Errorf("Error iptables allow incoming: %s", output)
+		}
+
+		// Accept all non-intercontainer outgoing packets
+		if output, err := iptables.Raw("-I", "FORWARD", "-i", config.BridgeIface, "!", "-o", config.BridgeIface, "-j", "ACCEPT"); err != nil {
+			return fmt.Errorf("Unable to allow outgoing packets: %s", err)
+		} else if len(output) != 0 {
+			return fmt.Errorf("Error iptables allow outgoing: %s", output)
+		}
+
 	}
 	return nil
 }
@@ -680,20 +696,30 @@ func newNetworkManager(config *DaemonConfig) (*NetworkManager, error) {
 
 	// Configure iptables for link support
 	if config.EnableIptables {
-		args := []string{"FORWARD", "-i", config.BridgeIface, "-o", config.BridgeIface, "-j", "DROP"}
+		args := []string{"FORWARD", "-i", config.BridgeIface, "-o", config.BridgeIface, "-j"}
+		acceptArgs := append(args, "ACCEPT")
+		dropArgs := append(args, "DROP")
 
 		if !config.InterContainerCommunication {
-			if !iptables.Exists(args...) {
+			iptables.Raw(append([]string{"-D"}, acceptArgs...)...)
+			if !iptables.Exists(dropArgs...) {
 				utils.Debugf("Disable inter-container communication")
-				if output, err := iptables.Raw(append([]string{"-A"}, args...)...); err != nil {
+				if output, err := iptables.Raw(append([]string{"-I"}, dropArgs...)...); err != nil {
 					return nil, fmt.Errorf("Unable to prevent intercontainer communication: %s", err)
 				} else if len(output) != 0 {
-					return nil, fmt.Errorf("Error enabling iptables: %s", output)
+					return nil, fmt.Errorf("Error disabling intercontainer communication: %s", output)
 				}
 			}
 		} else {
-			utils.Debugf("Enable inter-container communication")
-			iptables.Raw(append([]string{"-D"}, args...)...)
+			iptables.Raw(append([]string{"-D"}, dropArgs...)...)
+			if !iptables.Exists(acceptArgs...) {
+				utils.Debugf("Enable inter-container communication")
+				if output, err := iptables.Raw(append([]string{"-I"}, acceptArgs...)...); err != nil {
+					return nil, fmt.Errorf("Unable to allow intercontainer communication: %s", err)
+				} else if len(output) != 0 {
+					return nil, fmt.Errorf("Error enabling intercontainer communication: %s", output)
+				}
+			}
 		}
 	}
 

From ce1bb0ce731fe44c5569fb3529e8550e4756dd1a Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Thu, 7 Nov 2013 14:31:25 -0800
Subject: [PATCH 059/184] fix mergeConfig with new ports Upstream-commit:
 49c4231f077cb0b4804768231396c596d070a22f Component: engine

---
 components/engine/utils.go      |  9 +++++++++
 components/engine/utils_test.go | 28 ++++++++++++++++++++++++++--
 2 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/components/engine/utils.go b/components/engine/utils.go
index 81715881ae..1393a5c0a8 100644
--- a/components/engine/utils.go
+++ b/components/engine/utils.go
@@ -89,6 +89,15 @@ func MergeConfig(userConf, imageConf *Config) error {
 	}
 	if userConf.ExposedPorts == nil || len(userConf.ExposedPorts) == 0 {
 		userConf.ExposedPorts = imageConf.ExposedPorts
+	} else if imageConf.ExposedPorts != nil {
+		if userConf.ExposedPorts == nil {
+			userConf.ExposedPorts = make(map[Port]struct{})
+		}
+		for port := range imageConf.ExposedPorts {
+			if _, exists := userConf.ExposedPorts[port]; !exists {
+				userConf.ExposedPorts[port] = struct{}{}
+			}
+		}
 	}
 
 	if userConf.PortSpecs != nil && len(userConf.PortSpecs) > 0 {
diff --git a/components/engine/utils_test.go b/components/engine/utils_test.go
index 87426f38ea..589cd405ea 100644
--- a/components/engine/utils_test.go
+++ b/components/engine/utils_test.go
@@ -247,7 +247,9 @@ func TestMergeConfig(t *testing.T) {
 		Volumes:   volumesUser,
 	}
 
-	MergeConfig(configUser, configImage)
+	if err := MergeConfig(configUser, configImage); err != nil {
+		t.Error(err)
+	}
 
 	if len(configUser.Dns) != 3 {
 		t.Fatalf("Expected 3 dns, 1.1.1.1, 2.2.2.2 and 3.3.3.3, found %d", len(configUser.Dns))
@@ -259,7 +261,7 @@ func TestMergeConfig(t *testing.T) {
 	}
 
 	if len(configUser.ExposedPorts) != 3 {
-		t.Fatalf("Expected 3 portSpecs, 1111, 2222 and 3333, found %d", len(configUser.PortSpecs))
+		t.Fatalf("Expected 3 ExposedPorts, 1111, 2222 and 3333, found %d", len(configUser.ExposedPorts))
 	}
 	for portSpecs := range configUser.ExposedPorts {
 		if portSpecs.Port() != "1111" && portSpecs.Port() != "2222" && portSpecs.Port() != "3333" {
@@ -287,6 +289,28 @@ func TestMergeConfig(t *testing.T) {
 	if configUser.VolumesFrom != "1111" {
 		t.Fatalf("Expected VolumesFrom to be 1111, found %s", configUser.VolumesFrom)
 	}
+
+	ports, _, err := parsePortSpecs([]string{"0000"})
+	if err != nil {
+		t.Error(err)
+	}
+	configImage2 := &Config{
+		ExposedPorts: ports,
+	}
+
+	if err := MergeConfig(configUser, configImage2); err != nil {
+		t.Error(err)
+	}
+
+	if len(configUser.ExposedPorts) != 4 {
+		t.Fatalf("Expected 4 ExposedPorts, 0000, 1111, 2222 and 3333, found %d", len(configUser.ExposedPorts))
+	}
+	for portSpecs := range configUser.ExposedPorts {
+		if portSpecs.Port() != "0000" && portSpecs.Port() != "1111" && portSpecs.Port() != "2222" && portSpecs.Port() != "3333" {
+			t.Fatalf("Expected 0000 or 1111 or 2222 or 3333, found %s", portSpecs)
+		}
+	}
+
 }
 
 func TestParseLxcConfOpt(t *testing.T) {

From 163d4a5b8fc0afc02fcd1705d5fbba1169715512 Mon Sep 17 00:00:00 2001
From: Roberto Gandolfo Hashioka <roberto_hashioka@hotmail.com>
Date: Thu, 7 Nov 2013 14:44:07 -0800
Subject: [PATCH 060/184] - Included the sudo alternative as an example_header
 Upstream-commit: eba3c36b386f389953eda6315948577200c9bf2c Component: engine

---
 components/engine/docs/sources/examples/example_header.inc  | 6 ++++++
 .../engine/docs/sources/examples/running_ssh_service.rst    | 3 +--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/components/engine/docs/sources/examples/example_header.inc b/components/engine/docs/sources/examples/example_header.inc
index 607421fc13..7d0feddeb9 100644
--- a/components/engine/docs/sources/examples/example_header.inc
+++ b/components/engine/docs/sources/examples/example_header.inc
@@ -2,3 +2,9 @@
 .. note::
     
     This example assumes you have Docker running in daemon mode. For more information please see :ref:`running_examples`
+
+.. note::
+
+   These examples use ``sudo`` before each ``docker`` command you could also
+   add your current ``<username>`` to docker's group and get rid of ``sudo``.
+   You just need to type: ``$ sudo usermod -a -G docker <username>``
diff --git a/components/engine/docs/sources/examples/running_ssh_service.rst b/components/engine/docs/sources/examples/running_ssh_service.rst
index e0d406bc0e..59a80fbf6e 100644
--- a/components/engine/docs/sources/examples/running_ssh_service.rst
+++ b/components/engine/docs/sources/examples/running_ssh_service.rst
@@ -21,8 +21,7 @@ smooth, but gives you a good idea.
    daemon is unprotected and available via a TCP port. When you run
    through the same steps in a newer version of Docker, you will
    need to add ``sudo`` in front of each ``docker`` command in order
-   to reach the daemon over its protected Unix socket or you can add
-   your user to docker's group: ``sudo usermod -a -G docker <user>``.
+   to reach the daemon over its protected Unix socket.
 
 .. raw:: html
 

From d03901e0ad057a2978368972bc2bd9b782875560 Mon Sep 17 00:00:00 2001
From: Sven Dowideit <SvenDowideit@home.org.au>
Date: Tue, 22 Oct 2013 21:48:10 +1000
Subject: [PATCH 061/184] Closes #2328 - allow the user to specify a string
 timestamp (not just a unix epoch) in the string format that the docker cli
 shows to the user Upstream-commit: 01fea3cf116b768720b542ab65cbd1c2695848d0
 Component: engine

---
 components/engine/commands.go                 | 14 +++++++++++--
 .../engine/docs/sources/commandline/cli.rst   | 20 +++++++++++++++++++
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index d41f0f86b8..00be9a60e1 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1387,7 +1387,7 @@ func (cli *DockerCli) CmdCommit(args ...string) error {
 
 func (cli *DockerCli) CmdEvents(args ...string) error {
 	cmd := Subcmd("events", "[OPTIONS]", "Get real time events from the server")
-	since := cmd.String("since", "", "Show events previously created (used for polling).")
+	since := cmd.String("since", "", "Show previously created events and then stream.")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -1399,7 +1399,17 @@ func (cli *DockerCli) CmdEvents(args ...string) error {
 
 	v := url.Values{}
 	if *since != "" {
-		v.Set("since", *since)
+		loc := time.FixedZone(time.Now().Zone())
+		format := "2006-01-02 15:04:05 -0700 MST"
+		if len(*since) < len(format) {
+			format = format[:len(*since)]
+		}
+
+		if t, err := time.ParseInLocation(format, *since, loc); err == nil {
+			v.Set("since", strconv.FormatInt(t.Unix(), 10))
+		} else {
+			v.Set("since", *since)
+		}
 	}
 
 	if err := cli.stream("GET", "/events?"+v.Encode(), nil, cli.out, nil); err != nil {
diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 6d56bccc38..d6e47d1787 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -245,6 +245,9 @@ Full -run example
     Usage: docker events
 
     Get real time events from the server
+    
+    -since="": Show previously created events and then stream.
+               (either seconds since epoch, or date string as below)
 
 .. _cli_events_example:
 
@@ -277,6 +280,23 @@ Shell 1: (Again .. now showing events)
     [2013-09-03 15:49:29 +0200 CEST] 4386fb97867d: (from 12de384bfb10) die
     [2013-09-03 15:49:29 +0200 CEST] 4386fb97867d: (from 12de384bfb10) stop
 
+Show events in the past from a specified time
+.............................................
+
+.. code-block:: bash
+
+    $ sudo docker events -since 1378216169
+    [2013-09-03 15:49:29 +0200 CEST] 4386fb97867d: (from 12de384bfb10) die
+    [2013-09-03 15:49:29 +0200 CEST] 4386fb97867d: (from 12de384bfb10) stop
+
+    $ sudo docker events -since '2013-09-03'
+    [2013-09-03 15:49:26 +0200 CEST] 4386fb97867d: (from 12de384bfb10) start
+    [2013-09-03 15:49:29 +0200 CEST] 4386fb97867d: (from 12de384bfb10) die
+    [2013-09-03 15:49:29 +0200 CEST] 4386fb97867d: (from 12de384bfb10) stop
+
+    $ sudo docker events -since '2013-09-03 15:49:29 +0200 CEST'
+    [2013-09-03 15:49:29 +0200 CEST] 4386fb97867d: (from 12de384bfb10) die
+    [2013-09-03 15:49:29 +0200 CEST] 4386fb97867d: (from 12de384bfb10) stop
 
 .. _cli_export:
 

From 600bb37cb7415f1e383152f07dfd31893e310f35 Mon Sep 17 00:00:00 2001
From: "Guillaume J. Charmes" <charmes.guillaume@gmail.com>
Date: Thu, 7 Nov 2013 17:30:51 -0800
Subject: [PATCH 062/184] Deprecate old tagging format Upstream-commit:
 ef57752bce5c333d0e2b8352a84d071f21cce132 Component: engine

---
 components/engine/commands.go | 35 +++++++++++++++++++++++++++++------
 1 file changed, 29 insertions(+), 6 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index 00be9a60e1..12cc713654 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -913,8 +913,16 @@ func (cli *DockerCli) CmdImport(args ...string) error {
 		cmd.Usage()
 		return nil
 	}
-	src := cmd.Arg(0)
-	repository, tag := utils.ParseRepositoryTag(cmd.Arg(1))
+
+	var src, repository, tag string
+
+	if cmd.NArg() == 3 {
+		fmt.Fprintf(cli.err, "[DEPRECATED] The format 'URL|- [REPOSITORY [TAG]]' as been deprecated. Please use URL|- [REPOSITORY[:TAG]]\n")
+		src, repository, tag = cmd.Arg(0), cmd.Arg(1), cmd.Arg(2)
+	} else {
+		src = cmd.Arg(0)
+		repository, tag = utils.ParseRepositoryTag(cmd.Arg(1))
+	}
 	v := url.Values{}
 	v.Set("repo", repository)
 	v.Set("tag", tag)
@@ -1349,8 +1357,16 @@ func (cli *DockerCli) CmdCommit(args ...string) error {
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
-	name := cmd.Arg(0)
-	repository, tag := utils.ParseRepositoryTag(cmd.Arg(1))
+
+	var name, repository, tag string
+
+	if cmd.NArg() == 3 {
+		fmt.Fprintf(cli.err, "[DEPRECATED] The format 'CONTAINER [REPOSITORY [TAG]]' as been deprecated. Please use CONTAINER [REPOSITORY[:TAG]]\n")
+		name, repository, tag = cmd.Arg(0), cmd.Arg(1), cmd.Arg(2)
+	} else {
+		name = cmd.Arg(0)
+		repository, tag = utils.ParseRepositoryTag(cmd.Arg(1))
+	}
 
 	if name == "" {
 		cmd.Usage()
@@ -1666,9 +1682,16 @@ func (cli *DockerCli) CmdTag(args ...string) error {
 		return nil
 	}
 
-	v := url.Values{}
-	repository, tag := utils.ParseRepositoryTag(cmd.Arg(1))
+	var repository, tag string
 
+	if cmd.NArg() == 3 {
+		fmt.Fprintf(cli.err, "[DEPRECATED] The format 'IMAGE [REPOSITORY [TAG]]' as been deprecated. Please use IMAGE [REPOSITORY[:TAG]]\n")
+		repository, tag = cmd.Arg(1), cmd.Arg(2)
+	} else {
+		repository, tag = utils.ParseRepositoryTag(cmd.Arg(1))
+	}
+
+	v := url.Values{}
 	v.Set("repo", repository)
 	v.Set("tag", tag)
 

From b89c66d72483cc552d7fb0d00b8050e2c5787e75 Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Thu, 7 Nov 2013 18:54:00 -0800
Subject: [PATCH 063/184] prevent panic if you use API in a wrong way
 Upstream-commit: 49d7b87cfc4385470a5ecf181f92c13b8391c002 Component: engine

---
 components/engine/container.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index 6cf35ec70e..419ba84d29 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -133,7 +133,11 @@ type PortBinding struct {
 type Port string
 
 func (p Port) Proto() string {
-	return strings.Split(string(p), "/")[1]
+	parts := strings.Split(string(p), "/")
+	if len(parts) == 1 {
+		return "tcp"
+	}
+	return parts[1]
 }
 
 func (p Port) Port() string {

From 5090a5bd4b9472a450d86afe70b74f2aa3c180a0 Mon Sep 17 00:00:00 2001
From: David Sissitka <me@dsissitka.com>
Date: Fri, 20 Sep 2013 04:55:17 -0400
Subject: [PATCH 064/184] Make "docker insert" errors obvious

Closes #1130
See also #1942
Upstream-commit: 5957dd909134fc3c3dc3e165b83559feb89d9f5b
Component: engine
---
 components/engine/api.go      |  9 +++------
 components/engine/commands.go |  5 +----
 components/engine/server.go   | 20 ++++++++++----------
 3 files changed, 14 insertions(+), 20 deletions(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index 61252ab9af..8f31ab0282 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -479,15 +479,12 @@ func postImagesInsert(srv *Server, version float64, w http.ResponseWriter, r *ht
 		w.Header().Set("Content-Type", "application/json")
 	}
 	sf := utils.NewStreamFormatter(version > 1.0)
-	imgID, err := srv.ImageInsert(name, url, path, w, sf)
+	err := srv.ImageInsert(name, url, path, w, sf)
 	if err != nil {
-		if sf.Used() {
-			w.Write(sf.FormatError(err))
-			return nil
-		}
+		w.Write(sf.FormatError(err))
 	}
 
-	return writeJSON(w, http.StatusOK, &APIID{ID: imgID})
+	return nil
 }
 
 func postImagesPush(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
diff --git a/components/engine/commands.go b/components/engine/commands.go
index 00be9a60e1..1dc82e3bdc 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -130,10 +130,7 @@ func (cli *DockerCli) CmdInsert(args ...string) error {
 	v.Set("url", cmd.Arg(1))
 	v.Set("path", cmd.Arg(2))
 
-	if err := cli.stream("POST", "/images/"+cmd.Arg(0)+"/insert?"+v.Encode(), nil, cli.out, nil); err != nil {
-		return err
-	}
-	return nil
+	return cli.stream("POST", "/images/"+cmd.Arg(0)+"/insert?"+v.Encode(), nil, cli.out, nil)
 }
 
 // mkBuildContext returns an archive of an empty context with the contents
diff --git a/components/engine/server.go b/components/engine/server.go
index 3441029027..eb4e74e0bf 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -198,39 +198,39 @@ func (srv *Server) ImagesSearch(term string) ([]registry.SearchResult, error) {
 	return results.Results, nil
 }
 
-func (srv *Server) ImageInsert(name, url, path string, out io.Writer, sf *utils.StreamFormatter) (string, error) {
+func (srv *Server) ImageInsert(name, url, path string, out io.Writer, sf *utils.StreamFormatter) error {
 	out = utils.NewWriteFlusher(out)
 	img, err := srv.runtime.repositories.LookupImage(name)
 	if err != nil {
-		return "", err
+		return err
 	}
 
 	file, err := utils.Download(url, out)
 	if err != nil {
-		return "", err
+		return err
 	}
 	defer file.Body.Close()
 
 	config, _, _, err := ParseRun([]string{img.ID, "echo", "insert", url, path}, srv.runtime.capabilities)
 	if err != nil {
-		return "", err
+		return err
 	}
 
 	c, _, err := srv.runtime.Create(config, "")
 	if err != nil {
-		return "", err
+		return err
 	}
 
-	if err := c.Inject(utils.ProgressReader(file.Body, int(file.ContentLength), out, sf.FormatProgress("", "Downloading", "%8v/%v (%v)"), sf, true), path); err != nil {
-		return "", err
+	if err := c.Inject(utils.ProgressReader(file.Body, int(file.ContentLength), out, sf.FormatProgress("", "Downloading", "%8v/%v (%v)"), sf, false), path); err != nil {
+		return err
 	}
 	// FIXME: Handle custom repo, tag comment, author
 	img, err = srv.runtime.Commit(c, "", "", img.Comment, img.Author, nil)
 	if err != nil {
-		return "", err
+		return err
 	}
-	out.Write(sf.FormatStatus("", img.ID))
-	return img.ShortID(), nil
+	out.Write(sf.FormatStatus(utils.TruncateID(img.ID), "Image created"))
+	return nil
 }
 
 func (srv *Server) ImagesViz(out io.Writer) error {

From 807e6a9bd8bce9cf23ddb3e8ec8a6a6e8f5935d4 Mon Sep 17 00:00:00 2001
From: Mark Allen <mrallen1@yahoo.com>
Date: Thu, 7 Nov 2013 23:34:54 -0600
Subject: [PATCH 065/184] Add ImageInsert tests Upstream-commit:
 bf8e0277bbd1c2df2310bc20ecc4003d1ed7a657 Component: engine

---
 components/engine/server_test.go | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/components/engine/server_test.go b/components/engine/server_test.go
index 4072344f35..3376eebd6e 100644
--- a/components/engine/server_test.go
+++ b/components/engine/server_test.go
@@ -3,6 +3,7 @@ package docker
 import (
 	"github.com/dotcloud/docker/utils"
 	"strings"
+	"io/ioutil"
 	"testing"
 	"time"
 )
@@ -521,3 +522,25 @@ func TestImagesFilter(t *testing.T) {
 		t.Fatal("incorrect number of matches returned")
 	}
 }
+
+func TestImageInsert(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+	srv := &Server{runtime: runtime}
+	sf := utils.NewStreamFormatter(true)
+
+	// bad image name fails
+	if err := srv.ImageInsert("foo", "https://www.docker.io/static/img/docker-top-logo.png", "/foo", ioutil.Discard, sf); err == nil {
+		t.Fatal("expected an error and got none")
+	}
+
+	// bad url fails
+	if err := srv.ImageInsert(GetTestImage(runtime).ID, "http://bad_host_name_that_will_totally_fail.com/", "/foo", ioutil.Discard, sf); err == nil {
+		t.Fatal("expected an error and got none")
+	}
+
+	// success returns nil
+	if err := srv.ImageInsert(GetTestImage(runtime).ID, "https://www.docker.io/static/img/docker-top-logo.png", "/foo", ioutil.Discard, sf); err != nil {
+		t.Fatalf("expected no error, but got %v", err)
+	}
+}

From e5498d2e589bb020deb9078c3e1cc65ee07ad882 Mon Sep 17 00:00:00 2001
From: Michael Stapelberg <michael+gh@stapelberg.de>
Date: Fri, 8 Nov 2013 22:52:10 +0100
Subject: [PATCH 066/184] =?UTF-8?q?Return=20=E2=80=9Cerr=E2=80=9D=20instea?=
 =?UTF-8?q?d=20of=20=E2=80=9Cnil=E2=80=9D=20when=20MkdirAll()=20fails=20wh?=
 =?UTF-8?q?en=20binding=20a=20volume=20Upstream-commit:=20e7fdcc15c5eb3812?=
 =?UTF-8?q?c71dd61f22a8d77d3ae72e36=20Component:=20engine?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 components/engine/container.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index 419ba84d29..f9247eccc8 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -837,7 +837,7 @@ func (container *Container) Start() (err error) {
 		// Create the mountpoint
 		rootVolPath := path.Join(container.RootfsPath(), volPath)
 		if err := os.MkdirAll(rootVolPath, 0755); err != nil {
-			return nil
+			return err
 		}
 
 		// Do not copy or change permissions if we are mounting from the host

From 8e910346a3edca75fb93c5cf83ac25c4e6e7ec0c Mon Sep 17 00:00:00 2001
From: Sean Cronin <seancron@gmail.com>
Date: Fri, 8 Nov 2013 17:17:39 -0500
Subject: [PATCH 067/184] Removes duplicate changelog entry Upstream-commit:
 ca174ae84d37d89af726fa41e25a11bdaeca2067 Component: engine

---
 components/engine/CHANGELOG.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/components/engine/CHANGELOG.md b/components/engine/CHANGELOG.md
index f5c9617463..8c08cefaad 100644
--- a/components/engine/CHANGELOG.md
+++ b/components/engine/CHANGELOG.md
@@ -17,7 +17,6 @@
 + Prevent DNS server conflicts in CreateBridgeIface
 + Validate bind mounts on the server side
 + Use parent image config in docker build
-* Fix regression in /etc/hosts
 
 #### Client
 

From 67c8d19777b74f65ff03bca146138af34fcd6c6b Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Fri, 8 Nov 2013 16:28:41 -0600
Subject: [PATCH 068/184] setup network when reconnecting to ghost container

Re-adding the line to setup the network when reconnecting to a ghost
container.  It was inadvertently removed by commit
31638ab2ad2a5380d447780f05f7aa078c9421f5.
Upstream-commit: 2448058ee23292e2a167bbd6a2e138ad99e8b3b8
Component: engine
---
 components/engine/runtime.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/engine/runtime.go b/components/engine/runtime.go
index 671694fce5..581f6a8d83 100644
--- a/components/engine/runtime.go
+++ b/components/engine/runtime.go
@@ -172,6 +172,7 @@ func (runtime *Runtime) Register(container *Container) error {
 	if !container.State.Running {
 		close(container.waitLock)
 	} else if !nomonitor {
+		container.allocateNetwork()
 		go container.monitor()
 	}
 	return nil

From db48d3cf28e87c98d7cc6844385f2962ec5bb426 Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Fri, 8 Nov 2013 15:44:52 -0700
Subject: [PATCH 069/184] Update release script with proper support for
 non-*.docker.io bucket URLs Upstream-commit:
 b8e7ec1b74fdeaeab56a8ffab801dcd87b7361ca Component: engine

---
 components/engine/hack/release.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/hack/release.sh b/components/engine/hack/release.sh
index 56538ea70a..23718dd63d 100755
--- a/components/engine/hack/release.sh
+++ b/components/engine/hack/release.sh
@@ -107,7 +107,7 @@ s3_url() {
 			echo "https://$BUCKET"
 			;;
 		*)
-			echo "http://$BUCKET.s3.amazonaws.com"
+			s3cmd ws-info s3://$BUCKET | awk -v 'FS=: +' '/http:\/\/'$BUCKET'/ { gsub(/\/+$/, "", $2); print $2 }'
 			;;
 	esac
 }

From 0ed69503c99279c624b8f63a252a71c7f8427b88 Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Fri, 8 Nov 2013 15:45:18 -0700
Subject: [PATCH 070/184] Update release script to move
 https://get.docker.io/ubuntu/info to https://get.docker.io/ubuntu/ and
 provide a backwards-compatibility redirect (same for /builds/info)
 Upstream-commit: f56945d71bcce6e7d18b3471bf4744ddd70b1783 Component: engine

---
 components/engine/hack/release.sh | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/components/engine/hack/release.sh b/components/engine/hack/release.sh
index 23718dd63d..06b76a1c7a 100755
--- a/components/engine/hack/release.sh
+++ b/components/engine/hack/release.sh
@@ -114,7 +114,7 @@ s3_url() {
 
 # Upload the 'ubuntu' bundle to S3:
 # 1. A full APT repository is published at $BUCKET/ubuntu/
-# 2. Instructions for using the APT repository are uploaded at $BUCKET/ubuntu/info
+# 2. Instructions for using the APT repository are uploaded at $BUCKET/ubuntu/index
 release_ubuntu() {
 	[ -e bundles/$VERSION/ubuntu ] || {
 		echo >&2 './hack/make.sh must be run before release_ubuntu'
@@ -168,7 +168,7 @@ EOF
 
 	# Upload repo
 	s3cmd --acl-public sync $APTDIR/ s3://$BUCKET/ubuntu/
-	cat <<EOF | write_to_s3 s3://$BUCKET/ubuntu/info
+	cat <<EOF | write_to_s3 s3://$BUCKET/ubuntu/index
 # Add the repository to your APT sources
 echo deb $(s3_url)/ubuntu docker main > /etc/apt/sources.list.d/docker.list
 # Then import the repository key
@@ -180,7 +180,12 @@ apt-get update ; apt-get install -y lxc-docker
 # Alternatively, just use the curl-able install.sh script provided at $(s3_url)
 #
 EOF
-	echo "APT repository uploaded. Instructions available at $(s3_url)/ubuntu/info"
+
+	# Add redirect at /ubuntu/info for URL-backwards-compatibility
+	rm -rf /tmp/emptyfile && touch /tmp/emptyfile
+	s3cmd --acl-public --add-header='x-amz-website-redirect-location:/ubuntu/' --mime-type='text/plain' put /tmp/emptyfile s3://$BUCKET/ubuntu/info
+
+	echo "APT repository uploaded. Instructions available at $(s3_url)/ubuntu"
 }
 
 # Upload a static binary to S3
@@ -189,14 +194,20 @@ release_binary() {
 		echo >&2 './hack/make.sh must be run before release_binary'
 		exit 1
 	}
+
 	S3DIR=s3://$BUCKET/builds/Linux/x86_64
 	s3cmd --acl-public put bundles/$VERSION/binary/docker-$VERSION $S3DIR/docker-$VERSION
-	cat <<EOF | write_to_s3 s3://$BUCKET/builds/info
+	cat <<EOF | write_to_s3 s3://$BUCKET/builds/index
 # To install, run the following command as root:
 curl -O $(s3_url)/builds/Linux/x86_64/docker-$VERSION && chmod +x docker-$VERSION && sudo mv docker-$VERSION /usr/local/bin/docker
 # Then start docker in daemon mode:
 sudo /usr/local/bin/docker -d
 EOF
+
+	# Add redirect at /builds/info for URL-backwards-compatibility
+	rm -rf /tmp/emptyfile && touch /tmp/emptyfile
+	s3cmd --acl-public --add-header='x-amz-website-redirect-location:/builds/' --mime-type='text/plain' put /tmp/emptyfile s3://$BUCKET/builds/info
+
 	if [ -z "$NOLATEST" ]; then
 		echo "Copying docker-$VERSION to docker-latest"
 		s3cmd --acl-public cp $S3DIR/docker-$VERSION $S3DIR/docker-latest

From edd84b853d5b5876e86a371deba7a9661e88e645 Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Fri, 8 Nov 2013 15:01:01 -0800
Subject: [PATCH 071/184] prevent deletion if image is used by a running
 container Upstream-commit: 45c2b5dc1a0d8f3658f012844f9d89fbb2290c42
 Component: engine

---
 components/engine/server.go | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/components/engine/server.go b/components/engine/server.go
index 3441029027..ceb3401f1d 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -1257,6 +1257,26 @@ func (srv *Server) ImageDelete(name string, autoPrune bool) ([]APIRmi, error) {
 		}
 		return nil, nil
 	}
+
+	// Prevent deletion if image is used by a running container
+	for _, container := range srv.runtime.List() {
+		if container.State.Running {
+			parent, err := srv.runtime.repositories.LookupImage(container.Image)
+			if err != nil {
+				return nil, err
+			}
+
+			if err := parent.WalkHistory(func(p *Image) error {
+				if img.ID == p.ID {
+					return fmt.Errorf("Conflict, cannot delete %s because the running container %s is using it", name, container.ID)
+				}
+				return nil
+			}); err != nil {
+				return nil, err
+			}
+		}
+	}
+
 	if strings.Contains(img.ID, name) {
 		//delete via ID
 		return srv.deleteImage(img, "", "")

From 1fdd529660efab480c11fd9fe01d2717d8cdec48 Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Fri, 8 Nov 2013 15:41:45 -0700
Subject: [PATCH 072/184] Update ubuntu packaging script, especially to stop
 docker group deletion Upstream-commit:
 498b6031b12da56c442d7c2b501f500766652b2d Component: engine

---
 components/engine/hack/make/ubuntu | 70 ++++++++++++++++++++++--------
 1 file changed, 51 insertions(+), 19 deletions(-)

diff --git a/components/engine/hack/make/ubuntu b/components/engine/hack/make/ubuntu
index 5834172fd1..d4b9fd0b30 100644
--- a/components/engine/hack/make/ubuntu
+++ b/components/engine/hack/make/ubuntu
@@ -10,7 +10,7 @@ fi
 PACKAGE_ARCHITECTURE="$(dpkg-architecture -qDEB_HOST_ARCH)"
 PACKAGE_URL="http://www.docker.io/"
 PACKAGE_MAINTAINER="docker@dotcloud.com"
-PACKAGE_DESCRIPTION="lxc-docker is a Linux container runtime
+PACKAGE_DESCRIPTION="Linux container runtime
 Docker complements LXC with a high-level API which operates at the process
 level. It runs unix processes with strong guarantees of isolation and
 repeatability across servers.
@@ -37,27 +37,51 @@ bundle_ubuntu() {
 	# This will fail if the binary bundle hasn't been built
 	cp $DEST/../binary/docker-$VERSION $DIR/usr/bin/docker
 
-	# Generate postinst/prerm scripts
-	cat >/tmp/postinst <<'EOF'
+	# Generate postinst/prerm/postrm scripts
+	cat > /tmp/postinst <<'EOF'
 #!/bin/sh
-service docker stop || true
-grep -q '^docker:' /etc/group || groupadd --system docker || true
-service docker start
-EOF
-	cat >/tmp/prerm <<'EOF'
-#!/bin/sh
-service docker stop || true
+set -e
+set -u
 
-case "$1" in
-	purge|remove|abort-install)
-		groupdel docker || true
-		;;
-		
-	upgrade|failed-upgrade|abort-upgrade)
-		# don't touch docker group
-		;;
-esac
+getent group docker > /dev/null || groupadd --system docker || true
+
+update-rc.d docker defaults > /dev/null || true
+if [ -n "$2" ]; then
+	_dh_action=restart
+else
+	_dh_action=start
+fi
+service docker $_dh_action 2>/dev/null || true
+
+#DEBHELPER#
 EOF
+	cat > /tmp/prerm <<'EOF'
+#!/bin/sh
+set -e
+set -u
+
+service docker stop 2>/dev/null || true
+
+#DEBHELPER#
+EOF
+	cat > /tmp/postrm <<'EOF'
+#!/bin/sh
+set -e
+set -u
+
+if [ "$1" = "purge" ] ; then
+	update-rc.d docker remove > /dev/null || true
+fi
+
+# In case this system is running systemd, we make systemd reload the unit files
+# to pick up changes.
+if [ -d /run/systemd/system ] ; then
+	systemctl --system daemon-reload > /dev/null || true
+fi
+
+#DEBHELPER#
+EOF
+	# TODO swaths of these were borrowed from debhelper's auto-inserted stuff, because we're still using fpm - we need to use debhelper instead, and somehow reconcile Ubuntu that way
 	chmod +x /tmp/postinst /tmp/prerm
 
 	(
@@ -66,6 +90,7 @@ EOF
 		    --name lxc-docker-$VERSION --version $PKGVERSION \
 		    --after-install /tmp/postinst \
 		    --before-remove /tmp/prerm \
+		    --after-remove /tmp/postrm \
 		    --architecture "$PACKAGE_ARCHITECTURE" \
 		    --prefix / \
 		    --depends lxc \
@@ -82,6 +107,8 @@ EOF
 		    --vendor "$PACKAGE_VENDOR" \
 		    --config-files /etc/init/docker.conf \
 		    --config-files /etc/init.d/docker \
+		    --config-files /etc/default/docker \
+		    --deb-compression xz \
 		    -t deb .
 		mkdir empty
 		fpm -s dir -C empty \
@@ -92,7 +119,12 @@ EOF
 		    --maintainer "$PACKAGE_MAINTAINER" \
 		    --url "$PACKAGE_URL" \
 		    --vendor "$PACKAGE_VENDOR" \
+		    --config-files /etc/init/docker.conf \
+		    --config-files /etc/init.d/docker \
+		    --config-files /etc/default/docker \
+		    --deb-compression xz \
 		    -t deb .
+		# note: the --config-files lines have to be duplicated to stop overwrite on package upgrade (since we have to use this funky virtual package)
 	)
 }
 

From f4773a7d1fddbd0a12a94cb068830056cdff04a2 Mon Sep 17 00:00:00 2001
From: Roberto Gandolfo Hashioka <roberto_hashioka@hotmail.com>
Date: Fri, 8 Nov 2013 16:47:42 -0800
Subject: [PATCH 073/184] - Added delete all the containers example
 Upstream-commit: 403f9fc357d64ccbdf82e1c4cbad2946eb1d1080 Component: engine

---
 components/engine/docs/sources/commandline/cli.rst | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 4e3d369e14..28fac978f5 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -622,6 +622,15 @@ This will remove the container referenced under the link ``/redis``.
 This will remove the underlying link between ``/webapp`` and the ``/redis`` containers removing all
 network communication.
 
+.. code-block:: bash
+
+    $ docker rm `docker ps -a -q`
+
+
+This command will delete all the stopped containers. The command ``docker ps -a -q`` will return all
+the existing container's id and the ``rm`` command takes those id's and delete them. The running containers
+will not be deleted, even though they will appear on that id's list.
+
 .. _cli_rmi:
 
 ``rmi``

From d772cfe67302b297748e3b1fe28e23df52f2c62e Mon Sep 17 00:00:00 2001
From: Sven Dowideit <SvenDowideit@home.org.au>
Date: Fri, 25 Oct 2013 11:59:59 +1000
Subject: [PATCH 074/184] make all image ID and container ID API responses use
 the Long ID (Closes #2098) Upstream-commit:
 b3974abe4f01d408850e245c9b52c77f3571e0b2 Component: engine

---
 components/engine/AUTHORS                     |   1 +
 components/engine/commands_test.go            | 128 +++++++++++++++++-
 components/engine/container.go                |  16 +--
 components/engine/container_test.go           |   3 +-
 .../engine/docs/sources/terms/container.rst   |   7 +
 .../engine/docs/sources/terms/image.rst       |   8 ++
 components/engine/docs/sources/use/basics.rst |  23 +++-
 components/engine/image.go                    |   4 -
 components/engine/runtime.go                  |   4 +-
 components/engine/server.go                   |  34 ++---
 10 files changed, 182 insertions(+), 46 deletions(-)

diff --git a/components/engine/AUTHORS b/components/engine/AUTHORS
index 64f2ce21aa..711c7718ff 100644
--- a/components/engine/AUTHORS
+++ b/components/engine/AUTHORS
@@ -165,6 +165,7 @@ Sridatta Thatipamala <sthatipamala@gmail.com>
 Sridhar Ratnakumar <sridharr@activestate.com>
 Steeve Morin <steeve.morin@gmail.com>
 Stefan Praszalowicz <stefan@greplin.com>
+Sven Dowideit <SvenDowideit@home.org.au>
 Thatcher Peskens <thatcher@dotcloud.com>
 Thermionix <bond711@gmail.com>
 Thijs Terlouw <thijsterlouw@gmail.com>
diff --git a/components/engine/commands_test.go b/components/engine/commands_test.go
index 6c6a8e975b..1778f1b89f 100644
--- a/components/engine/commands_test.go
+++ b/components/engine/commands_test.go
@@ -6,6 +6,8 @@ import (
 	"github.com/dotcloud/docker/utils"
 	"io"
 	"io/ioutil"
+	"os"
+	"path"
 	"regexp"
 	"strings"
 	"testing"
@@ -381,8 +383,8 @@ func TestRunAttachStdin(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		if cmdOutput != container.ShortID()+"\n" {
-			t.Fatalf("Wrong output: should be '%s', not '%s'\n", container.ShortID()+"\n", cmdOutput)
+		if cmdOutput != container.ID+"\n" {
+			t.Fatalf("Wrong output: should be '%s', not '%s'\n", container.ID+"\n", cmdOutput)
 		}
 	})
 
@@ -459,7 +461,7 @@ func TestRunDetach(t *testing.T) {
 	})
 }
 
-// TestAttachDetach checks that attach in tty mode can be detached
+// TestAttachDetach checks that attach in tty mode can be detached using the long container ID
 func TestAttachDetach(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
@@ -486,8 +488,8 @@ func TestAttachDetach(t *testing.T) {
 
 		container = globalRuntime.List()[0]
 
-		if strings.Trim(string(buf[:n]), " \r\n") != container.ShortID() {
-			t.Fatalf("Wrong ID received. Expect %s, received %s", container.ShortID(), buf[:n])
+		if strings.Trim(string(buf[:n]), " \r\n") != container.ID {
+			t.Fatalf("Wrong ID received. Expect %s, received %s", container.ID, buf[:n])
 		}
 	})
 	setTimeout(t, "Starting container timed out", 10*time.Second, func() {
@@ -501,7 +503,69 @@ func TestAttachDetach(t *testing.T) {
 	ch = make(chan struct{})
 	go func() {
 		defer close(ch)
-		if err := cli.CmdAttach(container.ShortID()); err != nil {
+		if err := cli.CmdAttach(container.ID); err != nil {
+			if err != io.ErrClosedPipe {
+				t.Fatal(err)
+			}
+		}
+	}()
+
+	setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
+		if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
+			if err != io.ErrClosedPipe {
+				t.Fatal(err)
+			}
+		}
+	})
+
+	setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {
+		stdinPipe.Write([]byte{16, 17})
+		if err := stdinPipe.Close(); err != nil {
+			t.Fatal(err)
+		}
+	})
+	closeWrap(stdin, stdinPipe, stdout, stdoutPipe)
+
+	// wait for CmdRun to return
+	setTimeout(t, "Waiting for CmdAttach timed out", 15*time.Second, func() {
+		<-ch
+	})
+
+	time.Sleep(500 * time.Millisecond)
+	if !container.State.Running {
+		t.Fatal("The detached container should be still running")
+	}
+
+	setTimeout(t, "Waiting for container to die timedout", 5*time.Second, func() {
+		container.Kill()
+	})
+}
+
+// TestAttachDetachTruncatedID checks that attach in tty mode can be detached
+func TestAttachDetachTruncatedID(t *testing.T) {
+	stdin, stdinPipe := io.Pipe()
+	stdout, stdoutPipe := io.Pipe()
+
+	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)
+
+	go stdout.Read(make([]byte, 1024))
+	setTimeout(t, "Starting container timed out", 2*time.Second, func() {
+		if err := cli.CmdRun("-i", "-t", "-d", unitTestImageID, "cat"); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	container := globalRuntime.List()[0]
+
+	stdin, stdinPipe = io.Pipe()
+	stdout, stdoutPipe = io.Pipe()
+	cli = NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+
+	ch := make(chan struct{})
+	go func() {
+		defer close(ch)
+		if err := cli.CmdAttach(utils.TruncateID(container.ID)); err != nil {
 			if err != io.ErrClosedPipe {
 				t.Fatal(err)
 			}
@@ -825,3 +889,55 @@ run    [ "$(ls -d /var/run/sshd)" = "/var/run/sshd" ]
 
 	return image
 }
+
+// #2098 - Docker cidFiles only contain short version of the containerId
+//sudo docker run -cidfile /tmp/docker_test.cid ubuntu echo "test"
+// TestRunCidFile tests that run -cidfile returns the longid
+func TestRunCidFile(t *testing.T) {
+	stdout, stdoutPipe := io.Pipe()
+
+	tmpDir, err := ioutil.TempDir("", "TestRunCidFile")
+	if err != nil {
+		t.Fatal(err)
+	}
+	tmpCidFile := path.Join(tmpDir, "cid")
+
+	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)
+
+	c := make(chan struct{})
+	go func() {
+		defer close(c)
+		if err := cli.CmdRun("-cidfile", tmpCidFile, unitTestImageID, "ls"); err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	defer os.RemoveAll(tmpDir)
+	setTimeout(t, "Reading command output time out", 2*time.Second, func() {
+		cmdOutput, err := bufio.NewReader(stdout).ReadString('\n')
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(cmdOutput) < 1 {
+			t.Fatalf("'ls' should return something , not '%s'", cmdOutput)
+		}
+		//read the tmpCidFile
+		buffer, err := ioutil.ReadFile(tmpCidFile)
+		if err != nil {
+			t.Fatal(err)
+		}
+		id := string(buffer)
+
+		if len(id) != len("2bf44ea18873287bd9ace8a4cb536a7cbe134bed67e805fdf2f58a57f69b320c") {
+			t.Fatalf("-cidfile should be a long id, not '%s'", id)
+		}
+		//test that its a valid cid? (though the container is gone..)
+		//remove the file and dir.
+	})
+
+	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
+		<-c
+	})
+
+}
diff --git a/components/engine/container.go b/components/engine/container.go
index 419ba84d29..330ddb0d2d 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -1235,7 +1235,7 @@ func (container *Container) monitor() {
 	container.State.setStopped(exitCode)
 
 	if container.runtime != nil && container.runtime.srv != nil {
-		container.runtime.srv.LogEvent("die", container.ShortID(), container.runtime.repositories.ImageName(container.Image))
+		container.runtime.srv.LogEvent("die", container.ID, container.runtime.repositories.ImageName(container.Image))
 	}
 
 	// Cleanup
@@ -1302,7 +1302,7 @@ func (container *Container) kill(sig int) error {
 	}
 
 	if output, err := exec.Command("lxc-kill", "-n", container.ID, strconv.Itoa(sig)).CombinedOutput(); err != nil {
-		log.Printf("error killing container %s (%s, %s)", container.ShortID(), output, err)
+		log.Printf("error killing container %s (%s, %s)", utils.TruncateID(container.ID), output, err)
 		return err
 	}
 
@@ -1322,9 +1322,9 @@ func (container *Container) Kill() error {
 	// 2. Wait for the process to die, in last resort, try to kill the process directly
 	if err := container.WaitTimeout(10 * time.Second); err != nil {
 		if container.cmd == nil {
-			return fmt.Errorf("lxc-kill failed, impossible to kill the container %s", container.ShortID())
+			return fmt.Errorf("lxc-kill failed, impossible to kill the container %s", utils.TruncateID(container.ID))
 		}
-		log.Printf("Container %s failed to exit within 10 seconds of lxc-kill %s - trying direct SIGKILL", "SIGKILL", container.ShortID())
+		log.Printf("Container %s failed to exit within 10 seconds of lxc-kill %s - trying direct SIGKILL", "SIGKILL", utils.TruncateID(container.ID))
 		if err := container.cmd.Process.Kill(); err != nil {
 			return err
 		}
@@ -1460,14 +1460,6 @@ func (container *Container) Unmount() error {
 	return Unmount(container.RootfsPath())
 }
 
-// ShortID returns a shorthand version of the container's id for convenience.
-// A collision with other container shorthands is very unlikely, but possible.
-// In case of a collision a lookup with Runtime.Get() will fail, and the caller
-// will need to use a langer prefix, or the full-length container Id.
-func (container *Container) ShortID() string {
-	return utils.TruncateID(container.ID)
-}
-
 func (container *Container) logPath(name string) string {
 	return path.Join(container.root, fmt.Sprintf("%s-%s.log", container.ID, name))
 }
diff --git a/components/engine/container_test.go b/components/engine/container_test.go
index d51946ece3..26007a732d 100644
--- a/components/engine/container_test.go
+++ b/components/engine/container_test.go
@@ -3,6 +3,7 @@ package docker
 import (
 	"bufio"
 	"fmt"
+	"github.com/dotcloud/docker/utils"
 	"io"
 	"io/ioutil"
 	"math/rand"
@@ -1005,7 +1006,7 @@ func TestEnv(t *testing.T) {
 		"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
 		"HOME=/",
 		"container=lxc",
-		"HOSTNAME=" + container.ShortID(),
+		"HOSTNAME=" + utils.TruncateID(container.ID),
 		"FALSE=true",
 		"TRUE=false",
 		"TRICKY=tri",
diff --git a/components/engine/docs/sources/terms/container.rst b/components/engine/docs/sources/terms/container.rst
index aeb7b1c3a9..206664bd82 100644
--- a/components/engine/docs/sources/terms/container.rst
+++ b/components/engine/docs/sources/terms/container.rst
@@ -38,3 +38,10 @@ was when the container was stopped.
 You can promote a container to an :ref:`image_def` with ``docker
 commit``. Once a container is an image, you can use it as a parent for
 new containers.
+
+Container IDs
+.............
+All containers are identified by a 64 hexadecimal digit string (internally a 256bit 
+value). To simplify their use, a short ID of the first 12 characters can be used 
+on the commandline. There is a small possibility of short id collisions, so the 
+docker server will always return the long ID.
diff --git a/components/engine/docs/sources/terms/image.rst b/components/engine/docs/sources/terms/image.rst
index dafda1f3fc..6d5c8b2e7c 100644
--- a/components/engine/docs/sources/terms/image.rst
+++ b/components/engine/docs/sources/terms/image.rst
@@ -36,3 +36,11 @@ Base Image
 ..........
 
 An image that has no parent is a **base image**.
+
+Image IDs
+.........
+All images are identified by a 64 hexadecimal digit string (internally a 256bit 
+value). To simplify their use, a short ID of the first 12 characters can be used 
+on the command line. There is a small possibility of short id collisions, so the 
+docker server will always return the long ID.
+
diff --git a/components/engine/docs/sources/use/basics.rst b/components/engine/docs/sources/use/basics.rst
index 0097b6836d..d1ad081f99 100644
--- a/components/engine/docs/sources/use/basics.rst
+++ b/components/engine/docs/sources/use/basics.rst
@@ -22,22 +22,37 @@ specify the path to it and manually start it.
     # Run docker in daemon mode
     sudo <path to>/docker -d &
 
-
-Running an interactive shell
-----------------------------
+Download a pre-built image
+--------------------------
 
 .. code-block:: bash
 
   # Download an ubuntu image
   sudo docker pull ubuntu
 
+This will find the ``ubuntu`` image by name in the :ref:`Central Index 
+<searching_central_index>` and download it from the top-level Central 
+Repository to a local image cache.
+
+.. NOTE:: When the image has successfully downloaded, you will see a 12 
+character hash ``539c0211cd76: Download complete`` which is the short 
+form of the image ID. These short image IDs are the first 12 characters 
+of the full image ID - which can be found using ``docker inspect`` or 
+``docker images -notrunc=true``
+
+.. _dockergroup:
+
+Running an interactive shell
+----------------------------
+
+.. code-block:: bash
+
   # Run an interactive shell in the ubuntu image,
   # allocate a tty, attach stdin and stdout
   # To detach the tty without exiting the shell,
   # use the escape sequence Ctrl-p + Ctrl-q
   sudo docker run -i -t ubuntu /bin/bash
 
-.. _dockergroup:
 
 Why ``sudo``?
 -------------
diff --git a/components/engine/image.go b/components/engine/image.go
index 94cccaac67..c600273c1a 100644
--- a/components/engine/image.go
+++ b/components/engine/image.go
@@ -202,10 +202,6 @@ func (image *Image) Changes(rw string) ([]Change, error) {
 	return Changes(layers, rw)
 }
 
-func (image *Image) ShortID() string {
-	return utils.TruncateID(image.ID)
-}
-
 func ValidateID(id string) error {
 	if id == "" {
 		return fmt.Errorf("Image id can't be empty")
diff --git a/components/engine/runtime.go b/components/engine/runtime.go
index 671694fce5..6a3b76a595 100644
--- a/components/engine/runtime.go
+++ b/components/engine/runtime.go
@@ -181,7 +181,7 @@ func (runtime *Runtime) ensureName(container *Container) error {
 	if container.Name == "" {
 		name, err := generateRandomName(runtime)
 		if err != nil {
-			name = container.ShortID()
+			name = utils.TruncateID(container.ID)
 		}
 		container.Name = name
 
@@ -288,7 +288,7 @@ func (runtime *Runtime) restore() error {
 		// Try to set the default name for a container if it exists prior to links
 		container.Name, err = generateRandomName(runtime)
 		if err != nil {
-			container.Name = container.ShortID()
+			container.Name = utils.TruncateID(container.ID)
 		}
 
 		if _, err := runtime.containerGraph.Set(container.Name, container.ID); err != nil {
diff --git a/components/engine/server.go b/components/engine/server.go
index 3441029027..2e23612621 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -154,7 +154,7 @@ func (srv *Server) ContainerKill(name string, sig int) error {
 			if err := container.Kill(); err != nil {
 				return fmt.Errorf("Cannot kill container %s: %s", name, err)
 			}
-			srv.LogEvent("kill", container.ShortID(), srv.runtime.repositories.ImageName(container.Image))
+			srv.LogEvent("kill", container.ID, srv.runtime.repositories.ImageName(container.Image))
 		} else {
 			// Otherwise, just send the requested signal
 			if err := container.kill(sig); err != nil {
@@ -180,7 +180,7 @@ func (srv *Server) ContainerExport(name string, out io.Writer) error {
 		if _, err := io.Copy(out, data); err != nil {
 			return err
 		}
-		srv.LogEvent("export", container.ShortID(), srv.runtime.repositories.ImageName(container.Image))
+		srv.LogEvent("export", container.ID, srv.runtime.repositories.ImageName(container.Image))
 		return nil
 	}
 	return fmt.Errorf("No such container: %s", name)
@@ -230,7 +230,7 @@ func (srv *Server) ImageInsert(name, url, path string, out io.Writer, sf *utils.
 		return "", err
 	}
 	out.Write(sf.FormatStatus("", img.ID))
-	return img.ShortID(), nil
+	return img.ID, nil
 }
 
 func (srv *Server) ImagesViz(out io.Writer) error {
@@ -250,9 +250,9 @@ func (srv *Server) ImagesViz(out io.Writer) error {
 			return fmt.Errorf("Error while getting parent image: %v", err)
 		}
 		if parentImage != nil {
-			out.Write([]byte(" \"" + parentImage.ShortID() + "\" -> \"" + image.ShortID() + "\"\n"))
+			out.Write([]byte(" \"" + parentImage.ID + "\" -> \"" + image.ID + "\"\n"))
 		} else {
-			out.Write([]byte(" base -> \"" + image.ShortID() + "\" [style=invis]\n"))
+			out.Write([]byte(" base -> \"" + image.ID + "\" [style=invis]\n"))
 		}
 	}
 
@@ -465,7 +465,7 @@ func (srv *Server) Containers(all, size bool, n int, since, before string) []API
 			continue
 		}
 		if before != "" {
-			if container.ShortID() == before {
+			if container.ID == before || utils.TruncateID(container.ID) == before {
 				foundBefore = true
 				continue
 			}
@@ -476,7 +476,7 @@ func (srv *Server) Containers(all, size bool, n int, since, before string) []API
 		if displayed == n {
 			break
 		}
-		if container.ShortID() == since {
+		if container.ID == since || utils.TruncateID(container.ID) == since {
 			break
 		}
 		displayed++
@@ -518,7 +518,7 @@ func (srv *Server) ContainerCommit(name, repo, tag, author, comment string, conf
 	if err != nil {
 		return "", err
 	}
-	return img.ShortID(), err
+	return img.ID, err
 }
 
 func (srv *Server) ContainerTag(name, repo, tag string, force bool) error {
@@ -1017,7 +1017,7 @@ func (srv *Server) ImageImport(src, repo, tag string, in io.Reader, out io.Write
 			return err
 		}
 	}
-	out.Write(sf.FormatStatus("", img.ShortID()))
+	out.Write(sf.FormatStatus("", img.ID))
 	return nil
 }
 
@@ -1046,8 +1046,8 @@ func (srv *Server) ContainerCreate(config *Config, name string) (string, []strin
 		}
 		return "", nil, err
 	}
-	srv.LogEvent("create", container.ShortID(), srv.runtime.repositories.ImageName(container.Image))
-	return container.ShortID(), buildWarnings, nil
+	srv.LogEvent("create", container.ID, srv.runtime.repositories.ImageName(container.Image))
+	return container.ID, buildWarnings, nil
 }
 
 func (srv *Server) ContainerRestart(name string, t int) error {
@@ -1055,7 +1055,7 @@ func (srv *Server) ContainerRestart(name string, t int) error {
 		if err := container.Restart(t); err != nil {
 			return fmt.Errorf("Cannot restart container %s: %s", name, err)
 		}
-		srv.LogEvent("restart", container.ShortID(), srv.runtime.repositories.ImageName(container.Image))
+		srv.LogEvent("restart", container.ID, srv.runtime.repositories.ImageName(container.Image))
 	} else {
 		return fmt.Errorf("No such container: %s", name)
 	}
@@ -1111,7 +1111,7 @@ func (srv *Server) ContainerDestroy(name string, removeVolume, removeLink bool)
 		if err := srv.runtime.Destroy(container); err != nil {
 			return fmt.Errorf("Cannot destroy container %s: %s", name, err)
 		}
-		srv.LogEvent("destroy", container.ShortID(), srv.runtime.repositories.ImageName(container.Image))
+		srv.LogEvent("destroy", container.ID, srv.runtime.repositories.ImageName(container.Image))
 
 		if removeVolume {
 			// Retrieve all volumes from all remaining containers
@@ -1228,8 +1228,8 @@ func (srv *Server) deleteImage(img *Image, repoName, tag string) ([]APIRmi, erro
 			return nil, err
 		}
 		if tagDeleted {
-			imgs = append(imgs, APIRmi{Untagged: img.ShortID()})
-			srv.LogEvent("untag", img.ShortID(), "")
+			imgs = append(imgs, APIRmi{Untagged: img.ID})
+			srv.LogEvent("untag", img.ID, "")
 		}
 	}
 	if len(srv.runtime.repositories.ByID()[img.ID]) == 0 {
@@ -1364,7 +1364,7 @@ func (srv *Server) ContainerStart(name string, hostConfig *HostConfig) error {
 	if err := container.Start(); err != nil {
 		return fmt.Errorf("Cannot start container %s: %s", name, err)
 	}
-	srv.LogEvent("start", container.ShortID(), runtime.repositories.ImageName(container.Image))
+	srv.LogEvent("start", container.ID, runtime.repositories.ImageName(container.Image))
 
 	return nil
 }
@@ -1374,7 +1374,7 @@ func (srv *Server) ContainerStop(name string, t int) error {
 		if err := container.Stop(t); err != nil {
 			return fmt.Errorf("Cannot stop container %s: %s", name, err)
 		}
-		srv.LogEvent("stop", container.ShortID(), srv.runtime.repositories.ImageName(container.Image))
+		srv.LogEvent("stop", container.ID, srv.runtime.repositories.ImageName(container.Image))
 	} else {
 		return fmt.Errorf("No such container: %s", name)
 	}

From e4cf9cf4dc746fa53b2c7659b0247bae8a931f31 Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Sat, 9 Nov 2013 02:28:04 -0700
Subject: [PATCH 075/184] Fix the display of get.docker.io in Firefox by making
 our index files text/plain Upstream-commit:
 7f1b179c67476efa7dbafda55541b515fbe0f346 Component: engine

---
 components/engine/hack/release.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/hack/release.sh b/components/engine/hack/release.sh
index 06b76a1c7a..931ab6f9af 100755
--- a/components/engine/hack/release.sh
+++ b/components/engine/hack/release.sh
@@ -97,7 +97,7 @@ write_to_s3() {
 	DEST=$1
 	F=`mktemp`
 	cat > $F
-	s3cmd --acl-public put $F $DEST
+	s3cmd --acl-public --mime-type='text/plain' put $F $DEST
 	rm -f $F
 }
 

From 311c5ef875c76b0935419a370ddb276d9a7111b1 Mon Sep 17 00:00:00 2001
From: Roberto Gandolfo Hashioka <roberto_hashioka@hotmail.com>
Date: Sat, 9 Nov 2013 11:08:43 -0800
Subject: [PATCH 076/184] - Updated description Upstream-commit:
 4ec0b515786ce266234d350fee872764974d2218 Component: engine

---
 components/engine/docs/sources/commandline/cli.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 28fac978f5..0267852149 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -627,9 +627,9 @@ network communication.
     $ docker rm `docker ps -a -q`
 
 
-This command will delete all the stopped containers. The command ``docker ps -a -q`` will return all
-the existing container's id and the ``rm`` command takes those id's and delete them. The running containers
-will not be deleted, even though they will appear on that id's list.
+This command will delete all stopped containers. The command ``docker ps -a -q`` will return all
+existing container IDs and pass them to the ``rm`` command which will delete them. Any running
+containers will not be deleted.
 
 .. _cli_rmi:
 

From 862e9a4daef9c70644e7507855a178e91b816a68 Mon Sep 17 00:00:00 2001
From: David Anderson <dave@natulte.net>
Date: Sat, 9 Nov 2013 19:31:08 -0800
Subject: [PATCH 077/184] Correctly express "any address" to iptables.

Iptables interprets "-d 0.0.0.0" as "-d 0.0.0.0/32", not /0. This
results in the DNAT rule never matching any traffic if not bound
to a specific host IP.

Fixes #2598
Upstream-commit: 8ba8783bcc0ec3a0c5391445d52e2b2a9d0a3f8a
Component: engine
---
 components/engine/iptables/iptables.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/components/engine/iptables/iptables.go b/components/engine/iptables/iptables.go
index 82ecf8bb5b..0438bcbd88 100644
--- a/components/engine/iptables/iptables.go
+++ b/components/engine/iptables/iptables.go
@@ -55,9 +55,16 @@ func RemoveExistingChain(name string) error {
 }
 
 func (c *Chain) Forward(action Action, ip net.IP, port int, proto, dest_addr string, dest_port int) error {
+	daddr := ip.String()
+	if ip.IsUnspecified() {
+		// iptables interprets "0.0.0.0" as "0.0.0.0/32", whereas we
+		// want "0.0.0.0/0". "0/0" is correctly interpreted as "any
+		// value" by both iptables and ip6tables.
+		daddr = "0/0"
+	}
 	if output, err := Raw("-t", "nat", fmt.Sprint(action), c.Name,
 		"-p", proto,
-		"-d", ip.String(),
+		"-d", daddr,
 		"--dport", strconv.Itoa(port),
 		"!", "-i", c.Bridge,
 		"-j", "DNAT",

From 9fcdb45469ac17c2777987db17aa59eb14f9d371 Mon Sep 17 00:00:00 2001
From: Mark Allen <mrallen1@yahoo.com>
Date: Sun, 10 Nov 2013 00:06:55 -0600
Subject: [PATCH 078/184] Edits after code review

Return long image ID
Return streamformatted error or "raw" error
Upstream-commit: 8cc19765b48d1a429b840b731ed5fd5b81fbda3c
Component: engine
---
 components/engine/api.go    | 6 +++++-
 components/engine/server.go | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index 8f31ab0282..ce46d50129 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -481,7 +481,11 @@ func postImagesInsert(srv *Server, version float64, w http.ResponseWriter, r *ht
 	sf := utils.NewStreamFormatter(version > 1.0)
 	err := srv.ImageInsert(name, url, path, w, sf)
 	if err != nil {
-		w.Write(sf.FormatError(err))
+		if sf.Used() {
+			w.Write(sf.FormatError(err))
+			return nil
+		}
+		return err
 	}
 
 	return nil
diff --git a/components/engine/server.go b/components/engine/server.go
index eb4e74e0bf..93ca61365a 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -229,7 +229,7 @@ func (srv *Server) ImageInsert(name, url, path string, out io.Writer, sf *utils.
 	if err != nil {
 		return err
 	}
-	out.Write(sf.FormatStatus(utils.TruncateID(img.ID), "Image created"))
+	out.Write(sf.FormatStatus(img.ID, "Image created"))
 	return nil
 }
 

From a33628fd7cb09a0db56b49021034f2a49557606f Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Sat, 9 Nov 2013 14:10:00 -0500
Subject: [PATCH 079/184] Added status column to API client table
 Upstream-commit: 5a1bfd9aa9a0983b5141dd8e393cc67a68fc6590 Component: engine

---
 .../api/remote_api_client_libraries.rst       | 50 +++++++++----------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/components/engine/docs/sources/api/remote_api_client_libraries.rst b/components/engine/docs/sources/api/remote_api_client_libraries.rst
index 8243d02c80..f00ab1c2b5 100644
--- a/components/engine/docs/sources/api/remote_api_client_libraries.rst
+++ b/components/engine/docs/sources/api/remote_api_client_libraries.rst
@@ -12,28 +12,28 @@ compatibility. Please file issues with the library owners.  If you
 find more library implementations, please list them in Docker doc bugs
 and we will add the libraries here.
 
-+----------------------+----------------+--------------------------------------------+
-| Language/Framework   | Name           | Repository                                 |
-+======================+================+============================================+
-| Python               | docker-py      | https://github.com/dotcloud/docker-py      |
-+----------------------+----------------+--------------------------------------------+
-| Ruby                 | docker-client  | https://github.com/geku/docker-client      |
-+----------------------+----------------+--------------------------------------------+
-| Ruby                 | docker-api     | https://github.com/swipely/docker-api      |
-+----------------------+----------------+--------------------------------------------+
-| Javascript (NodeJS)  | docker.io      | https://github.com/appersonlabs/docker.io  |
-|                      |                | Install via NPM: `npm install docker.io`   |
-+----------------------+----------------+--------------------------------------------+
-| Javascript           | docker-js      | https://github.com/dgoujard/docker-js      |
-+----------------------+----------------+--------------------------------------------+
-| Javascript (Angular) | dockerui       | https://github.com/crosbymichael/dockerui  |
-| **WebUI**            |                |                                            |
-+----------------------+----------------+--------------------------------------------+
-| Java                 | docker-java    | https://github.com/kpelykh/docker-java     |
-+----------------------+----------------+--------------------------------------------+
-| Erlang               | erldocker      | https://github.com/proger/erldocker        |
-+----------------------+----------------+--------------------------------------------+
-| Go                   | go-dockerclient| https://github.com/fsouza/go-dockerclient  |
-+----------------------+----------------+--------------------------------------------+
-| PHP                  | Alvine         | http://pear.alvine.io/ (alpha)             |
-+----------------------+----------------+--------------------------------------------+
++----------------------+----------------+--------------------------------------------+----------+
+| Language/Framework   | Name           | Repository                                 | Status   |
++======================+================+============================================+==========+
+| Python               | docker-py      | https://github.com/dotcloud/docker-py      | Active   |
++----------------------+----------------+--------------------------------------------+----------+
+| Ruby                 | docker-client  | https://github.com/geku/docker-client      | Outdated |
++----------------------+----------------+--------------------------------------------+----------+
+| Ruby                 | docker-api     | https://github.com/swipely/docker-api      | Active   |
++----------------------+----------------+--------------------------------------------+----------+
+| Javascript (NodeJS)  | docker.io      | https://github.com/appersonlabs/docker.io  | Active   |
+|                      |                | Install via NPM: `npm install docker.io`   |          |
++----------------------+----------------+--------------------------------------------+----------+
+| Javascript           | docker-js      | https://github.com/dgoujard/docker-js      | Active   |
++----------------------+----------------+--------------------------------------------+----------+
+| Javascript (Angular) | dockerui       | https://github.com/crosbymichael/dockerui  | Active   |
+| **WebUI**            |                |                                            |          |
++----------------------+----------------+--------------------------------------------+----------+
+| Java                 | docker-java    | https://github.com/kpelykh/docker-java     | Active   |
++----------------------+----------------+--------------------------------------------+----------+
+| Erlang               | erldocker      | https://github.com/proger/erldocker        | Active   |
++----------------------+----------------+--------------------------------------------+----------+
+| Go                   | go-dockerclient| https://github.com/fsouza/go-dockerclient  | Active   |
++----------------------+----------------+--------------------------------------------+----------+
+| PHP                  | Alvine         | http://pear.alvine.io/ (alpha)             | Active   |
++----------------------+----------------+--------------------------------------------+----------+

From ab0419261e571ac6cdc37962064f58f6acca7610 Mon Sep 17 00:00:00 2001
From: Galen Sampson <galen.sampson@gmail.com>
Date: Wed, 6 Nov 2013 19:16:56 -0800
Subject: [PATCH 080/184] Vagrantfile updates.

- Remove the overrides config.vm.box and config.vm.box_url and use
  the same values for all providers.
- Use the same private key path for all providers.  It is still possible
  to set a different private key path through the environment variable
  SSH_PRIVKEY_PATH if desired (your AWS key may be different from your
  Virtualbox key).
- Allow the environment variable AWS_INSTANCE_TYPE to specify the
  instance type of instead of hard coding the AWS instance type as
  't1.micro'.  't1.micro' is still the default if unspecified.
- Use the same environment variables for keys as the Amazon provided EC2
  API tools.  This allows people who already have the EC2 tools set up
  correctly to use 'vagrant up' with less environment configuration
  than before.
- Rewrite the provisioning code.  The goal is to be idempotent and to
  correctly install docker for all providers instead of just virtualbox.
  It will conditionally install the virtualbox guest additions if
  virtualbox is the provider.
- Update the AWS install documentation to reflect the changes.
Upstream-commit: ccbb5d34927dc1905984bead3ebb576c0ea20960
Component: engine
---
 components/engine/Vagrantfile                 | 163 +++++++++++++-----
 .../docs/sources/installation/amazon.rst      |  35 +++-
 2 files changed, 146 insertions(+), 52 deletions(-)

diff --git a/components/engine/Vagrantfile b/components/engine/Vagrantfile
index 93a2219fa0..a0bb38ca4f 100644
--- a/components/engine/Vagrantfile
+++ b/components/engine/Vagrantfile
@@ -4,65 +4,135 @@
 BOX_NAME = ENV['BOX_NAME'] || "ubuntu"
 BOX_URI = ENV['BOX_URI'] || "http://files.vagrantup.com/precise64.box"
 VF_BOX_URI = ENV['BOX_URI'] || "http://files.vagrantup.com/precise64_vmware_fusion.box"
+AWS_BOX_URI = ENV['BOX_URI'] || "https://github.com/mitchellh/vagrant-aws/raw/master/dummy.box"
 AWS_REGION = ENV['AWS_REGION'] || "us-east-1"
-AWS_AMI    = ENV['AWS_AMI']    || "ami-d0f89fb9"
+AWS_AMI = ENV['AWS_AMI'] || "ami-69f5a900"
+AWS_INSTANCE_TYPE = ENV['AWS_INSTANCE_TYPE'] || 't1.micro'
+
 FORWARD_DOCKER_PORTS = ENV['FORWARD_DOCKER_PORTS']
 
+SSH_PRIVKEY_PATH = ENV["SSH_PRIVKEY_PATH"]
+
+# A script to upgrade from the 12.04 kernel to the raring backport kernel (3.8)
+# and install docker.
+$script = <<SCRIPT
+# The username to add to the docker group will be passed as the first argument
+# to the script.  If nothing is passed, default to "vagrant".
+user="$1"
+if [ -z "$user" ]; then
+    user=vagrant
+fi
+
+# Adding an apt gpg key is idempotent.
+wget -q -O - https://get.docker.io/gpg | apt-key add -
+
+# Creating the docker.list file is idempotent, but it may overrite desired
+# settings if it already exists.  This could be solved with md5sum but it
+# doesn't seem worth it.
+echo 'deb http://get.docker.io/ubuntu docker main' > \
+    /etc/apt/sources.list.d/docker.list
+
+# Update remote package metadata.  'apt-get update' is idempotent.
+apt-get update -q
+
+# Install docker.  'apt-get install' is idempotent.
+apt-get install -q -y lxc-docker
+
+usermod -a -G docker "$user"
+
+tmp=`mktemp -q` && {
+    # Only install the backport kernel, don't bother upgrade if the backport is
+    # already installed.  We want parse the output of apt so we need to save it
+    # with 'tee'.  NOTE: The installation of the kernel will trigger dkms to
+    # install vboxguest if needed.
+    apt-get install -q -y --no-upgrade linux-image-generic-lts-raring | \
+        tee "$tmp"
+
+    # Parse the number of installed packages from the output
+    NUM_INST=`awk '$2 == "upgraded," && $4 == "newly" { print $3 }' "$tmp"`
+    rm "$tmp"
+}
+
+# If the number of installed packages is greater than 0, we want to reboot (the
+# backport kernel was installed but is not running).
+if [ "$NUM_INST" -gt 0 ];
+then
+    echo "Rebooting down to activate new kernel."
+    echo "/vagrant will not be mounted.  Use 'vagrant halt' followed by"
+    echo "'vagrant up' to ensure /vagrant is mounted."
+    shutdown -r now
+fi
+SCRIPT
+
+# We need to install the virtualbox guest additions *before* we do the normal
+# docker installation.  As such this script is prepended to the common docker
+# install script above.  This allows the install of the backport kernel to
+# trigger dkms to build the virtualbox guest module install.
+$vbox_script = <<VBOX_SCRIPT + $script
+# Install the VirtualBox guest additions if they aren't already installed.
+if [ ! -d /opt/VBoxGuestAdditions-4.2.12/ ]; then
+    # Update remote package metadata.  'apt-get update' is idempotent.
+    apt-get update -q
+
+    # Kernel Headers and dkms are required to build the vbox guest kernel
+    # modules.
+    apt-get install -q -y linux-headers-generic-lts-raring dkms
+
+    echo 'Downloading VBox Guest Additions...'
+    wget -cq http://dlc.sun.com.edgesuite.net/virtualbox/4.2.12/VBoxGuestAdditions_4.2.12.iso
+
+    mount -o loop,ro /home/vagrant/VBoxGuestAdditions_4.2.12.iso /mnt
+    /mnt/VBoxLinuxAdditions.run --nox11
+    umount /mnt
+fi
+VBOX_SCRIPT
+
 Vagrant::Config.run do |config|
   # Setup virtual machine box. This VM configuration code is always executed.
   config.vm.box = BOX_NAME
   config.vm.box_url = BOX_URI
 
-  config.ssh.forward_agent = true
-
-  # Provision docker and new kernel if deployment was not done.
-  # It is assumed Vagrant can successfully launch the provider instance.
-  if Dir.glob("#{File.dirname(__FILE__)}/.vagrant/machines/default/*/id").empty?
-    # Add lxc-docker package
-    pkg_cmd = "wget -q -O - https://get.docker.io/gpg | apt-key add -;" \
-      "echo deb http://get.docker.io/ubuntu docker main > /etc/apt/sources.list.d/docker.list;" \
-      "apt-get update -qq; apt-get install -q -y --force-yes lxc-docker; "
-    # Add Ubuntu raring backported kernel
-    pkg_cmd << "apt-get update -qq; apt-get install -q -y linux-image-generic-lts-raring; "
-    # Add guest additions if local vbox VM. As virtualbox is the default provider,
-    # it is assumed it won't be explicitly stated.
-    if ENV["VAGRANT_DEFAULT_PROVIDER"].nil? && ARGV.none? { |arg| arg.downcase.start_with?("--provider") }
-      pkg_cmd << "apt-get install -q -y linux-headers-generic-lts-raring dkms; " \
-        "echo 'Downloading VBox Guest Additions...'; " \
-        "wget -q http://dlc.sun.com.edgesuite.net/virtualbox/4.2.12/VBoxGuestAdditions_4.2.12.iso; "
-      # Prepare the VM to add guest additions after reboot
-      pkg_cmd << "echo -e 'mount -o loop,ro /home/vagrant/VBoxGuestAdditions_4.2.12.iso /mnt\n" \
-        "echo yes | /mnt/VBoxLinuxAdditions.run\numount /mnt\n" \
-          "rm /root/guest_additions.sh; ' > /root/guest_additions.sh; " \
-        "chmod 700 /root/guest_additions.sh; " \
-        "sed -i -E 's#^exit 0#[ -x /root/guest_additions.sh ] \\&\\& /root/guest_additions.sh#' /etc/rc.local; " \
-        "echo 'Installation of VBox Guest Additions is proceeding in the background.'; " \
-        "echo '\"vagrant reload\" can be used in about 2 minutes to activate the new guest additions.'; "
-    end
-    # Add vagrant user to the docker group
-    pkg_cmd << "usermod -a -G docker vagrant; "
-    # Activate new kernel
-    pkg_cmd << "shutdown -r +1; "
-    config.vm.provision :shell, :inline => pkg_cmd
+  # Use the specified private key path if it is specified and not empty.
+  if SSH_PRIVKEY_PATH
+      config.ssh.private_key_path = SSH_PRIVKEY_PATH
   end
+
+  config.ssh.forward_agent = true
 end
 
-
 # Providers were added on Vagrant >= 1.1.0
+#
+# NOTE: The vagrant "vm.provision" appends its arguments to a list and executes
+# them in order.  If you invoke "vm.provision :shell, :inline => $script"
+# twice then vagrant will run the script two times.  Unfortunately when you use
+# providers and the override argument to set up provisioners (like the vbox
+# guest extensions) they 1) don't replace the other provisioners (they append
+# to the end of the list) and 2) you can't control the order the provisioners
+# are executed (you can only append to the list).  If you want the virtualbox
+# only script to run before the other script, you have to jump through a lot of
+# hoops.
+#
+# Here is my only repeatable solution: make one script that is common ($script)
+# and another script that is the virtual box guest *prepended* to the common
+# script.  Only ever use "vm.provision" *one time* per provider.  That means
+# every single provider has an override, and every single one configures
+# "vm.provision".  Much saddness, but such is life.
 Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
   config.vm.provider :aws do |aws, override|
-    aws.access_key_id = ENV["AWS_ACCESS_KEY_ID"]
-    aws.secret_access_key = ENV["AWS_SECRET_ACCESS_KEY"]
+    username = "ubuntu"
+    override.vm.box_url = AWS_BOX_URI
+    override.vm.provision :shell, :inline => $script, :args => username
+    aws.access_key_id = ENV["AWS_ACCESS_KEY"]
+    aws.secret_access_key = ENV["AWS_SECRET_KEY"]
     aws.keypair_name = ENV["AWS_KEYPAIR_NAME"]
-    override.ssh.private_key_path = ENV["AWS_SSH_PRIVKEY"]
-    override.ssh.username = "ubuntu"
+    override.ssh.username = username
     aws.region = AWS_REGION
     aws.ami    = AWS_AMI
-    aws.instance_type = "t1.micro"
+    aws.instance_type = AWS_INSTANCE_TYPE
   end
 
-  config.vm.provider :rackspace do |rs|
-    config.ssh.private_key_path = ENV["RS_PRIVATE_KEY"]
+  config.vm.provider :rackspace do |rs, override|
+    override.vm.provision :shell, :inline => $script
     rs.username = ENV["RS_USERNAME"]
     rs.api_key  = ENV["RS_API_KEY"]
     rs.public_key_path = ENV["RS_PUBLIC_KEY"]
@@ -71,20 +141,25 @@ Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
   end
 
   config.vm.provider :vmware_fusion do |f, override|
-    override.vm.box = BOX_NAME
     override.vm.box_url = VF_BOX_URI
     override.vm.synced_folder ".", "/vagrant", disabled: true
+    override.vm.provision :shell, :inline => $script
     f.vmx["displayName"] = "docker"
   end
 
-  config.vm.provider :virtualbox do |vb|
-    config.vm.box = BOX_NAME
-    config.vm.box_url = BOX_URI
+  config.vm.provider :virtualbox do |vb, override|
+    override.vm.provision :shell, :inline => $vbox_script
     vb.customize ["modifyvm", :id, "--natdnshostresolver1", "on"]
     vb.customize ["modifyvm", :id, "--natdnsproxy1", "on"]
   end
 end
 
+# If this is a version 1 config, virtualbox is the only option.  A version 2
+# config would have already been set in the above provider section.
+Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|
+  config.vm.provision :shell, :inline => $vbox_script
+end
+
 if !FORWARD_DOCKER_PORTS.nil?
   Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|
     (49000..49900).each do |port|
diff --git a/components/engine/docs/sources/installation/amazon.rst b/components/engine/docs/sources/installation/amazon.rst
index c6c8104321..6d92046dbf 100644
--- a/components/engine/docs/sources/installation/amazon.rst
+++ b/components/engine/docs/sources/installation/amazon.rst
@@ -102,26 +102,45 @@ Docker that way too. Vagrant 1.1 or higher is required.
    we need to set them there first. Make sure you have everything on
    amazon aws setup so you can (manually) deploy a new image to EC2.
 
+   Note that where possible these variables are the same as those honored by
+   the ec2 api tools.
    ::
 
-       export AWS_ACCESS_KEY_ID=xxx
-       export AWS_SECRET_ACCESS_KEY=xxx
+       export AWS_ACCESS_KEY=xxx
+       export AWS_SECRET_KEY=xxx
        export AWS_KEYPAIR_NAME=xxx
-       export AWS_SSH_PRIVKEY=xxx
+       export SSH_PRIVKEY_PATH=xxx
 
-   The environment variables are:
+       export BOX_NAME=xxx
+       export AWS_REGION=xxx
+       export AWS_AMI=xxx
+       export AWS_INSTANCE_TYPE=xxx
 
-   * ``AWS_ACCESS_KEY_ID`` - The API key used to make requests to AWS
-   * ``AWS_SECRET_ACCESS_KEY`` - The secret key to make AWS API requests
+   The required environment variables are:
+
+   * ``AWS_ACCESS_KEY`` - The API key used to make requests to AWS
+   * ``AWS_SECRET_KEY`` - The secret key to make AWS API requests
    * ``AWS_KEYPAIR_NAME`` - The name of the keypair used for this EC2 instance
-   * ``AWS_SSH_PRIVKEY`` - The path to the private key for the named
+   * ``SSH_PRIVKEY_PATH`` - The path to the private key for the named
      keypair, for example ``~/.ssh/docker.pem``
 
+   There are a number of optional environment variables:
+
+   * ``BOX_NAME`` - The name of the vagrant box to use.  Defaults to
+     ``ubuntu``.
+   * ``AWS_REGION`` - The aws region to spawn the vm in.  Defaults to
+     ``us-east-1``.
+   * ``AWS_AMI`` - The aws AMI to start with as a base.  This must be
+     be an ubuntu 12.04 precise image.  You must change this value if
+     ``AWS_REGION`` is set to a value other than ``us-east-1``.
+     This is because AMIs are region specific.  Defaults to ``ami-69f5a900``.
+   * ``AWS_INSTANCE_TYPE`` - The aws instance type.  Defaults to ``t1.micro``.
+
    You can check if they are set correctly by doing something like
 
    ::
 
-      echo $AWS_ACCESS_KEY_ID
+      echo $AWS_ACCESS_KEY
 
 6. Do the magic!
 

From 8c7ea8191097c06ff5ac5f0293237de68626c230 Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <artagnon@gmail.com>
Date: Mon, 11 Nov 2013 10:45:26 +0530
Subject: [PATCH 081/184] CONTRIBUTING: wrap a couple of long lines

Signed-off-by: Ramkumar Ramachandra <artagnon@gmail.com>
Upstream-commit: cf30b85eb1d3ecbf27c35ea344a5f68934c1bd2b
Component: engine
---
 components/engine/CONTRIBUTING.md | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/components/engine/CONTRIBUTING.md b/components/engine/CONTRIBUTING.md
index 43137c67e2..4024bf2634 100644
--- a/components/engine/CONTRIBUTING.md
+++ b/components/engine/CONTRIBUTING.md
@@ -1,11 +1,14 @@
 # Contributing to Docker
 
-Want to hack on Docker? Awesome! Here are instructions to get you started. They are probably not perfect, please let us know if anything feels
-wrong or incomplete.
+Want to hack on Docker? Awesome! Here are instructions to get you
+started. They are probably not perfect, please let us know if anything
+feels wrong or incomplete.
 
 ## Build Environment
 
-For instructions on setting up your development environment, please see our dedicated [dev environment setup docs](http://docs.docker.io/en/latest/contributing/devenvironment/).
+For instructions on setting up your development environment, please
+see our dedicated [dev environment setup
+docs](http://docs.docker.io/en/latest/contributing/devenvironment/).
 
 ## Contribution guidelines
 

From f7888fafe943c93aeb64b80ae964c6ddf7c44f8f Mon Sep 17 00:00:00 2001
From: Fabio Rehm <fgrehm@gmail.com>
Date: Mon, 11 Nov 2013 13:36:44 -0200
Subject: [PATCH 082/184] Update contrib/vagrant-docker with projects available
 Upstream-commit: 9c7a8edddd447e64069f0cd108bee4d008049c49 Component: engine

---
 .../engine/contrib/vagrant-docker/README.md   | 20 +++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/components/engine/contrib/vagrant-docker/README.md b/components/engine/contrib/vagrant-docker/README.md
index 5852ea1927..fa28e448eb 100644
--- a/components/engine/contrib/vagrant-docker/README.md
+++ b/components/engine/contrib/vagrant-docker/README.md
@@ -1,3 +1,19 @@
-# Vagrant-docker
+# Vagrant integration
 
-This is a placeholder for the official vagrant-docker, a plugin for Vagrant (http://vagrantup.com) which exposes Docker as a provider.
+Currently there are at least 4 different projects that we are aware of that deals
+with integration with [Vagrant](http://vagrantup.com/) at different levels. One
+approach is to use Docker as a [provisioner](http://docs.vagrantup.com/v2/provisioning/index.html)
+which means you can create containers and pull base images on VMs using Docker's
+CLI and the other is to use Docker as a [provider](http://docs.vagrantup.com/v2/providers/index.html),
+meaning you can use Vagrant to control Docker containers.
+
+
+### Provisioners
+
+* [Vocker](https://github.com/fgrehm/vocker)
+* [Ventriloquist](https://github.com/fgrehm/ventriloquist)
+
+### Providers
+
+* [docker-provider](https://github.com/fgrehm/docker-provider)
+* [vagrant-shell](https://github.com/destructuring/vagrant-shell)

From 504a744b38ebade2c1af5cd2a2a8102f1888b239 Mon Sep 17 00:00:00 2001
From: "Guillaume J. Charmes" <charmes.guillaume@gmail.com>
Date: Mon, 11 Nov 2013 09:05:38 -0800
Subject: [PATCH 083/184] Fix formatting in tests Upstream-commit:
 402a58a75a5b9813c889bf6c030bb756f86e56d4 Component: engine

---
 components/engine/runtime_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/runtime_test.go b/components/engine/runtime_test.go
index e61f63d495..db9cf8b12e 100644
--- a/components/engine/runtime_test.go
+++ b/components/engine/runtime_test.go
@@ -140,7 +140,7 @@ func setupBaseImage() {
 	if img, err := runtime.repositories.LookupImage(unitTestImageName); err != nil || img.ID != unitTestImageID {
 		// Retrieve the Image
 		if err := srv.ImagePull(unitTestImageName, "", os.Stdout, utils.NewStreamFormatter(false), nil, nil, true); err != nil {
-			log.Fatalf("Unable to pull the test image:", err)
+			log.Fatalf("Unable to pull the test image: %s", err)
 		}
 	}
 }

From a52e1003c49fddd442cc9137985e18a931427550 Mon Sep 17 00:00:00 2001
From: "Guillaume J. Charmes" <charmes.guillaume@gmail.com>
Date: Mon, 11 Nov 2013 09:15:51 -0800
Subject: [PATCH 084/184] Make sure docker kill exit with failure in case of
 error Upstream-commit: 8149439d956489a551f9e197ca2adbae85e78ff0 Component:
 engine

---
 components/engine/commands.go | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index 12cc713654..e00e251b1e 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -892,14 +892,17 @@ func (cli *DockerCli) CmdKill(args ...string) error {
 		return nil
 	}
 
+	failure := []error{}
 	for _, name := range args {
-		_, _, err := cli.call("POST", "/containers/"+name+"/kill", nil)
-		if err != nil {
-			fmt.Fprintf(cli.err, "%s\n", err)
+		if _, _, err := cli.call("POST", "/containers/"+name+"/kill", nil); err != nil {
+			failure = append(failure, err)
 		} else {
 			fmt.Fprintf(cli.out, "%s\n", name)
 		}
 	}
+	if len(failure) != 0 {
+		return fmt.Errorf("Some container failed to get killed: %v\n", failure)
+	}
 	return nil
 }
 

From 60cd8ebc407a016d9e00d65c037887ed3d4ba87c Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Mon, 11 Nov 2013 11:10:19 -0700
Subject: [PATCH 085/184] Fix sysvinit upstart detection and give it a pretty
 message Upstream-commit: bb76157d240ae871bc3d9b6a945a982abf0473c7 Component:
 engine

---
 components/engine/contrib/init/sysvinit/docker | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/components/engine/contrib/init/sysvinit/docker b/components/engine/contrib/init/sysvinit/docker
index 6c0e182f08..3dc6435533 100755
--- a/components/engine/contrib/init/sysvinit/docker
+++ b/components/engine/contrib/init/sysvinit/docker
@@ -29,7 +29,8 @@ if [ -f /etc/default/$BASE ]; then
 	. /etc/default/$BASE
 fi
 
-if [ "$1" = start ] && which initctl >/dev/null && initctl version | grep -q upstart; then
+if which initctl >/dev/null && initctl version | grep -q upstart; then
+	log_failure_msg "Docker is managed via upstart, try using service $BASE $1"
 	exit 1
 fi
 

From 97bc55ee5d2b8199f2654327c05a382a537787e8 Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Mon, 11 Nov 2013 11:13:16 -0700
Subject: [PATCH 086/184] Add /etc/default/docker support to upstart, too
 (mirroring sysvinit) Upstream-commit:
 7cf7dda87d59981f8a1727725f6d914dcc4c1815 Component: engine

---
 components/engine/contrib/init/upstart/docker.conf | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/components/engine/contrib/init/upstart/docker.conf b/components/engine/contrib/init/upstart/docker.conf
index 72c132c860..ee8a447c27 100644
--- a/components/engine/contrib/init/upstart/docker.conf
+++ b/components/engine/contrib/init/upstart/docker.conf
@@ -6,5 +6,10 @@ stop on runlevel [!2345]
 respawn
 
 script
-	/usr/bin/docker -d
+	DOCKER=/usr/bin/$UPSTART_JOB
+	DOCKER_OPTS=
+	if [ -f /etc/default/$UPSTART_JOB ]; then
+		. /etc/default/$UPSTART_JOB
+	fi
+	"$DOCKER" -d $DOCKER_OPTS
 end script

From 10393910abc83ea02d14498b81dadd128e3a6aac Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Mon, 11 Nov 2013 11:57:25 -0700
Subject: [PATCH 087/184] Update upstart check in sysvinit to be exactly the
 same as the init_is_upstart function from /lib/lsb/init-functions (which
 isn't available in 12.04 or we'd use it directly) Upstream-commit:
 88edba7e86efc8d7e118a9863ab701f0b5493d62 Component: engine

---
 components/engine/contrib/init/sysvinit/docker | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/components/engine/contrib/init/sysvinit/docker b/components/engine/contrib/init/sysvinit/docker
index 3dc6435533..2d79c4d4c0 100755
--- a/components/engine/contrib/init/sysvinit/docker
+++ b/components/engine/contrib/init/sysvinit/docker
@@ -29,7 +29,8 @@ if [ -f /etc/default/$BASE ]; then
 	. /etc/default/$BASE
 fi
 
-if which initctl >/dev/null && initctl version | grep -q upstart; then
+# see also init_is_upstart in /lib/lsb/init-functions (which isn't available in Ubuntu 12.04, or we'd use it)
+if [ -x /sbin/initctl ] && /sbin/initctl version 2>/dev/null | /bin/grep -q upstart; then
 	log_failure_msg "Docker is managed via upstart, try using service $BASE $1"
 	exit 1
 fi

From 29829cd5d2bb659ac2bcff13f3b5ed5c26882e97 Mon Sep 17 00:00:00 2001
From: Mark Allen <mrallen1@yahoo.com>
Date: Mon, 11 Nov 2013 13:26:24 -0600
Subject: [PATCH 088/184] Just return the id; nothing else. Upstream-commit:
 62f873aa1f918fe4d303f6168f66d057e6776b18 Component: engine

---
 components/engine/server.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index 93ca61365a..167ec7fc1d 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -229,7 +229,7 @@ func (srv *Server) ImageInsert(name, url, path string, out io.Writer, sf *utils.
 	if err != nil {
 		return err
 	}
-	out.Write(sf.FormatStatus(img.ID, "Image created"))
+	out.Write(sf.FormatStatus(img.ID, ""))
 	return nil
 }
 

From a30846b5480b6d24e5ba1339e71e9fec261d6189 Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Mon, 11 Nov 2013 13:54:17 -0800
Subject: [PATCH 089/184] use utils.ParseRepositoryTag instead of strings.split
 in docker images Upstream-commit: 84a3600ea82d1a3ea235f1193092206c1f0c011a
 Component: engine

---
 components/engine/commands.go | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index 12cc713654..d358e3a0f0 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1172,14 +1172,10 @@ func (cli *DockerCli) CmdImages(args ...string) error {
 			fmt.Fprintln(w, "REPOSITORY\tTAG\tIMAGE ID\tCREATED\tSIZE")
 		}
 
-		var repo string
-		var tag string
 		for _, out := range outs {
 			for _, repotag := range out.RepoTags {
 
-				components := strings.SplitN(repotag, ":", 2)
-				repo = components[0]
-				tag = components[1]
+				repo, tag := utils.ParseRepositoryTag(repotag)
 
 				if !*noTrunc {
 					out.ID = utils.TruncateID(out.ID)
@@ -1241,7 +1237,7 @@ func PrintTreeNode(cli *DockerCli, noTrunc *bool, image APIImages, prefix string
 
 	fmt.Fprintf(cli.out, "%s%s Size: %s (virtual %s)", prefix, imageID, utils.HumanSize(image.Size), utils.HumanSize(image.VirtualSize))
 	if image.RepoTags[0] != "<none>:<none>" {
-		fmt.Fprintf(cli.out, " Tags: %s\n", strings.Join(image.RepoTags, ","))
+		fmt.Fprintf(cli.out, " Tags: %s\n", strings.Join(image.RepoTags, ", "))
 	} else {
 		fmt.Fprint(cli.out, "\n")
 	}

From e57467c18086f8c432fbaad584806a91bc8afdf6 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Mon, 11 Nov 2013 22:08:37 +0000
Subject: [PATCH 090/184] Change crypto export notice to meet Debian
 requirements Upstream-commit: 01dd7e74592b7b45c56d1187e7dcfaac39e67be1
 Component: engine

---
 components/engine/NOTICE    | 35 ++++++-----------------------------
 components/engine/README.md |  9 ++++-----
 2 files changed, 10 insertions(+), 34 deletions(-)

diff --git a/components/engine/NOTICE b/components/engine/NOTICE
index 08be17f366..fb6810bc28 100644
--- a/components/engine/NOTICE
+++ b/components/engine/NOTICE
@@ -8,35 +8,12 @@ by Keith Rarick, licensed under the MIT License.
 
 The following is courtesy of our legal counsel:
 
-Transfers of Docker shall be in accordance with applicable export
-controls of any country and all other applicable legal requirements.
-Docker shall not be distributed or downloaded to or in Cuba, Iran,
-North Korea, Sudan or Syria and shall not be distributed or downloaded
-to any person on the Denied Persons List administered by the U.S.
-Department of Commerce.
 
-What does that mean? 
-Here is a further explanation from our legal counsel:
+Use and transfer of Docker may be subject to certain restrictions by the
+United States and other governments.  
+It is your responsibility to ensure that your use and/or transfer does not
+violate applicable laws. 
 
-Like all software products that utilize cryptography, the export and
-use of Docker is subject to the U.S. Commerce Department's Export
-Administration Regulations (EAR) because it uses or contains
-cryptography (see
-http://www.bis.doc.gov/index.php/policy-guidance/encryption).  Certain
-free and open source software projects have a lightweight set of
-requirements, which can generally be met by providing email notice to
-the appropriate U.S. government agencies that their source code is
-available on a publicly available repository and making the
-appropriate statements in the README.
+For more information, please see http://www.bis.doc.gov
 
-The restrictions of the EAR apply to certain denied locations
-(currently Iran, Sudan, Syria, North Korea, or Cuba) and those
-individuals on the Denied Persons List, which is available here:
-http://www.bis.doc.gov/index.php/policy-guidance/lists-of-parties-of-concern/denied-persons-list.
-If you are incorporating Docker into a new open source project, the
-EAR restrictions apply to your incorporation of Docker into your
-project in the same manner as other cryptography-enabled projects,
-such as OpenSSL, almost all Linux distributions, etc.
-
-For more information, see http://www.apache.org/dev/crypto.html and/or
-seek legal counsel.
+See also http://www.apache.org/dev/crypto.html and/or seek legal counsel.
diff --git a/components/engine/README.md b/components/engine/README.md
index 0d0b1cd888..12ffc2e8ec 100644
--- a/components/engine/README.md
+++ b/components/engine/README.md
@@ -193,10 +193,9 @@ wrong or incomplete.
 *Brought to you courtesy of our legal counsel. For more context,
 please see the Notice document.*
 
-Transfers of Docker shall be in accordance with applicable export controls 
-of any country and all other applicable legal requirements. Without limiting the 
-foregoing, Docker shall not be distributed or downloaded to any individual or 
-location if such distribution or download would violate the applicable US 
-government export regulations. 
+Use and transfer of Docker may be subject to certain restrictions by the
+United States and other governments.  
+It is your responsibility to ensure that your use and/or transfer does not
+violate applicable laws. 
 
 For more information, please see http://www.bis.doc.gov

From b55bba158edde3c3b7a69dc53d49217205a84830 Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Mon, 11 Nov 2013 14:44:51 -0800
Subject: [PATCH 091/184] add wait, stop, start, restart, rm, rmi
 Upstream-commit: e2ac0e6b806c094fd8a3b706653623c0c2aee861 Component: engine

---
 components/engine/commands.go | 43 ++++++++++++++++++++++-------------
 1 file changed, 27 insertions(+), 16 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index e00e251b1e..b73c561522 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -376,15 +376,17 @@ func (cli *DockerCli) CmdWait(args ...string) error {
 		cmd.Usage()
 		return nil
 	}
+	var encounteredError error
 	for _, name := range cmd.Args() {
 		status, err := waitForExit(cli, name)
 		if err != nil {
-			fmt.Fprintf(cli.err, "%s", err)
+			fmt.Fprintf(cli.err, "%s\n", err)
+			encounteredError = fmt.Errorf("Error: failed to wait one or more containers")
 		} else {
 			fmt.Fprintf(cli.out, "%d\n", status)
 		}
 	}
-	return nil
+	return encounteredError
 }
 
 // 'docker version': show version information
@@ -505,15 +507,17 @@ func (cli *DockerCli) CmdStop(args ...string) error {
 	v := url.Values{}
 	v.Set("t", strconv.Itoa(*nSeconds))
 
+	var encounteredError error
 	for _, name := range cmd.Args() {
 		_, _, err := cli.call("POST", "/containers/"+name+"/stop?"+v.Encode(), nil)
 		if err != nil {
 			fmt.Fprintf(cli.err, "%s\n", err)
+			encounteredError = fmt.Errorf("Error: failed to stop one or more containers")
 		} else {
 			fmt.Fprintf(cli.out, "%s\n", name)
 		}
 	}
-	return nil
+	return encounteredError
 }
 
 func (cli *DockerCli) CmdRestart(args ...string) error {
@@ -530,15 +534,17 @@ func (cli *DockerCli) CmdRestart(args ...string) error {
 	v := url.Values{}
 	v.Set("t", strconv.Itoa(*nSeconds))
 
+	var encounteredError error
 	for _, name := range cmd.Args() {
 		_, _, err := cli.call("POST", "/containers/"+name+"/restart?"+v.Encode(), nil)
 		if err != nil {
 			fmt.Fprintf(cli.err, "%s\n", err)
+			encounteredError = fmt.Errorf("Error: failed to  restart one or more containers")
 		} else {
 			fmt.Fprintf(cli.out, "%s\n", name)
 		}
 	}
-	return nil
+	return encounteredError
 }
 
 func (cli *DockerCli) forwardAllSignals(cid string) chan os.Signal {
@@ -772,15 +778,19 @@ func (cli *DockerCli) CmdRmi(args ...string) error {
 		return nil
 	}
 
+	var encounteredError error
 	for _, name := range cmd.Args() {
 		body, _, err := cli.call("DELETE", "/images/"+name, nil)
 		if err != nil {
-			fmt.Fprintf(cli.err, "%s", err)
+			fmt.Fprintf(cli.err, "%s\n", err)
+			encounteredError = fmt.Errorf("Error: failed to remove one or more images")
 		} else {
 			var outs []APIRmi
 			err = json.Unmarshal(body, &outs)
 			if err != nil {
-				return err
+				fmt.Fprintf(cli.err, "%s\n", err)
+				encounteredError = fmt.Errorf("Error: failed to remove one or more images")
+				continue
 			}
 			for _, out := range outs {
 				if out.Deleted != "" {
@@ -791,7 +801,7 @@ func (cli *DockerCli) CmdRmi(args ...string) error {
 			}
 		}
 	}
-	return nil
+	return encounteredError
 }
 
 func (cli *DockerCli) CmdHistory(args ...string) error {
@@ -870,15 +880,18 @@ func (cli *DockerCli) CmdRm(args ...string) error {
 	if *link {
 		val.Set("link", "1")
 	}
+
+	var encounteredError error
 	for _, name := range cmd.Args() {
 		_, _, err := cli.call("DELETE", "/containers/"+name+"?"+val.Encode(), nil)
 		if err != nil {
 			fmt.Fprintf(cli.err, "%s\n", err)
+			encounteredError = fmt.Errorf("Error: failed to remove one or more containers")
 		} else {
 			fmt.Fprintf(cli.out, "%s\n", name)
 		}
 	}
-	return nil
+	return encounteredError
 }
 
 // 'docker kill NAME' kills a running container
@@ -892,18 +905,16 @@ func (cli *DockerCli) CmdKill(args ...string) error {
 		return nil
 	}
 
-	failure := []error{}
+	var encounteredError error
 	for _, name := range args {
 		if _, _, err := cli.call("POST", "/containers/"+name+"/kill", nil); err != nil {
-			failure = append(failure, err)
+			fmt.Fprintf(cli.err, "%s\n", err)
+			encounteredError = fmt.Errorf("Error: failed to kill one or more containers")
 		} else {
 			fmt.Fprintf(cli.out, "%s\n", name)
 		}
 	}
-	if len(failure) != 0 {
-		return fmt.Errorf("Some container failed to get killed: %v\n", failure)
-	}
-	return nil
+	return encounteredError
 }
 
 func (cli *DockerCli) CmdImport(args ...string) error {
@@ -2005,7 +2016,7 @@ func (cli *DockerCli) call(method, path string, data interface{}) ([]byte, int,
 		if len(body) == 0 {
 			return nil, resp.StatusCode, fmt.Errorf("Error: %s", http.StatusText(resp.StatusCode))
 		}
-		return nil, resp.StatusCode, fmt.Errorf("Error: %s", body)
+		return nil, resp.StatusCode, fmt.Errorf("Error: %s", bytes.TrimSpace(body))
 	}
 	return body, resp.StatusCode, nil
 }
@@ -2061,7 +2072,7 @@ func (cli *DockerCli) stream(method, path string, in io.Reader, out io.Writer, h
 		if len(body) == 0 {
 			return fmt.Errorf("Error :%s", http.StatusText(resp.StatusCode))
 		}
-		return fmt.Errorf("Error: %s", body)
+		return fmt.Errorf("Error: %s", bytes.TrimSpace(body))
 	}
 
 	if matchesContentType(resp.Header.Get("Content-Type"), "application/json") {

From c75d132f03ff875b7b0f039e354199d4faf5c61e Mon Sep 17 00:00:00 2001
From: Roberto Gandolfo Hashioka <roberto_hashioka@hotmail.com>
Date: Mon, 11 Nov 2013 17:38:54 -0800
Subject: [PATCH 092/184] - Added a doc about Links and Container Naming
 Upstream-commit: 981560c43631e1b09b6f90945d2d5e58345cabd2 Component: engine

---
 components/engine/docs/sources/use/index.rst  |  1 +
 .../sources/use/working_with_links_names.rst  | 98 +++++++++++++++++++
 2 files changed, 99 insertions(+)
 create mode 100644 components/engine/docs/sources/use/working_with_links_names.rst

diff --git a/components/engine/docs/sources/use/index.rst b/components/engine/docs/sources/use/index.rst
index 914d5a2a21..38f61ba744 100644
--- a/components/engine/docs/sources/use/index.rst
+++ b/components/engine/docs/sources/use/index.rst
@@ -20,3 +20,4 @@ Contents:
    puppet
    host_integration
    working_with_volumes
+   working_with_links_names
diff --git a/components/engine/docs/sources/use/working_with_links_names.rst b/components/engine/docs/sources/use/working_with_links_names.rst
new file mode 100644
index 0000000000..ad88b5f910
--- /dev/null
+++ b/components/engine/docs/sources/use/working_with_links_names.rst
@@ -0,0 +1,98 @@
+:title: Working with Links and Names
+:description: How to create and use links and names
+:keywords: Examples, Usage, links, docker, documentation, examples, names, name, container naming
+
+.. _working_with_links_names:
+
+Working with Links and Names
+============================
+
+From version 0.6.5 you are able to ``name`` a container and ``link`` it to another
+container by referring its name. This will create a relation parent->child where
+the parent container can see all the important information about its child.
+
+.. _run_name:
+
+Container Naming
+----------------
+
+.. versionadded:: v0.6.5
+
+You can now name your container by using ``-name`` flag. If no name is provided,
+Docker will automatically generate a name which can be seen by typing: ``docker ps``.
+
+.. code-block:: bash
+
+    # format is "sudo docker run -name <container_name> <image_name> <command>"
+    $ sudo docker run -name test ubuntu /bin/bash
+
+.. _run_link:
+
+Links: service discovery for docker
+-----------------------------------
+
+.. versionadded:: v0.6.5
+
+Links allow containers to discover and securely communicate with each other by using the
+flag ``-link name:alias``. Inter-container communication can be disabled with the daemon
+flag ``-icc=false``. With this flag set to false, Container A cannot access Container B
+unless explicitly allowed via a link. This is a huge win for securing your containers.
+When two containers are linked together Docker creates a parent child relationship
+between the containers. The parent container will be able to access information via
+env variables of the child such as name, exposed ports, ip, and environment variables.
+
+When linking two containers Docker will use the exposed ports of the container to create
+a secure tunnel for the parent to access. If a database container only exposes port 8080
+then the linked container will only be allowed to access port 8080 and nothing else if
+inter-container communication is set to false.
+
+.. code-block:: bash
+
+    # Example: there is an image called redis-2.6 that exposes the port 6379 and starts redis-server.
+    # Let's name the container as "redis" based on that image and run it as daemon.
+    $ sudo docker run -d -name redis redis-2.6
+
+We can issue all the commands that you would expect using the name "redis"; start, stop,
+attach, using the name for our container. The name also allows us to link other containers
+into this one.
+
+Next, we can start a new web application that has a dependency on Redis and apply a link
+to connect both containers. If you noticed when running our Redis server we did not use
+the -p flag to publish the Redis port to the host system. Redis exposed port 6379 and
+this is all we need to establish a link.
+
+.. code-block:: bash
+
+    # Linking the redis container as a child
+    $ sudo docker run -t -i -link redis:db -name webapp ubuntu bash
+
+When you specified -link redis:db you are telling docker to link the container named redis
+into this new container with the alias db. Environment variables are prefixed with the alias
+so that the parent container can access network and environment information from the containers
+that are linked into it.
+
+If we inspect the environment variables of the second container, we would see all the information
+about the child container.
+
+.. code-block:: bash
+
+    $ sroot@4c01db0b339c:/# env
+
+    HOSTNAME=4c01db0b339c
+    DB_NAME=/webapp/db
+    TERM=xterm
+    DB_PORT=tcp://172.17.0.8:6379
+    DB_PORT_6379_TCP=tcp://172.17.0.8:6379
+    DB_PORT_6379_TCP_PROTO=tcp
+    DB_PORT_6379_TCP_ADDR=172.17.0.8
+    DB_PORT_6379_TCP_PORT=6379
+    PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+    PWD=/
+    SHLVL=1
+    HOME=/
+    container=lxc
+    _=/usr/bin/env
+    root@4c01db0b339c:/#
+
+Accessing the network information along with the environment of the child container allows
+us to easily connect to the Redis service on the specific IP and port in the environment.

From 943cd7996b9c9aab88e9a823ffcff5ba10f2a0fc Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Mon, 11 Nov 2013 18:15:38 -0800
Subject: [PATCH 093/184] on docker start, do not cleanup if already running
 Upstream-commit: bc6d87284174c1a862603a2da574ff60bb03e0fa Component: engine

---
 components/engine/container.go | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index ea4a240387..118ce1b034 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -702,15 +702,14 @@ func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, s
 func (container *Container) Start() (err error) {
 	container.State.Lock()
 	defer container.State.Unlock()
+	if container.State.Running {
+		return fmt.Errorf("The container %s is already running.", container.ID)
+	}
 	defer func() {
 		if err != nil {
 			container.cleanup()
 		}
 	}()
-
-	if container.State.Running {
-		return fmt.Errorf("The container %s is already running.", container.ID)
-	}
 	if err := container.EnsureMounted(); err != nil {
 		return err
 	}

From 31cff767cdfbc82a3d4c4d5452e2b0092b930f36 Mon Sep 17 00:00:00 2001
From: Liang-Chi Hsieh <viirya@gmail.com>
Date: Tue, 12 Nov 2013 10:53:34 +0800
Subject: [PATCH 094/184] fix nameserver regex. Upstream-commit:
 1e5ba57de372bd13b0231e969dbb62a7fa8d7b52 Component: engine

---
 components/engine/utils/utils.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/utils/utils.go b/components/engine/utils/utils.go
index 03fdc1987a..6b1a70df41 100644
--- a/components/engine/utils/utils.go
+++ b/components/engine/utils/utils.go
@@ -944,7 +944,7 @@ func StripComments(input []byte, commentMarker []byte) []byte {
 func GetNameserversAsCIDR(resolvConf []byte) []string {
 	var parsedResolvConf = StripComments(resolvConf, []byte("#"))
 	nameservers := []string{}
-	re := regexp.MustCompile(`^\s*nameserver\s*(([0-9]\.){3}([0-9]))\s*$`)
+	re := regexp.MustCompile(`^\s*nameserver\s*(([0-9]+\.){3}([0-9]+))\s*$`)
 	for _, line := range bytes.Split(parsedResolvConf, []byte("\n")) {
 		var ns = re.FindSubmatch(line)
 		if len(ns) > 0 {

From 5ec9c645773e8f54c690af7c5887378cde3f17a2 Mon Sep 17 00:00:00 2001
From: Liang-Chi Hsieh <viirya@gmail.com>
Date: Tue, 12 Nov 2013 18:18:30 +0800
Subject: [PATCH 095/184] modify test of GetNameserversAsCIDR for its regex
 change. Upstream-commit: 879aa29cb09c641bbd510eed03647f8f85f0d559 Component:
 engine

---
 components/engine/utils/utils_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/components/engine/utils/utils_test.go b/components/engine/utils/utils_test.go
index a6fcbf24bb..09b15c73bc 100644
--- a/components/engine/utils/utils_test.go
+++ b/components/engine/utils/utils_test.go
@@ -481,12 +481,12 @@ func TestParsePortMapping(t *testing.T) {
 func TestGetNameserversAsCIDR(t *testing.T) {
 	for resolv, result := range map[string][]string{`
 nameserver 1.2.3.4
-nameserver 4.3.2.1
-search example.com`: {"1.2.3.4/32", "4.3.2.1/32"},
+nameserver 40.3.200.10
+search example.com`: {"1.2.3.4/32", "40.3.200.10/32"},
 		`search example.com`: {},
 		`nameserver 1.2.3.4
 search example.com
-nameserver 4.3.2.1`: {"1.2.3.4/32", "4.3.2.1/32"},
+nameserver 4.30.20.100`: {"1.2.3.4/32", "4.30.20.100/32"},
 		``: {},
 		`  nameserver 1.2.3.4   `: {"1.2.3.4/32"},
 		`search example.com

From 9bdd66f858d8e6ee0cced71d2235caa857224409 Mon Sep 17 00:00:00 2001
From: Roberto Gandolfo Hashioka <roberto_hashioka@hotmail.com>
Date: Tue, 12 Nov 2013 10:11:52 -0800
Subject: [PATCH 096/184] - Improved documentation and typos fixing (Thanks to
 @jamtur01) Upstream-commit: 353243a7254705f92c3d775eec1f9cfe14fa4170
 Component: engine

---
 .../sources/use/working_with_links_names.rst  | 20 ++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/components/engine/docs/sources/use/working_with_links_names.rst b/components/engine/docs/sources/use/working_with_links_names.rst
index ad88b5f910..02906a8226 100644
--- a/components/engine/docs/sources/use/working_with_links_names.rst
+++ b/components/engine/docs/sources/use/working_with_links_names.rst
@@ -7,9 +7,9 @@
 Working with Links and Names
 ============================
 
-From version 0.6.5 you are able to ``name`` a container and ``link`` it to another
-container by referring its name. This will create a relation parent->child where
-the parent container can see all the important information about its child.
+From version 0.6.5 you are now able to ``name`` a container and ``link`` it to another
+container by referring to its name. This will create a parent -> child relationship
+where the parent container can see selected information about its child.
 
 .. _run_name:
 
@@ -18,14 +18,19 @@ Container Naming
 
 .. versionadded:: v0.6.5
 
-You can now name your container by using ``-name`` flag. If no name is provided,
-Docker will automatically generate a name which can be seen by typing: ``docker ps``.
+You can now name your container by using the ``-name`` flag. If no name is provided, Docker
+will automatically generate a name. You can see this name using the ``docker ps`` command.
 
 .. code-block:: bash
 
     # format is "sudo docker run -name <container_name> <image_name> <command>"
     $ sudo docker run -name test ubuntu /bin/bash
 
+    # the flag "-a" Show all containers. Only running containers are shown by default.
+    $ sudo docker ps -a
+    CONTAINER ID        IMAGE                            COMMAND             CREATED             STATUS              PORTS               NAMES
+    2522602a0d99        ubuntu:12.04                     /bin/bash           14 seconds ago      Exit 0                                  test
+
 .. _run_link:
 
 Links: service discovery for docker
@@ -39,7 +44,8 @@ flag ``-icc=false``. With this flag set to false, Container A cannot access Cont
 unless explicitly allowed via a link. This is a huge win for securing your containers.
 When two containers are linked together Docker creates a parent child relationship
 between the containers. The parent container will be able to access information via
-env variables of the child such as name, exposed ports, ip, and environment variables.
+environment variables of the child such as name, exposed ports, IP and other selected
+environment variables.
 
 When linking two containers Docker will use the exposed ports of the container to create
 a secure tunnel for the parent to access. If a database container only exposes port 8080
@@ -76,7 +82,7 @@ about the child container.
 
 .. code-block:: bash
 
-    $ sroot@4c01db0b339c:/# env
+    $ root@4c01db0b339c:/# env
 
     HOSTNAME=4c01db0b339c
     DB_NAME=/webapp/db

From 78d1d60f74fa2582a4c7564756278bb92a9403d2 Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Tue, 12 Nov 2013 11:23:06 -0700
Subject: [PATCH 097/184] Add clarification of multiple "go test" calls in
 hack/make/*test Upstream-commit: 5cdb3aec507d9df7bb98366f04c4303a2172cbd5
 Component: engine

---
 components/engine/hack/make/dyntest | 5 +++++
 components/engine/hack/make/test    | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/components/engine/hack/make/dyntest b/components/engine/hack/make/dyntest
index 7de144e8db..ff607d3910 100644
--- a/components/engine/hack/make/dyntest
+++ b/components/engine/hack/make/dyntest
@@ -22,7 +22,12 @@ bundle_test() {
 		for test_dir in $(find_test_dirs); do (
 			set -x
 			cd $test_dir
+			
+			# Install packages that are dependencies of the tests.
+			#   Note: Does not run the tests.
 			go test -i -ldflags "$LDFLAGS" $BUILDFLAGS
+			
+			# Run the tests with the optional $TESTFLAGS.
 			export TEST_DOCKERINIT_PATH=$DEST/../dynbinary/dockerinit-$VERSION
 			go test -v -ldflags "$LDFLAGS -X github.com/dotcloud/docker/utils.INITSHA1 \"$DOCKER_INITSHA1\"" $BUILDFLAGS $TESTFLAGS
 		)  done
diff --git a/components/engine/hack/make/test b/components/engine/hack/make/test
index 8acd63461d..45ffe87fbd 100644
--- a/components/engine/hack/make/test
+++ b/components/engine/hack/make/test
@@ -16,7 +16,12 @@ bundle_test() {
 		for test_dir in $(find_test_dirs); do (
 			set -x
 			cd $test_dir
+			
+			# Install packages that are dependencies of the tests.
+			#   Note: Does not run the tests.
 			go test -i -ldflags "$LDFLAGS $LDFLAGS_STATIC" $BUILDFLAGS
+			
+			# Run the tests with the optional $TESTFLAGS.
 			go test -v -ldflags "$LDFLAGS $LDFLAGS_STATIC" $BUILDFLAGS $TESTFLAGS
 		)  done
 	} 2>&1 | tee $DEST/test.log

From c52a89950ab91116a032b0cb2b0a299e6b4952d4 Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Tue, 12 Nov 2013 21:51:12 -0700
Subject: [PATCH 098/184] Update to go1.2rc4 Upstream-commit:
 8523d5518c500903c19a53f73c653318e4db38f9 Component: engine

---
 components/engine/Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/Dockerfile b/components/engine/Dockerfile
index 9bfa266a22..a8b2f2e00e 100644
--- a/components/engine/Dockerfile
+++ b/components/engine/Dockerfile
@@ -36,7 +36,7 @@ run	apt-get install -y -q mercurial
 run apt-get install -y -q build-essential libsqlite3-dev
 
 # Install Go
-run	curl -s https://go.googlecode.com/files/go1.2rc3.src.tar.gz | tar -v -C /usr/local -xz
+run	curl -s https://go.googlecode.com/files/go1.2rc4.src.tar.gz | tar -v -C /usr/local -xz
 env	PATH	/usr/local/go/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
 env	GOPATH	/go:/go/src/github.com/dotcloud/docker/vendor
 run cd /usr/local/go/src && ./make.bash && go install -ldflags '-w -linkmode external -extldflags "-static -Wl,--unresolved-symbols=ignore-in-shared-libs"' -tags netgo -a std

From 9f0beed503748da3f37f2f604c29bf0429780702 Mon Sep 17 00:00:00 2001
From: Liang-Chi Hsieh <viirya@gmail.com>
Date: Thu, 31 Oct 2013 23:49:30 +0800
Subject: [PATCH 099/184] skip the volumes mounted when deleting the volumes of
 container. Upstream-commit: 6a693176d6b2dbf4afd36ebda2aeb9495fdf42bc
 Component: engine

---
 components/engine/server.go | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index 6a5d0a3294..d790787d6c 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -1104,8 +1104,12 @@ func (srv *Server) ContainerDestroy(name string, removeVolume, removeLink bool)
 		volumes := make(map[string]struct{})
 		// Store all the deleted containers volumes
 		for _, volumeId := range container.Volumes {
-			volumeId = strings.TrimRight(volumeId, "/layer")
-			volumeId = filepath.Base(volumeId)
+                        trim_volumeId := strings.TrimSuffix(volumeId, "/layer")
+			// Skip the volumes mounted
+                        if trim_volumeId == volumeId {
+                                continue
+                        }
+                        volumeId = filepath.Base(trim_volumeId)
 			volumes[volumeId] = struct{}{}
 		}
 		if err := srv.runtime.Destroy(container); err != nil {

From d033d0366cedc90e4d94c41aefb5555370314b5b Mon Sep 17 00:00:00 2001
From: Liang-Chi Hsieh <viirya@gmail.com>
Date: Wed, 13 Nov 2013 14:59:24 +0800
Subject: [PATCH 100/184] use Binds key in hostConfig to detect volumes mounted
 from external. Upstream-commit: 1d7f22c0d4bb55cf797b303cc46b1944509e4085
 Component: engine

---
 components/engine/server.go | 23 +++++++++++++++++------
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index d790787d6c..b7f16fe9a4 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -1102,14 +1102,25 @@ func (srv *Server) ContainerDestroy(name string, removeVolume, removeLink bool)
 			return fmt.Errorf("Impossible to remove a running container, please stop it first")
 		}
 		volumes := make(map[string]struct{})
+
+		binds := make(map[string]struct{})
+
+		for _, bind := range container.hostConfig.Binds {
+			splitBind := strings.Split(bind, ":")
+			source := splitBind[0]
+			binds[source] = struct{}{}
+		}
+
 		// Store all the deleted containers volumes
 		for _, volumeId := range container.Volumes {
-                        trim_volumeId := strings.TrimSuffix(volumeId, "/layer")
-			// Skip the volumes mounted
-                        if trim_volumeId == volumeId {
-                                continue
-                        }
-                        volumeId = filepath.Base(trim_volumeId)
+
+			// Skip the volumes mounted from external
+			if _, exists := binds[volumeId]; exists {
+				continue
+			}
+
+			volumeId = strings.TrimSuffix(volumeId, "/layer")
+			volumeId = filepath.Base(volumeId)
 			volumes[volumeId] = struct{}{}
 		}
 		if err := srv.runtime.Destroy(container); err != nil {

From d85082acd3b268d72d971174078cde275d33e8fa Mon Sep 17 00:00:00 2001
From: Xiuming Chen <cc@cxm.cc>
Date: Wed, 13 Nov 2013 01:29:00 -0800
Subject: [PATCH 101/184] Minor code simplification for Containers api
 Upstream-commit: 0013aa7d9f74eab1c6d02cf9f7b35a1b9364b17a Component: engine

---
 components/engine/server.go | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index 6a5d0a3294..a83463144f 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -464,14 +464,11 @@ func (srv *Server) Containers(all, size bool, n int, since, before string) []API
 		if !container.State.Running && !all && n == -1 && since == "" && before == "" {
 			continue
 		}
-		if before != "" {
+		if before != "" && !foundBefore {
 			if container.ID == before || utils.TruncateID(container.ID) == before {
 				foundBefore = true
-				continue
-			}
-			if !foundBefore {
-				continue
 			}
+			continue
 		}
 		if displayed == n {
 			break

From b5a0f0ad5b5d1897fcc636ec621fee44b1861b51 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C2=A8Sven?= <¨SvenDowideit@home.org.au¨>
Date: Wed, 13 Nov 2013 22:09:44 +1000
Subject: [PATCH 102/184] update the v1.7 API to reflect the case change in the
 /index/search response, and note that its to align better with the registry
 server response that its proxying Upstream-commit:
 f0f8462d18cf2efc44ee48cfdd2706e8a4a800d6 Component: engine

---
 .../sources/api/docker_remote_api_v1.7.rst    | 41 +++++++++++++------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/components/engine/docs/sources/api/docker_remote_api_v1.7.rst b/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
index 3985f7aa0a..0e848d46b0 100644
--- a/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
+++ b/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
@@ -914,7 +914,12 @@ Search images
 
 .. http:get:: /images/search
 
-	Search for an image in the docker index
+	Search for an image in the docker index.
+	
+	.. note::
+	
+	   The response keys have changed from API v1.6 to reflect the JSON 
+	   sent by the registry server to the docker daemon's request.
 	
 	**Example request**:
 
@@ -930,18 +935,28 @@ Search images
 	   Content-Type: application/json
 	   
 	   [
-		{
-			"Name":"cespare/sshd",
-			"Description":""
-		},
-		{
-			"Name":"johnfuller/sshd",
-			"Description":""
-		},
-		{
-			"Name":"dhrp/mongodb-sshd",
-			"Description":""
-		}
+		   {
+		       "description": "",
+		       "is_official": false,
+		       "is_trusted": false,
+		       "name": "wma55/u1210sshd",
+		       "star_count": 0
+		   },
+		   {
+		       "description": "",
+		       "is_official": false,
+		       "is_trusted": false,
+		       "name": "jdswinbank/sshd",
+		       "star_count": 0
+		   },
+		   {
+		       "description": "",
+		       "is_official": false,
+		       "is_trusted": false,
+		       "name": "vgauthier/sshd",
+		       "star_count": 0
+		   }
+	   ...
 	   ]
 
 	   :query term: term to search

From 172689d6bbc1af57ab60700ac301126598d8a516 Mon Sep 17 00:00:00 2001
From: Freek Kalter <freek@kalteronline.org>
Date: Wed, 13 Nov 2013 13:20:38 +0100
Subject: [PATCH 103/184] fix error in python webapp example

When getting the private port used by a container using
`docker port` returns 0.0.0.0:49353, stript just the portnumber of the address with awk to used it in the rest of the example code.
Upstream-commit: f5e6c2d060d5eb052929c4ab14bf3256b260afc4
Component: engine
---
 components/engine/docs/sources/examples/python_web_app.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/docs/sources/examples/python_web_app.rst b/components/engine/docs/sources/examples/python_web_app.rst
index c707fcdec6..e3f5f5eb83 100644
--- a/components/engine/docs/sources/examples/python_web_app.rst
+++ b/components/engine/docs/sources/examples/python_web_app.rst
@@ -86,7 +86,7 @@ http://0.0.0.0:5000/`` in the log output.
 
 .. code-block:: bash
 
-    WEB_PORT=$(sudo docker port $WEB_WORKER 5000)
+    WEB_PORT=$(sudo docker port $WEB_WORKER 5000 | awk -F: '{ print $2 }')
 
 Look up the public-facing port which is NAT-ed. Find the private port
 used by the container and store it inside of the ``WEB_PORT`` variable.

From 6d93aad6a7a4063eb4054414707b6392adde9a8f Mon Sep 17 00:00:00 2001
From: inglesp <peter.inglesby@gmail.com>
Date: Wed, 13 Nov 2013 12:32:49 +0000
Subject: [PATCH 104/184] Typo in ROADMAP.md Upstream-commit:
 87b4bb9fcc41806da4ed3151e74511120c099115 Component: engine

---
 components/engine/hack/ROADMAP.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/hack/ROADMAP.md b/components/engine/hack/ROADMAP.md
index e7dbf80a8a..01fac1f712 100644
--- a/components/engine/hack/ROADMAP.md
+++ b/components/engine/hack/ROADMAP.md
@@ -5,7 +5,7 @@ It is a curated selection of planned improvements which are either important, di
 
 For a more complete view of planned and requested improvements, see [the Github issues](https://github.com/dotcloud/docker/issues).
 
-Tu suggest changes to the roadmap, including additions, please write the change as if it were already in effect, and make a pull request.
+To suggest changes to the roadmap, including additions, please write the change as if it were already in effect, and make a pull request.
 
 
 ## Container wiring and service discovery

From 59d38006c93d6008f0b29e950a2a20ca99b00911 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C2=A8Sven?= <¨SvenDowideit@home.org.au¨>
Date: Wed, 13 Nov 2013 22:55:55 +1000
Subject: [PATCH 105/184] add a little more info about the limitations of ADD
 wrt ../ and docker build - Upstream-commit:
 af0b2e38c3b2688cd4c2e831847bf4601d8fc149 Component: engine

---
 components/engine/docs/sources/use/builder.rst | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/components/engine/docs/sources/use/builder.rst b/components/engine/docs/sources/use/builder.rst
index e48f3f2a48..18c52ec09f 100644
--- a/components/engine/docs/sources/use/builder.rst
+++ b/components/engine/docs/sources/use/builder.rst
@@ -221,8 +221,16 @@ destination container.
 All new files and directories are created with mode 0755, uid and gid
 0.
 
+.. note::
+   if you build using STDIN (``docker build - < somefile``), there is no build 
+   context, so the Dockerfile cannot contain an ADD statement.
+
 The copy obeys the following rules:
 
+* The ``<src>`` path must be inside the *context* of the build; you cannot 
+  ``ADD ../something /something``, because the first step of a 
+  ``docker build`` is to send the context directory (and subdirectories) to 
+  the docker daemon.
 * If ``<src>`` is a URL and ``<dest>`` does not end with a trailing slash,
   then a file is downloaded from the URL and copied to ``<dest>``.
 * If ``<src>`` is a URL and ``<dest>`` does end with a trailing slash,

From a905d364a80831a3e06b507d4d250854d8526f4c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Petazzoni?= <jp@enix.org>
Date: Wed, 13 Nov 2013 10:29:29 -0800
Subject: [PATCH 106/184] Add warning about SYS_BOOT capability with pre-3.4
 kernels and pre-0.8 LXC. Upstream-commit:
 8145e57cee6390bb27d7fb07fe5f572affe5d0cd Component: engine

---
 components/engine/docs/sources/installation/kernel.rst | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/components/engine/docs/sources/installation/kernel.rst b/components/engine/docs/sources/installation/kernel.rst
index 2959fa4fcd..9d995ff018 100644
--- a/components/engine/docs/sources/installation/kernel.rst
+++ b/components/engine/docs/sources/installation/kernel.rst
@@ -25,6 +25,7 @@ If you cannot or do not want to use the "official" kernels,
 here is some technical background about the features (both optional and
 mandatory) that docker needs to run successfully.
 
+
 Linux version 3.8 or above
 --------------------------
 
@@ -39,6 +40,15 @@ The symptoms include:
 - kernel crash causing the machine to freeze for a few minutes, or even
   completely.
 
+Additionally, kernels prior 3.4 did not implement ``reboot_pid_ns``,
+which means that the ``reboot()`` syscall could reboot the host machine,
+instead of terminating the container. To work around that problem,
+LXC userland tools (since version 0.8) automatically drop the ``SYS_BOOT``
+capability when necessary. Still, if you run a pre-3.4 kernel with pre-0.8
+LXC tools, be aware that containers can reboot the whole host! This is
+not something that Docker wants to address in the short term, since you
+shouldn't use kernels prior 3.8 with Docker anyway.
+
 While it is still possible to use older kernels for development, it is
 really not advised to do so.
 

From 01395ce3bb97f8dee374993f07bda9e441709ad9 Mon Sep 17 00:00:00 2001
From: Ryan Seto <ryanseto@yak.net>
Date: Wed, 13 Nov 2013 13:34:34 -0500
Subject: [PATCH 107/184] Add more depth to the upstart example in
 host_integration.rst

I found that the original example wasn't starting the docker container when docker is started.  So, I modified it using information I found from https://groups.google.com/forum/#!msg/docker-user/OWz8EOpiXuo/L_uxGFQuYlkJ

Also, upstart wasn't starting docker if it wasn't running ahead of time.  So, I added a change to the docker upstart script to solve this.
Upstream-commit: 02884ee42971be141edde8964d72a2d2c7f63cfe
Component: engine
---
 .../docs/sources/use/host_integration.rst     | 31 ++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/components/engine/docs/sources/use/host_integration.rst b/components/engine/docs/sources/use/host_integration.rst
index 92012df3d6..b51b2efcfe 100644
--- a/components/engine/docs/sources/use/host_integration.rst
+++ b/components/engine/docs/sources/use/host_integration.rst
@@ -29,6 +29,10 @@ Here are a few sample scripts for systemd and upstart to integrate with docker.
 Sample Upstart Script
 ---------------------
 
+In this example we've already created a container to run Redis with an id of
+0a7e070b698b.  To create an upstart script for our container, we create a file
+named ``/etc/init/redis.conf`` and place the following into it:
+
 .. code-block:: bash
 
    description "Redis container"
@@ -36,7 +40,32 @@ Sample Upstart Script
    start on filesystem and started lxc-net and started docker
    stop on runlevel [!2345]
    respawn
-   exec docker start -a 0a7e070b698b
+   script
+     # Wait for docker to finish starting up first.
+     FILE=/var/run/docker.sock
+     while [ ! -e $FILE ] ; do
+       inotifywait -t 2 -e create $(dirname $FILE)
+     done
+     /usr/bin/docker start -a 0a7e070b698b
+   end script
+
+Next, we have to edit the docker upstart script (``/etc/init/docker.conf``)
+so that we run docker with ``-r=false``.  In this example, we also ensure
+that docker will start running before *redis* is started.
+
+.. code-block:: bash
+
+   description "Docker daemon"
+
+   start on filesystem and started lxc-net
+   start on (starting redis)
+   stop on runlevel [!2345]
+
+   respawn
+
+   script
+   	/usr/bin/docker -d -r=false
+   end script
 
 
 Sample systemd Script

From cea9cd65541659e86467ecdf7a3b0f45984c2b56 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Wed, 13 Nov 2013 19:25:55 +0000
Subject: [PATCH 108/184] gofmt Upstream-commit:
 b00d5f018541bf141dc4732ad6d71d23b8c28b43 Component: engine

---
 components/engine/engine/engine.go    | 27 +++++++++---------
 components/engine/engine/hack.go      |  2 --
 components/engine/engine/job.go       | 41 ++++++++++++++-------------
 components/engine/runtime_test.go     |  6 ++--
 components/engine/server.go           | 35 +++++++++++------------
 components/engine/server_test.go      |  2 +-
 components/engine/utils/utils_test.go | 18 ++++++------
 components/engine/utils_test.go       |  3 +-
 8 files changed, 66 insertions(+), 68 deletions(-)

diff --git a/components/engine/engine/engine.go b/components/engine/engine/engine.go
index 09b599890b..edd04fc5c0 100644
--- a/components/engine/engine/engine.go
+++ b/components/engine/engine/engine.go
@@ -30,10 +30,10 @@ func Register(name string, handler Handler) error {
 // It acts as a store for *containers*, and allows manipulation of these
 // containers by executing *jobs*.
 type Engine struct {
-	root		string
-	handlers	map[string]Handler
-	hack		Hack	// data for temporary hackery (see hack.go)
-	id		string
+	root     string
+	handlers map[string]Handler
+	hack     Hack // data for temporary hackery (see hack.go)
+	id       string
 }
 
 func (eng *Engine) Root() string {
@@ -50,7 +50,6 @@ func (eng *Engine) Register(name string, handler Handler) error {
 	return nil
 }
 
-
 // New initializes a new engine managing the directory specified at `root`.
 // `root` is used to store containers and any other state private to the engine.
 // Changing the contents of the root without executing a job will cause unspecified
@@ -78,9 +77,9 @@ func New(root string) (*Engine, error) {
 		return nil, err
 	}
 	eng := &Engine{
-		root:		root,
-		handlers:	make(map[string]Handler),
-		id:		utils.RandomString(),
+		root:     root,
+		handlers: make(map[string]Handler),
+		id:       utils.RandomString(),
 	}
 	// Copy existing global handlers
 	for k, v := range globalHandlers {
@@ -97,12 +96,12 @@ func (eng *Engine) String() string {
 // This function mimics `Command` from the standard os/exec package.
 func (eng *Engine) Job(name string, args ...string) *Job {
 	job := &Job{
-		Eng:		eng,
-		Name:		name,
-		Args:		args,
-		Stdin:		os.Stdin,
-		Stdout:		os.Stdout,
-		Stderr:		os.Stderr,
+		Eng:    eng,
+		Name:   name,
+		Args:   args,
+		Stdin:  os.Stdin,
+		Stdout: os.Stdout,
+		Stderr: os.Stderr,
 	}
 	handler, exists := eng.handlers[name]
 	if exists {
diff --git a/components/engine/engine/hack.go b/components/engine/engine/hack.go
index 7f6e79c0e9..be4fadbe6e 100644
--- a/components/engine/engine/hack.go
+++ b/components/engine/engine/hack.go
@@ -1,9 +1,7 @@
 package engine
 
-
 type Hack map[string]interface{}
 
-
 func (eng *Engine) Hack_GetGlobalVar(key string) interface{} {
 	if eng.hack == nil {
 		return nil
diff --git a/components/engine/engine/job.go b/components/engine/engine/job.go
index ed41f6c5c4..c4a2c3ef52 100644
--- a/components/engine/engine/job.go
+++ b/components/engine/engine/job.go
@@ -3,14 +3,14 @@ package engine
 import (
 	"bufio"
 	"bytes"
+	"encoding/json"
+	"fmt"
 	"io"
 	"io/ioutil"
+	"os"
 	"strconv"
 	"strings"
-	"fmt"
 	"sync"
-	"encoding/json"
-	"os"
 )
 
 // A job is the fundamental unit of work in the docker engine.
@@ -27,16 +27,16 @@ import (
 // This allows for richer error reporting.
 //
 type Job struct {
-	Eng	*Engine
-	Name	string
-	Args	[]string
-	env	[]string
-	Stdin	io.Reader
-	Stdout	io.Writer
-	Stderr	io.Writer
-	handler	func(*Job) string
-	status	string
-	onExit	[]func()
+	Eng     *Engine
+	Name    string
+	Args    []string
+	env     []string
+	Stdin   io.Reader
+	Stdout  io.Writer
+	Stderr  io.Writer
+	handler func(*Job) string
+	status  string
+	onExit  []func()
 }
 
 // Run executes the job and blocks until the job completes.
@@ -106,30 +106,33 @@ func (job *Job) parseLines(src io.Reader, dst *[]string, limit int) {
 func (job *Job) StdoutParseString(dst *string) {
 	lines := make([]string, 0, 1)
 	job.StdoutParseLines(&lines, 1)
-	job.onExit = append(job.onExit, func() { if len(lines) >= 1 { *dst = lines[0] }})
+	job.onExit = append(job.onExit, func() {
+		if len(lines) >= 1 {
+			*dst = lines[0]
+		}
+	})
 }
 
 func (job *Job) StderrParseString(dst *string) {
 	lines := make([]string, 0, 1)
 	job.StderrParseLines(&lines, 1)
-	job.onExit = append(job.onExit, func() { *dst = lines[0]; })
+	job.onExit = append(job.onExit, func() { *dst = lines[0] })
 }
 
 func (job *Job) StdoutPipe() io.ReadCloser {
 	r, w := io.Pipe()
 	job.Stdout = w
-	job.onExit = append(job.onExit, func(){ w.Close() })
+	job.onExit = append(job.onExit, func() { w.Close() })
 	return r
 }
 
 func (job *Job) StderrPipe() io.ReadCloser {
 	r, w := io.Pipe()
 	job.Stderr = w
-	job.onExit = append(job.onExit, func(){ w.Close() })
+	job.onExit = append(job.onExit, func() { w.Close() })
 	return r
 }
 
-
 func (job *Job) CallString() string {
 	return fmt.Sprintf("%s(%s)", job.Name, strings.Join(job.Args, ", "))
 }
@@ -242,7 +245,7 @@ func (job *Job) DecodeEnv(src io.Reader) error {
 			job.SetenvInt(k, int64(fval))
 		} else if sval, ok := v.(string); ok {
 			job.Setenv(k, sval)
-		} else	if val, err := json.Marshal(v); err == nil {
+		} else if val, err := json.Marshal(v); err == nil {
 			job.Setenv(k, string(val))
 		} else {
 			job.Setenv(k, fmt.Sprintf("%v", v))
diff --git a/components/engine/runtime_test.go b/components/engine/runtime_test.go
index 886f107198..6a365d338d 100644
--- a/components/engine/runtime_test.go
+++ b/components/engine/runtime_test.go
@@ -9,6 +9,7 @@ import (
 	"io"
 	"log"
 	"net"
+	"net/url"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -18,7 +19,6 @@ import (
 	"syscall"
 	"testing"
 	"time"
-	"net/url"
 )
 
 const (
@@ -158,8 +158,8 @@ func spawnGlobalDaemon() {
 	go func() {
 		utils.Debugf("Spawning global daemon for integration tests")
 		listenURL := &url.URL{
-			Scheme:	testDaemonProto,
-			Host:	testDaemonAddr,
+			Scheme: testDaemonProto,
+			Host:   testDaemonAddr,
 		}
 		job := eng.Job("serveapi", listenURL.String())
 		job.SetenvBool("Logging", os.Getenv("DEBUG") != "")
diff --git a/components/engine/server.go b/components/engine/server.go
index 66c898cbd8..28858d6f6b 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -74,7 +74,6 @@ func jobInitApi(job *engine.Job) string {
 	return "0"
 }
 
-
 func (srv *Server) ListenAndServe(job *engine.Job) string {
 	protoAddrs := job.Args
 	chErrors := make(chan error, len(protoAddrs))
@@ -1388,25 +1387,25 @@ func (srv *Server) ContainerStart(job *engine.Job) string {
 			return err.Error()
 		}
 		// Validate the HostConfig binds. Make sure that:
-                // 1) the source of a bind mount isn't /
-                //         The bind mount "/:/foo" isn't allowed.
-                // 2) Check that the source exists
-                //        The source to be bind mounted must exist.
-                for _, bind := range hostConfig.Binds {
-                        splitBind := strings.Split(bind, ":")
-                        source := splitBind[0]
+		// 1) the source of a bind mount isn't /
+		//         The bind mount "/:/foo" isn't allowed.
+		// 2) Check that the source exists
+		//        The source to be bind mounted must exist.
+		for _, bind := range hostConfig.Binds {
+			splitBind := strings.Split(bind, ":")
+			source := splitBind[0]
 
-                        // refuse to bind mount "/" to the container
-                        if source == "/" {
-                                return fmt.Sprintf("Invalid bind mount '%s' : source can't be '/'", bind)
-                        }
+			// refuse to bind mount "/" to the container
+			if source == "/" {
+				return fmt.Sprintf("Invalid bind mount '%s' : source can't be '/'", bind)
+			}
 
-                        // ensure the source exists on the host
-                        _, err := os.Stat(source)
-                        if err != nil && os.IsNotExist(err) {
-                                return fmt.Sprintf("Invalid bind mount '%s' : source doesn't exist", bind)
-                        }
-                }
+			// ensure the source exists on the host
+			_, err := os.Stat(source)
+			if err != nil && os.IsNotExist(err) {
+				return fmt.Sprintf("Invalid bind mount '%s' : source doesn't exist", bind)
+			}
+		}
 		// Register any links from the host config before starting the container
 		// FIXME: we could just pass the container here, no need to lookup by name again.
 		if err := srv.RegisterLinks(name, &hostConfig); err != nil {
diff --git a/components/engine/server_test.go b/components/engine/server_test.go
index e9dba2eefc..1ab38422f5 100644
--- a/components/engine/server_test.go
+++ b/components/engine/server_test.go
@@ -2,8 +2,8 @@ package docker
 
 import (
 	"github.com/dotcloud/docker/utils"
-	"strings"
 	"io/ioutil"
+	"strings"
 	"testing"
 	"time"
 )
diff --git a/components/engine/utils/utils_test.go b/components/engine/utils/utils_test.go
index 09b15c73bc..350ebb911f 100644
--- a/components/engine/utils/utils_test.go
+++ b/components/engine/utils/utils_test.go
@@ -266,23 +266,23 @@ func TestHumanSize(t *testing.T) {
 }
 
 func TestRAMInBytes(t *testing.T) {
-	assertRAMInBytes(t, "32",   false, 32)
-	assertRAMInBytes(t, "32b",  false, 32)
-	assertRAMInBytes(t, "32B",  false, 32)
-	assertRAMInBytes(t, "32k",  false, 32*1024)
-	assertRAMInBytes(t, "32K",  false, 32*1024)
+	assertRAMInBytes(t, "32", false, 32)
+	assertRAMInBytes(t, "32b", false, 32)
+	assertRAMInBytes(t, "32B", false, 32)
+	assertRAMInBytes(t, "32k", false, 32*1024)
+	assertRAMInBytes(t, "32K", false, 32*1024)
 	assertRAMInBytes(t, "32kb", false, 32*1024)
 	assertRAMInBytes(t, "32Kb", false, 32*1024)
 	assertRAMInBytes(t, "32Mb", false, 32*1024*1024)
 	assertRAMInBytes(t, "32Gb", false, 32*1024*1024*1024)
 
-	assertRAMInBytes(t, "",      true, -1)
+	assertRAMInBytes(t, "", true, -1)
 	assertRAMInBytes(t, "hello", true, -1)
-	assertRAMInBytes(t, "-32",   true, -1)
-	assertRAMInBytes(t, " 32 ",  true, -1)
+	assertRAMInBytes(t, "-32", true, -1)
+	assertRAMInBytes(t, " 32 ", true, -1)
 	assertRAMInBytes(t, "32 mb", true, -1)
 	assertRAMInBytes(t, "32m b", true, -1)
-	assertRAMInBytes(t, "32bm",  true, -1)
+	assertRAMInBytes(t, "32bm", true, -1)
 }
 
 func assertRAMInBytes(t *testing.T, size string, expectError bool, expectedBytes int64) {
diff --git a/components/engine/utils_test.go b/components/engine/utils_test.go
index c3f282f169..a9678a9bbd 100644
--- a/components/engine/utils_test.go
+++ b/components/engine/utils_test.go
@@ -27,7 +27,7 @@ func mkRuntime(f utils.Fataler) *Runtime {
 		f.Fatal(err)
 	}
 	config := &DaemonConfig{
-		Root:   root,
+		Root:        root,
 		AutoRestart: false,
 	}
 	r, err := NewRuntimeFromDirectory(config)
@@ -66,7 +66,6 @@ func mkServerFromEngine(eng *engine.Engine, t utils.Fataler) *Server {
 	return srv
 }
 
-
 func NewTestEngine(t utils.Fataler) *engine.Engine {
 	root, err := newTestDirectory(unitTestStoreBase)
 	if err != nil {

From 687d57d2f08cb7cd336b2b4883cbca083f5a8493 Mon Sep 17 00:00:00 2001
From: Thatcher Peskens <thatcher@dotcloud.com>
Date: Wed, 13 Nov 2013 16:09:23 -0800
Subject: [PATCH 109/184] Updated documentation footer to say "Docker Inc."
 instead of dotCloud. And added link to Read the Docs for giving them credit
 to hosting us. (Thanks Read The Docs!) Upstream-commit:
 9ab85f4d1220d04a3b682d5612ff27db5983f5d3 Component: engine

---
 components/engine/docs/theme/docker/layout.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/components/engine/docs/theme/docker/layout.html b/components/engine/docs/theme/docker/layout.html
index 193df7447f..ee80341cfe 100755
--- a/components/engine/docs/theme/docker/layout.html
+++ b/components/engine/docs/theme/docker/layout.html
@@ -129,7 +129,8 @@
                 <div class="row footer">
                     <div class="span12 tbox">
                         <div class="tbox">
-                            <p>Docker is an open source project, sponsored by  <a href="https://dotcloud.com">dotCloud</a>, under the <a href="https://github.com/dotcloud/docker/blob/master/LICENSE" title="Docker licence, hosted in the Github repository">apache 2.0 licence</a></p>
+                            <p>Docker is an open source project, sponsored by  <a href="https://www.docker.com">Docker Inc.</a>, under the <a href="https://github.com/dotcloud/docker/blob/master/LICENSE" title="Docker licence, hosted in the Github repository">apache 2.0 licence</a></p>
+                            <p>Documentation proudly hosted by <a href="http://www.readthedocs.org">Read the Docs</a></p>
                         </div>
 
                         <div class="social links">

From 35545fd6bb68459507470f80e20d8fff95c26b49 Mon Sep 17 00:00:00 2001
From: Andy Rothfusz <github@metaliveblog.com>
Date: Wed, 13 Nov 2013 17:45:22 -0800
Subject: [PATCH 110/184] Clean up sphinx syntax, upgrade http markup package,
 minor link changes, update intro. Upstream-commit:
 059950b095a48c254a9f407f2bff13eaab7a7a1c Component: engine

---
 components/engine/docs/requirements.txt       |  2 +-
 .../sources/api/docker_remote_api_v1.7.rst    | 57 +++++++++++--------
 components/engine/docs/sources/use/basics.rst | 15 +++--
 3 files changed, 40 insertions(+), 34 deletions(-)

diff --git a/components/engine/docs/requirements.txt b/components/engine/docs/requirements.txt
index 9d1ce18f5c..095f7600cd 100644
--- a/components/engine/docs/requirements.txt
+++ b/components/engine/docs/requirements.txt
@@ -1,2 +1,2 @@
 Sphinx==1.1.3
-sphinxcontrib-httpdomain==1.1.8
\ No newline at end of file
+sphinxcontrib-httpdomain==1.1.9
diff --git a/components/engine/docs/sources/api/docker_remote_api_v1.7.rst b/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
index 0e848d46b0..13aa5df71b 100644
--- a/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
+++ b/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
@@ -13,9 +13,12 @@ Docker Remote API v1.7
 1. Brief introduction
 =====================
 
-- The Remote API is replacing rcli
-- Default port in the docker daemon is 4243
-- The API tends to be REST, but for some complex commands, like attach or pull, the HTTP connection is hijacked to transport stdout stdin and stderr
+- The Remote API has replaced rcli
+- The daemon listens on ``unix:///var/run/docker.sock``, but you can
+  :ref:`bind_docker`.
+- The API tends to be REST, but for some complex commands, like
+  ``attach`` or ``pull``, the HTTP connection is hijacked to transport
+  ``stdout, stdin`` and ``stderr``
 
 2. Endpoints
 ============
@@ -690,10 +693,12 @@ Create an image
         :query repo: repository
 	:query tag: tag
 	:query registry: the registry to pull from
+	:reqheader X-Registry-Auth: base64-encoded AuthConfig object
         :statuscode 200: no error
         :statuscode 500: server error
 
 
+
 Insert a file in an image
 *************************
 
@@ -835,18 +840,16 @@ Push an image on the registry
     HTTP/1.1 200 OK
     Content-Type: application/json
 
-   {"status":"Pushing..."}
-   {"status":"Pushing", "progress":"1/? (n/a)"}
-   {"error":"Invalid..."}
-   ...
-
-	The ``X-Registry-Auth`` header can be used to include a
-	base64-encoded AuthConfig object.
+    {"status":"Pushing..."}
+    {"status":"Pushing", "progress":"1/? (n/a)"}
+    {"error":"Invalid..."}
+    ...
 
    :query registry: the registry you wan to push, optional
+   :reqheader X-Registry-Auth: include a base64-encoded AuthConfig object.
    :statuscode 200: no error
-        :statuscode 404: no such image
-        :statuscode 500: server error
+   :statuscode 404: no such image
+   :statuscode 500: server error
 
 
 Tag an image into a repository
@@ -959,9 +962,9 @@ Search images
 	   ...
 	   ]
 
-	   :query term: term to search
-	   :statuscode 200: no error
-	   :statuscode 500: server error
+	:query term: term to search
+	:statuscode 200: no error
+	:statuscode 500: server error
 
 
 2.3 Misc
@@ -991,18 +994,22 @@ Build an image from Dockerfile via stdin
       {{ STREAM }}
 
 
-       The stream must be a tar archive compressed with one of the following algorithms:
-       identity (no compression), gzip, bzip2, xz. The archive must include a file called
-       `Dockerfile` at its root. It may include any number of other files, which will be
-       accessible in the build context (See the ADD build command).
+   The stream must be a tar archive compressed with one of the
+   following algorithms: identity (no compression), gzip, bzip2,
+   xz. 
 
-       The Content-type header should be set to "application/tar".
+   The archive must include a file called ``Dockerfile`` at its
+   root. It may include any number of other files, which will be
+   accessible in the build context (See the :ref:`ADD build command
+   <dockerbuilder>`).
+
+   :query t: repository name (and optionally a tag) to be applied to the resulting image in case of success
+   :query q: suppress verbose build output
+   :query nocache: do not use the cache when building the image
+   :reqheader Content-type: should be set to ``"application/tar"``.
+   :statuscode 200: no error
+   :statuscode 500: server error
 
-	:query t: repository name (and optionally a tag) to be applied to the resulting image in case of success
-	:query q: suppress verbose build output
-    :query nocache: do not use the cache when building the image
-	:statuscode 200: no error
-    :statuscode 500: server error
 
 
 Check auth configuration
diff --git a/components/engine/docs/sources/use/basics.rst b/components/engine/docs/sources/use/basics.rst
index d1ad081f99..4cc43a1f29 100644
--- a/components/engine/docs/sources/use/basics.rst
+++ b/components/engine/docs/sources/use/basics.rst
@@ -34,13 +34,11 @@ This will find the ``ubuntu`` image by name in the :ref:`Central Index
 <searching_central_index>` and download it from the top-level Central 
 Repository to a local image cache.
 
-.. NOTE:: When the image has successfully downloaded, you will see a 12 
-character hash ``539c0211cd76: Download complete`` which is the short 
-form of the image ID. These short image IDs are the first 12 characters 
-of the full image ID - which can be found using ``docker inspect`` or 
-``docker images -notrunc=true``
-
-.. _dockergroup:
+.. NOTE:: When the image has successfully downloaded, you will see a
+   12 character hash ``539c0211cd76: Download complete`` which is the
+   short form of the image ID. These short image IDs are the first 12
+   characters of the full image ID - which can be found using ``docker
+   inspect`` or ``docker images -notrunc=true``
 
 Running an interactive shell
 ----------------------------
@@ -53,6 +51,7 @@ Running an interactive shell
   # use the escape sequence Ctrl-p + Ctrl-q
   sudo docker run -i -t ubuntu /bin/bash
 
+.. _dockergroup:
 
 Why ``sudo``?
 -------------
@@ -87,7 +86,7 @@ you don't need to add ``sudo`` to all the client commands.
 Bind Docker to another host/port or a Unix socket
 -------------------------------------------------
 
-.. DANGER:: Changing the default ``docker`` daemon binding to a TCP
+.. warning:: Changing the default ``docker`` daemon binding to a TCP
    port or Unix *docker* user group will increase your security risks
    by allowing non-root users to potentially gain *root* access on the
    host (`e.g. #1369

From 7c37de4a146aabd65311011e67b6efa0a0655751 Mon Sep 17 00:00:00 2001
From: Vinod Kulkarni <vinod.kulkarni@gmail.com>
Date: Thu, 14 Nov 2013 09:54:31 +0530
Subject: [PATCH 111/184] Improvise documentation for builder.rst / VOLUME
 command Upstream-commit: 37abc07852874939aabe7ba9a346d4d893e40409 Component:
 engine

---
 components/engine/docs/sources/use/builder.rst | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/components/engine/docs/sources/use/builder.rst b/components/engine/docs/sources/use/builder.rst
index e48f3f2a48..970be30ce7 100644
--- a/components/engine/docs/sources/use/builder.rst
+++ b/components/engine/docs/sources/use/builder.rst
@@ -310,8 +310,9 @@ this optional but default, you could use a CMD:
 
     ``VOLUME ["/data"]``
 
-The ``VOLUME`` instruction will add one or more new volumes to any
-container created from the image.
+The ``VOLUME`` instruction will create a mount point with the specified name and mark it 
+as holding externally mounted volumes from native host or other containers. For more information/examples 
+and mounting instructions via docker client, refer to :ref:`volume_def` documentation. 
 
 3.10 USER
 ---------

From 7b5ae8dd36dbf7e3235c33893fde75575a6986b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C2=A8Sven?= <¨SvenDowideit@home.org.au¨>
Date: Thu, 14 Nov 2013 14:53:55 +1000
Subject: [PATCH 112/184] thankyou @tomdz - I forgot about URL based ADDs
 Upstream-commit: e42144674fb6eeb76bcda822105b049f7fb6ab30 Component: engine

---
 components/engine/docs/sources/use/builder.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/docs/sources/use/builder.rst b/components/engine/docs/sources/use/builder.rst
index 18c52ec09f..7c9d3397f2 100644
--- a/components/engine/docs/sources/use/builder.rst
+++ b/components/engine/docs/sources/use/builder.rst
@@ -223,7 +223,7 @@ All new files and directories are created with mode 0755, uid and gid
 
 .. note::
    if you build using STDIN (``docker build - < somefile``), there is no build 
-   context, so the Dockerfile cannot contain an ADD statement.
+   context, so the Dockerfile can only contain an URL based ADD statement.
 
 The copy obeys the following rules:
 

From 6c1679864e902d08d54618692c9bbf4b1a27435d Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Thu, 14 Nov 2013 06:08:08 +0000
Subject: [PATCH 113/184] Move integration tests to integration/, expose
 missing public methods in the core Upstream-commit:
 359a6f49b9ec704686d0cb0df7cb0d7c8d5f55a7 Component: engine

---
 components/engine/api.go                      |  16 +-
 components/engine/commands.go                 |   4 +-
 components/engine/config_test.go              | 149 ++++++++++
 components/engine/container_unit_test.go      | 257 ++++++++++++++++++
 components/engine/engine/job.go               |   6 +-
 components/engine/http_test.go                |  52 ++++
 .../engine/{ => integration}/api_test.go      |   0
 .../{ => integration}/buildfile_test.go       |   0
 .../engine/{ => integration}/commands_test.go |   0
 .../{ => integration}/container_test.go       |   0
 .../engine/{ => integration}/runtime_test.go  |   0
 .../engine/{ => integration}/server_test.go   |   0
 .../engine/{ => integration}/sorter_test.go   |   0
 .../engine/{ => integration}/utils_test.go    |   0
 .../engine/{ => integration}/z_final_test.go  |   0
 components/engine/runtime.go                  |  34 +++
 components/engine/server.go                   |  13 +-
 components/engine/server_unit_test.go         | 110 ++++++++
 components/engine/sorter_unit_test.go         |  41 +++
 components/engine/tags_unit_test.go           |  81 ++++++
 components/engine/utils/utils.go              |  40 +++
 21 files changed, 797 insertions(+), 6 deletions(-)
 create mode 100644 components/engine/config_test.go
 create mode 100644 components/engine/container_unit_test.go
 create mode 100644 components/engine/http_test.go
 rename components/engine/{ => integration}/api_test.go (100%)
 rename components/engine/{ => integration}/buildfile_test.go (100%)
 rename components/engine/{ => integration}/commands_test.go (100%)
 rename components/engine/{ => integration}/container_test.go (100%)
 rename components/engine/{ => integration}/runtime_test.go (100%)
 rename components/engine/{ => integration}/server_test.go (100%)
 rename components/engine/{ => integration}/sorter_test.go (100%)
 rename components/engine/{ => integration}/utils_test.go (100%)
 rename components/engine/{ => integration}/z_final_test.go (100%)
 create mode 100644 components/engine/server_unit_test.go
 create mode 100644 components/engine/sorter_unit_test.go
 create mode 100644 components/engine/tags_unit_test.go

diff --git a/components/engine/api.go b/components/engine/api.go
index c5a91de5b5..5e16e7778c 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -927,7 +927,7 @@ func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Requ
 		if err != nil {
 			return err
 		}
-		c, err := mkBuildContext(string(dockerFile), nil)
+		c, err := MkBuildContext(string(dockerFile), nil)
 		if err != nil {
 			return err
 		}
@@ -1105,6 +1105,20 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 	return r, nil
 }
 
+// ServeRequest processes a single http request to the docker remote api.
+// FIXME: refactor this to be part of Server and not require re-creating a new
+// router each time. This requires first moving ListenAndServe into Server.
+func ServeRequest(srv *Server, apiversion float64, w http.ResponseWriter, req *http.Request) error {
+	router, err := createRouter(srv, false)
+	if err != nil {
+		return err
+	}
+	// Insert APIVERSION into the request as a convenience
+	req.URL.Path = fmt.Sprintf("/v%g%s", apiversion, req.URL.Path)
+	router.ServeHTTP(w, req)
+	return nil
+}
+
 func ListenAndServe(proto, addr string, srv *Server, logging bool) error {
 	log.Printf("Listening for HTTP on %s (%s)\n", addr, proto)
 
diff --git a/components/engine/commands.go b/components/engine/commands.go
index 9d144d8aeb..710a311c08 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -135,7 +135,7 @@ func (cli *DockerCli) CmdInsert(args ...string) error {
 
 // mkBuildContext returns an archive of an empty context with the contents
 // of `dockerfile` at the path ./Dockerfile
-func mkBuildContext(dockerfile string, files [][2]string) (archive.Archive, error) {
+func MkBuildContext(dockerfile string, files [][2]string) (archive.Archive, error) {
 	buf := new(bytes.Buffer)
 	tw := tar.NewWriter(buf)
 	files = append(files, [2]string{"Dockerfile", dockerfile})
@@ -185,7 +185,7 @@ func (cli *DockerCli) CmdBuild(args ...string) error {
 		if err != nil {
 			return err
 		}
-		context, err = mkBuildContext(string(dockerfile), nil)
+		context, err = MkBuildContext(string(dockerfile), nil)
 	} else if utils.IsURL(cmd.Arg(0)) || utils.IsGIT(cmd.Arg(0)) {
 		isRemote = true
 	} else {
diff --git a/components/engine/config_test.go b/components/engine/config_test.go
new file mode 100644
index 0000000000..31c961135a
--- /dev/null
+++ b/components/engine/config_test.go
@@ -0,0 +1,149 @@
+package docker
+
+import (
+	"testing"
+)
+
+func TestCompareConfig(t *testing.T) {
+	volumes1 := make(map[string]struct{})
+	volumes1["/test1"] = struct{}{}
+	config1 := Config{
+		Dns:         []string{"1.1.1.1", "2.2.2.2"},
+		PortSpecs:   []string{"1111:1111", "2222:2222"},
+		Env:         []string{"VAR1=1", "VAR2=2"},
+		VolumesFrom: "11111111",
+		Volumes:     volumes1,
+	}
+	config2 := Config{
+		Dns:         []string{"0.0.0.0", "2.2.2.2"},
+		PortSpecs:   []string{"1111:1111", "2222:2222"},
+		Env:         []string{"VAR1=1", "VAR2=2"},
+		VolumesFrom: "11111111",
+		Volumes:     volumes1,
+	}
+	config3 := Config{
+		Dns:         []string{"1.1.1.1", "2.2.2.2"},
+		PortSpecs:   []string{"0000:0000", "2222:2222"},
+		Env:         []string{"VAR1=1", "VAR2=2"},
+		VolumesFrom: "11111111",
+		Volumes:     volumes1,
+	}
+	config4 := Config{
+		Dns:         []string{"1.1.1.1", "2.2.2.2"},
+		PortSpecs:   []string{"0000:0000", "2222:2222"},
+		Env:         []string{"VAR1=1", "VAR2=2"},
+		VolumesFrom: "22222222",
+		Volumes:     volumes1,
+	}
+	volumes2 := make(map[string]struct{})
+	volumes2["/test2"] = struct{}{}
+	config5 := Config{
+		Dns:         []string{"1.1.1.1", "2.2.2.2"},
+		PortSpecs:   []string{"0000:0000", "2222:2222"},
+		Env:         []string{"VAR1=1", "VAR2=2"},
+		VolumesFrom: "11111111",
+		Volumes:     volumes2,
+	}
+	if CompareConfig(&config1, &config2) {
+		t.Fatalf("CompareConfig should return false, Dns are different")
+	}
+	if CompareConfig(&config1, &config3) {
+		t.Fatalf("CompareConfig should return false, PortSpecs are different")
+	}
+	if CompareConfig(&config1, &config4) {
+		t.Fatalf("CompareConfig should return false, VolumesFrom are different")
+	}
+	if CompareConfig(&config1, &config5) {
+		t.Fatalf("CompareConfig should return false, Volumes are different")
+	}
+	if !CompareConfig(&config1, &config1) {
+		t.Fatalf("CompareConfig should return true")
+	}
+}
+
+func TestMergeConfig(t *testing.T) {
+	volumesImage := make(map[string]struct{})
+	volumesImage["/test1"] = struct{}{}
+	volumesImage["/test2"] = struct{}{}
+	configImage := &Config{
+		Dns:         []string{"1.1.1.1", "2.2.2.2"},
+		PortSpecs:   []string{"1111:1111", "2222:2222"},
+		Env:         []string{"VAR1=1", "VAR2=2"},
+		VolumesFrom: "1111",
+		Volumes:     volumesImage,
+	}
+
+	volumesUser := make(map[string]struct{})
+	volumesUser["/test3"] = struct{}{}
+	configUser := &Config{
+		Dns:       []string{"3.3.3.3"},
+		PortSpecs: []string{"3333:2222", "3333:3333"},
+		Env:       []string{"VAR2=3", "VAR3=3"},
+		Volumes:   volumesUser,
+	}
+
+	if err := MergeConfig(configUser, configImage); err != nil {
+		t.Error(err)
+	}
+
+	if len(configUser.Dns) != 3 {
+		t.Fatalf("Expected 3 dns, 1.1.1.1, 2.2.2.2 and 3.3.3.3, found %d", len(configUser.Dns))
+	}
+	for _, dns := range configUser.Dns {
+		if dns != "1.1.1.1" && dns != "2.2.2.2" && dns != "3.3.3.3" {
+			t.Fatalf("Expected 1.1.1.1 or 2.2.2.2 or 3.3.3.3, found %s", dns)
+		}
+	}
+
+	if len(configUser.ExposedPorts) != 3 {
+		t.Fatalf("Expected 3 ExposedPorts, 1111, 2222 and 3333, found %d", len(configUser.ExposedPorts))
+	}
+	for portSpecs := range configUser.ExposedPorts {
+		if portSpecs.Port() != "1111" && portSpecs.Port() != "2222" && portSpecs.Port() != "3333" {
+			t.Fatalf("Expected 1111 or 2222 or 3333, found %s", portSpecs)
+		}
+	}
+	if len(configUser.Env) != 3 {
+		t.Fatalf("Expected 3 env var, VAR1=1, VAR2=3 and VAR3=3, found %d", len(configUser.Env))
+	}
+	for _, env := range configUser.Env {
+		if env != "VAR1=1" && env != "VAR2=3" && env != "VAR3=3" {
+			t.Fatalf("Expected VAR1=1 or VAR2=3 or VAR3=3, found %s", env)
+		}
+	}
+
+	if len(configUser.Volumes) != 3 {
+		t.Fatalf("Expected 3 volumes, /test1, /test2 and /test3, found %d", len(configUser.Volumes))
+	}
+	for v := range configUser.Volumes {
+		if v != "/test1" && v != "/test2" && v != "/test3" {
+			t.Fatalf("Expected /test1 or /test2 or /test3, found %s", v)
+		}
+	}
+
+	if configUser.VolumesFrom != "1111" {
+		t.Fatalf("Expected VolumesFrom to be 1111, found %s", configUser.VolumesFrom)
+	}
+
+	ports, _, err := parsePortSpecs([]string{"0000"})
+	if err != nil {
+		t.Error(err)
+	}
+	configImage2 := &Config{
+		ExposedPorts: ports,
+	}
+
+	if err := MergeConfig(configUser, configImage2); err != nil {
+		t.Error(err)
+	}
+
+	if len(configUser.ExposedPorts) != 4 {
+		t.Fatalf("Expected 4 ExposedPorts, 0000, 1111, 2222 and 3333, found %d", len(configUser.ExposedPorts))
+	}
+	for portSpecs := range configUser.ExposedPorts {
+		if portSpecs.Port() != "0000" && portSpecs.Port() != "1111" && portSpecs.Port() != "2222" && portSpecs.Port() != "3333" {
+			t.Fatalf("Expected 0000 or 1111 or 2222 or 3333, found %s", portSpecs)
+		}
+	}
+
+}
diff --git a/components/engine/container_unit_test.go b/components/engine/container_unit_test.go
new file mode 100644
index 0000000000..9647327d98
--- /dev/null
+++ b/components/engine/container_unit_test.go
@@ -0,0 +1,257 @@
+package docker
+
+import (
+	"testing"
+)
+
+
+
+func TestParseLxcConfOpt(t *testing.T) {
+	opts := []string{"lxc.utsname=docker", "lxc.utsname = docker "}
+
+	for _, o := range opts {
+		k, v, err := parseLxcOpt(o)
+		if err != nil {
+			t.FailNow()
+		}
+		if k != "lxc.utsname" {
+			t.Fail()
+		}
+		if v != "docker" {
+			t.Fail()
+		}
+	}
+}
+
+func TestParseNetworkOptsPrivateOnly(t *testing.T) {
+	ports, bindings, err := parsePortSpecs([]string{"192.168.1.100::80"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ports) != 1 {
+		t.Logf("Expected 1 got %d", len(ports))
+		t.FailNow()
+	}
+	if len(bindings) != 1 {
+		t.Logf("Expected 1 got %d", len(bindings))
+		t.FailNow()
+	}
+	for k := range ports {
+		if k.Proto() != "tcp" {
+			t.Logf("Expected tcp got %s", k.Proto())
+			t.Fail()
+		}
+		if k.Port() != "80" {
+			t.Logf("Expected 80 got %s", k.Port())
+			t.Fail()
+		}
+		b, exists := bindings[k]
+		if !exists {
+			t.Log("Binding does not exist")
+			t.FailNow()
+		}
+		if len(b) != 1 {
+			t.Logf("Expected 1 got %d", len(b))
+			t.FailNow()
+		}
+		s := b[0]
+		if s.HostPort != "" {
+			t.Logf("Expected \"\" got %s", s.HostPort)
+			t.Fail()
+		}
+		if s.HostIp != "192.168.1.100" {
+			t.Fail()
+		}
+	}
+}
+
+func TestParseNetworkOptsPublic(t *testing.T) {
+	ports, bindings, err := parsePortSpecs([]string{"192.168.1.100:8080:80"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ports) != 1 {
+		t.Logf("Expected 1 got %d", len(ports))
+		t.FailNow()
+	}
+	if len(bindings) != 1 {
+		t.Logf("Expected 1 got %d", len(bindings))
+		t.FailNow()
+	}
+	for k := range ports {
+		if k.Proto() != "tcp" {
+			t.Logf("Expected tcp got %s", k.Proto())
+			t.Fail()
+		}
+		if k.Port() != "80" {
+			t.Logf("Expected 80 got %s", k.Port())
+			t.Fail()
+		}
+		b, exists := bindings[k]
+		if !exists {
+			t.Log("Binding does not exist")
+			t.FailNow()
+		}
+		if len(b) != 1 {
+			t.Logf("Expected 1 got %d", len(b))
+			t.FailNow()
+		}
+		s := b[0]
+		if s.HostPort != "8080" {
+			t.Logf("Expected 8080 got %s", s.HostPort)
+			t.Fail()
+		}
+		if s.HostIp != "192.168.1.100" {
+			t.Fail()
+		}
+	}
+}
+
+func TestParseNetworkOptsUdp(t *testing.T) {
+	ports, bindings, err := parsePortSpecs([]string{"192.168.1.100::6000/udp"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ports) != 1 {
+		t.Logf("Expected 1 got %d", len(ports))
+		t.FailNow()
+	}
+	if len(bindings) != 1 {
+		t.Logf("Expected 1 got %d", len(bindings))
+		t.FailNow()
+	}
+	for k := range ports {
+		if k.Proto() != "udp" {
+			t.Logf("Expected udp got %s", k.Proto())
+			t.Fail()
+		}
+		if k.Port() != "6000" {
+			t.Logf("Expected 6000 got %s", k.Port())
+			t.Fail()
+		}
+		b, exists := bindings[k]
+		if !exists {
+			t.Log("Binding does not exist")
+			t.FailNow()
+		}
+		if len(b) != 1 {
+			t.Logf("Expected 1 got %d", len(b))
+			t.FailNow()
+		}
+		s := b[0]
+		if s.HostPort != "" {
+			t.Logf("Expected \"\" got %s", s.HostPort)
+			t.Fail()
+		}
+		if s.HostIp != "192.168.1.100" {
+			t.Fail()
+		}
+	}
+}
+
+
+
+
+// FIXME: test that destroying a container actually removes its root directory
+
+
+/*
+func TestLXCConfig(t *testing.T) {
+	// Memory is allocated randomly for testing
+	rand.Seed(time.Now().UTC().UnixNano())
+	memMin := 33554432
+	memMax := 536870912
+	mem := memMin + rand.Intn(memMax-memMin)
+	// CPU shares as well
+	cpuMin := 100
+	cpuMax := 10000
+	cpu := cpuMin + rand.Intn(cpuMax-cpuMin)
+	container, _, err := runtime.Create(&Config{
+		Image: GetTestImage(runtime).ID,
+		Cmd:   []string{"/bin/true"},
+
+		Hostname:  "foobar",
+		Memory:    int64(mem),
+		CpuShares: int64(cpu),
+	},
+		"",
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container)
+	container.generateLXCConfig()
+	grepFile(t, container.lxcConfigPath(), "lxc.utsname = foobar")
+	grepFile(t, container.lxcConfigPath(),
+		fmt.Sprintf("lxc.cgroup.memory.limit_in_bytes = %d", mem))
+	grepFile(t, container.lxcConfigPath(),
+		fmt.Sprintf("lxc.cgroup.memory.memsw.limit_in_bytes = %d", mem*2))
+}
+
+
+func TestCustomLxcConfig(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+	container, _, err := runtime.Create(&Config{
+		Image: GetTestImage(runtime).ID,
+		Cmd:   []string{"/bin/true"},
+
+		Hostname: "foobar",
+	},
+		"",
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container)
+	container.hostConfig = &HostConfig{LxcConf: []KeyValuePair{
+		{
+			Key:   "lxc.utsname",
+			Value: "docker",
+		},
+		{
+			Key:   "lxc.cgroup.cpuset.cpus",
+			Value: "0,1",
+		},
+	}}
+
+	container.generateLXCConfig()
+	grepFile(t, container.lxcConfigPath(), "lxc.utsname = docker")
+	grepFile(t, container.lxcConfigPath(), "lxc.cgroup.cpuset.cpus = 0,1")
+}
+
+
+func grepFile(t *testing.T, path string, pattern string) {
+	f, err := os.Open(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	r := bufio.NewReader(f)
+	var (
+		line string
+	)
+	err = nil
+	for err == nil {
+		line, err = r.ReadString('\n')
+		if strings.Contains(line, pattern) == true {
+			return
+		}
+	}
+	t.Fatalf("grepFile: pattern \"%s\" not found in \"%s\"", pattern, path)
+}
+*/
+
+
+func TestGetFullName(t *testing.T) {
+	name, err := getFullName("testing")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if name != "/testing" {
+		t.Fatalf("Expected /testing got %s", name)
+	}
+	if _, err := getFullName(""); err == nil {
+		t.Fatal("Error should not be nil")
+	}
+}
diff --git a/components/engine/engine/job.go b/components/engine/engine/job.go
index c4a2c3ef52..3ccaa8d1a0 100644
--- a/components/engine/engine/job.go
+++ b/components/engine/engine/job.go
@@ -214,7 +214,7 @@ func (job *Job) GetenvList(key string) []string {
 	return l
 }
 
-func (job *Job) SetenvList(key string, value []string) error {
+func (job *Job) SetenvJson(key string, value interface{}) error {
 	sval, err := json.Marshal(value)
 	if err != nil {
 		return err
@@ -223,6 +223,10 @@ func (job *Job) SetenvList(key string, value []string) error {
 	return nil
 }
 
+func (job *Job) SetenvList(key string, value []string) error {
+	return job.SetenvJson(key, value)
+}
+
 func (job *Job) Setenv(key, value string) {
 	job.env = append(job.env, key+"="+value)
 }
diff --git a/components/engine/http_test.go b/components/engine/http_test.go
new file mode 100644
index 0000000000..64764424cb
--- /dev/null
+++ b/components/engine/http_test.go
@@ -0,0 +1,52 @@
+package docker
+
+import (
+	"testing"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+)
+
+
+func TestGetBoolParam(t *testing.T) {
+	if ret, err := getBoolParam("true"); err != nil || !ret {
+		t.Fatalf("true -> true, nil | got %t %s", ret, err)
+	}
+	if ret, err := getBoolParam("True"); err != nil || !ret {
+		t.Fatalf("True -> true, nil | got %t %s", ret, err)
+	}
+	if ret, err := getBoolParam("1"); err != nil || !ret {
+		t.Fatalf("1 -> true, nil | got %t %s", ret, err)
+	}
+	if ret, err := getBoolParam(""); err != nil || ret {
+		t.Fatalf("\"\" -> false, nil | got %t %s", ret, err)
+	}
+	if ret, err := getBoolParam("false"); err != nil || ret {
+		t.Fatalf("false -> false, nil | got %t %s", ret, err)
+	}
+	if ret, err := getBoolParam("0"); err != nil || ret {
+		t.Fatalf("0 -> false, nil | got %t %s", ret, err)
+	}
+	if ret, err := getBoolParam("faux"); err == nil || ret {
+		t.Fatalf("faux -> false, err | got %t %s", ret, err)
+	}
+}
+
+func TesthttpError(t *testing.T) {
+	r := httptest.NewRecorder()
+
+	httpError(r, fmt.Errorf("No such method"))
+	if r.Code != http.StatusNotFound {
+		t.Fatalf("Expected %d, got %d", http.StatusNotFound, r.Code)
+	}
+
+	httpError(r, fmt.Errorf("This accound hasn't been activated"))
+	if r.Code != http.StatusForbidden {
+		t.Fatalf("Expected %d, got %d", http.StatusForbidden, r.Code)
+	}
+
+	httpError(r, fmt.Errorf("Some error"))
+	if r.Code != http.StatusInternalServerError {
+		t.Fatalf("Expected %d, got %d", http.StatusInternalServerError, r.Code)
+	}
+}
diff --git a/components/engine/api_test.go b/components/engine/integration/api_test.go
similarity index 100%
rename from components/engine/api_test.go
rename to components/engine/integration/api_test.go
diff --git a/components/engine/buildfile_test.go b/components/engine/integration/buildfile_test.go
similarity index 100%
rename from components/engine/buildfile_test.go
rename to components/engine/integration/buildfile_test.go
diff --git a/components/engine/commands_test.go b/components/engine/integration/commands_test.go
similarity index 100%
rename from components/engine/commands_test.go
rename to components/engine/integration/commands_test.go
diff --git a/components/engine/container_test.go b/components/engine/integration/container_test.go
similarity index 100%
rename from components/engine/container_test.go
rename to components/engine/integration/container_test.go
diff --git a/components/engine/runtime_test.go b/components/engine/integration/runtime_test.go
similarity index 100%
rename from components/engine/runtime_test.go
rename to components/engine/integration/runtime_test.go
diff --git a/components/engine/server_test.go b/components/engine/integration/server_test.go
similarity index 100%
rename from components/engine/server_test.go
rename to components/engine/integration/server_test.go
diff --git a/components/engine/sorter_test.go b/components/engine/integration/sorter_test.go
similarity index 100%
rename from components/engine/sorter_test.go
rename to components/engine/integration/sorter_test.go
diff --git a/components/engine/utils_test.go b/components/engine/integration/utils_test.go
similarity index 100%
rename from components/engine/utils_test.go
rename to components/engine/integration/utils_test.go
diff --git a/components/engine/z_final_test.go b/components/engine/integration/z_final_test.go
similarity index 100%
rename from components/engine/z_final_test.go
rename to components/engine/integration/z_final_test.go
diff --git a/components/engine/runtime.go b/components/engine/runtime.go
index f4744cc60a..bb90301d48 100644
--- a/components/engine/runtime.go
+++ b/components/engine/runtime.go
@@ -15,6 +15,7 @@ import (
 	"path"
 	"sort"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -516,7 +517,12 @@ func (runtime *Runtime) Commit(container *Container, repository, tag, comment, a
 	return img, nil
 }
 
+// FIXME: this is deprecated by the getFullName *function*
 func (runtime *Runtime) getFullName(name string) (string, error) {
+	return getFullName(name)
+}
+
+func getFullName(name string) (string, error) {
 	if name == "" {
 		return "", fmt.Errorf("Container name cannot be empty")
 	}
@@ -655,6 +661,26 @@ func (runtime *Runtime) Close() error {
 	return runtime.containerGraph.Close()
 }
 
+// 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)
+}
+
+
 func linkLxcStart(root string) error {
 	sourcePath, err := exec.LookPath("lxc-start")
 	if err != nil {
@@ -672,6 +698,14 @@ func linkLxcStart(root string) error {
 	return os.Symlink(sourcePath, targetPath)
 }
 
+// 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
+}
+
 // History is a convenience type for storing a list of containers,
 // ordered by creation date.
 type History []*Container
diff --git a/components/engine/server.go b/components/engine/server.go
index 28858d6f6b..768f73a688 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -62,6 +62,8 @@ func jobInitApi(job *engine.Job) string {
 		os.Exit(0)
 	}()
 	job.Eng.Hack_SetGlobalVar("httpapi.server", srv)
+	job.Eng.Hack_SetGlobalVar("httpapi.runtime", srv.runtime)
+	job.Eng.Hack_SetGlobalVar("httpapi.bridgeIP", srv.runtime.networkManager.bridgeNetwork.IP)
 	if err := job.Eng.Register("create", srv.ContainerCreate); err != nil {
 		return err.Error()
 	}
@@ -530,6 +532,7 @@ func (srv *Server) ContainerCommit(name, repo, tag, author, comment string, conf
 	return img.ID, err
 }
 
+// FIXME: this should be called ImageTag
 func (srv *Server) ContainerTag(name, repo, tag string, force bool) error {
 	if err := srv.runtime.repositories.Set(repo, tag, name, force); err != nil {
 		return err
@@ -1062,7 +1065,12 @@ func (srv *Server) ContainerCreate(job *engine.Job) string {
 		return err.Error()
 	}
 	srv.LogEvent("create", container.ID, srv.runtime.repositories.ImageName(container.Image))
-	job.Printf("%s\n", container.ID)
+	// FIXME: this is necessary because runtime.Create might return a nil container
+	// with a non-nil error. This should not happen! Once it's fixed we
+	// can remove this workaround.
+	if container != nil {
+		job.Printf("%s\n", container.ID)
+	}
 	for _, warning := range buildWarnings {
 		job.Errorf("%s\n", warning)
 	}
@@ -1600,7 +1608,7 @@ func (srv *Server) HTTPRequestFactory(metaHeaders map[string][]string) *utils.HT
 	return srv.reqFactory
 }
 
-func (srv *Server) LogEvent(action, id, from string) {
+func (srv *Server) LogEvent(action, id, from string) *utils.JSONMessage {
 	now := time.Now().Unix()
 	jm := utils.JSONMessage{Status: action, ID: id, From: from, Time: now}
 	srv.events = append(srv.events, jm)
@@ -1610,6 +1618,7 @@ func (srv *Server) LogEvent(action, id, from string) {
 		default:
 		}
 	}
+	return &jm
 }
 
 type Server struct {
diff --git a/components/engine/server_unit_test.go b/components/engine/server_unit_test.go
new file mode 100644
index 0000000000..7ce03e3547
--- /dev/null
+++ b/components/engine/server_unit_test.go
@@ -0,0 +1,110 @@
+package docker
+
+import (
+	"github.com/dotcloud/docker/utils"
+	"testing"
+	"time"
+)
+
+func TestPools(t *testing.T) {
+	srv := &Server{
+		pullingPool: make(map[string]struct{}),
+		pushingPool: make(map[string]struct{}),
+	}
+
+	err := srv.poolAdd("pull", "test1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = srv.poolAdd("pull", "test2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = srv.poolAdd("push", "test1")
+	if err == nil || err.Error() != "pull test1 is already in progress" {
+		t.Fatalf("Expected `pull test1 is already in progress`")
+	}
+	err = srv.poolAdd("pull", "test1")
+	if err == nil || err.Error() != "pull test1 is already in progress" {
+		t.Fatalf("Expected `pull test1 is already in progress`")
+	}
+	err = srv.poolAdd("wait", "test3")
+	if err == nil || err.Error() != "Unknown pool type" {
+		t.Fatalf("Expected `Unknown pool type`")
+	}
+
+	err = srv.poolRemove("pull", "test2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = srv.poolRemove("pull", "test2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = srv.poolRemove("pull", "test1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = srv.poolRemove("push", "test1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = srv.poolRemove("wait", "test3")
+	if err == nil || err.Error() != "Unknown pool type" {
+		t.Fatalf("Expected `Unknown pool type`")
+	}
+}
+
+
+func TestLogEvent(t *testing.T) {
+	srv := &Server{
+		events:    make([]utils.JSONMessage, 0, 64),
+		listeners: make(map[string]chan utils.JSONMessage),
+	}
+
+	srv.LogEvent("fakeaction", "fakeid", "fakeimage")
+
+	listener := make(chan utils.JSONMessage)
+	srv.Lock()
+	srv.listeners["test"] = listener
+	srv.Unlock()
+
+	srv.LogEvent("fakeaction2", "fakeid", "fakeimage")
+
+	if len(srv.events) != 2 {
+		t.Fatalf("Expected 2 events, found %d", len(srv.events))
+	}
+	go func() {
+		time.Sleep(200 * time.Millisecond)
+		srv.LogEvent("fakeaction3", "fakeid", "fakeimage")
+		time.Sleep(200 * time.Millisecond)
+		srv.LogEvent("fakeaction4", "fakeid", "fakeimage")
+	}()
+
+	setTimeout(t, "Listening for events timed out", 2*time.Second, func() {
+		for i := 2; i < 4; i++ {
+			event := <-listener
+			if event != srv.events[i] {
+				t.Fatalf("Event received it different than expected")
+			}
+		}
+	})
+}
+
+// FIXME: this is duplicated from integration/commands_test.go
+func setTimeout(t *testing.T, msg string, d time.Duration, f func()) {
+	c := make(chan bool)
+
+	// Make sure we are not too long
+	go func() {
+		time.Sleep(d)
+		c <- true
+	}()
+	go func() {
+		f()
+		c <- false
+	}()
+	if <-c && msg != "" {
+		t.Fatal(msg)
+	}
+}
diff --git a/components/engine/sorter_unit_test.go b/components/engine/sorter_unit_test.go
new file mode 100644
index 0000000000..0669feedb3
--- /dev/null
+++ b/components/engine/sorter_unit_test.go
@@ -0,0 +1,41 @@
+package docker
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestSortUniquePorts(t *testing.T) {
+	ports := []Port{
+		Port("6379/tcp"),
+		Port("22/tcp"),
+	}
+
+	sortPorts(ports, func(ip, jp Port) bool {
+		return ip.Int() < jp.Int() || (ip.Int() == jp.Int() && ip.Proto() == "tcp")
+	})
+
+	first := ports[0]
+	if fmt.Sprint(first) != "22/tcp" {
+		t.Log(fmt.Sprint(first))
+		t.Fail()
+	}
+}
+
+func TestSortSamePortWithDifferentProto(t *testing.T) {
+	ports := []Port{
+		Port("8888/tcp"),
+		Port("8888/udp"),
+		Port("6379/tcp"),
+		Port("6379/udp"),
+	}
+
+	sortPorts(ports, func(ip, jp Port) bool {
+		return ip.Int() < jp.Int() || (ip.Int() == jp.Int() && ip.Proto() == "tcp")
+	})
+
+	first := ports[0]
+	if fmt.Sprint(first) != "6379/tcp" {
+		t.Fail()
+	}
+}
diff --git a/components/engine/tags_unit_test.go b/components/engine/tags_unit_test.go
new file mode 100644
index 0000000000..89f31676f7
--- /dev/null
+++ b/components/engine/tags_unit_test.go
@@ -0,0 +1,81 @@
+package docker
+
+import (
+	"github.com/dotcloud/docker/utils"
+	"testing"
+	"path"
+	"os"
+)
+
+const (
+	testImageName string = "myapp"
+	testImageID   string = "foo"
+)
+
+func mkTestTagStore(root string, t *testing.T) *TagStore {
+	graph, err := NewGraph(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	store, err := NewTagStore(path.Join(root, "tags"), graph)
+	if err != nil {
+		t.Fatal(err)
+	}
+	archive, err := fakeTar()
+	if err != nil {
+		t.Fatal(err)
+	}
+	img := &Image{ID: testImageID}
+	if err := graph.Register(nil, archive, img); err != nil {
+		t.Fatal(err)
+	}
+	if err := store.Set(testImageName, "", testImageID, false); err != nil {
+		t.Fatal(err)
+	}
+	return store
+}
+
+
+func TestLookupImage(t *testing.T) {
+	tmp, err := utils.TestDirectory("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmp)
+	store := mkTestTagStore(tmp, t)
+
+	if img, err := store.LookupImage(testImageName); err != nil {
+		t.Fatal(err)
+	} else if img == nil {
+		t.Errorf("Expected 1 image, none found")
+	}
+	if img, err := store.LookupImage(testImageName + ":" + DEFAULTTAG); err != nil {
+		t.Fatal(err)
+	} else if img == nil {
+		t.Errorf("Expected 1 image, none found")
+	}
+
+	if img, err := store.LookupImage(testImageName + ":" + "fail"); err == nil {
+		t.Errorf("Expected error, none found")
+	} else if img != nil {
+		t.Errorf("Expected 0 image, 1 found")
+	}
+
+	if img, err := store.LookupImage("fail:fail"); err == nil {
+		t.Errorf("Expected error, none found")
+	} else if img != nil {
+		t.Errorf("Expected 0 image, 1 found")
+	}
+
+	if img, err := store.LookupImage(testImageID); err != nil {
+		t.Fatal(err)
+	} else if img == nil {
+		t.Errorf("Expected 1 image, none found")
+	}
+
+	if img, err := store.LookupImage(testImageName + ":" + testImageID); err != nil {
+		t.Fatal(err)
+	} else if img == nil {
+		t.Errorf("Expected 1 image, none found")
+	}
+}
diff --git a/components/engine/utils/utils.go b/components/engine/utils/utils.go
index fe75aa68dc..0844abdde6 100644
--- a/components/engine/utils/utils.go
+++ b/components/engine/utils/utils.go
@@ -1207,3 +1207,43 @@ func PartParser(template, data string) (map[string]string, error) {
 	}
 	return out, nil
 }
+
+
+
+var globalTestID string
+
+// TestDirectory creates a new temporary directory and returns its path.
+// The contents of directory at path `templateDir` is copied into the
+// new directory.
+func TestDirectory(templateDir string) (dir string, err error) {
+	if globalTestID == "" {
+		globalTestID = RandomString()[:4]
+	}
+	prefix := fmt.Sprintf("docker-test%s-%s-", globalTestID, GetCallerName(2))
+	if prefix == "" {
+		prefix = "docker-test-"
+	}
+	dir, err = ioutil.TempDir("", prefix)
+	if err = os.Remove(dir); err != nil {
+		return
+	}
+	if templateDir != "" {
+		if err = CopyDirectory(templateDir, dir); err != nil {
+			return
+		}
+	}
+	return
+}
+
+// GetCallerName introspects the call stack and returns the name of the
+// function `depth` levels down in the stack.
+func GetCallerName(depth int) string {
+	// Use the caller function name as a prefix.
+	// This helps trace temp directories back to their test.
+	pc, _, _, _ := runtime.Caller(depth + 1)
+	callerLongName := runtime.FuncForPC(pc).Name()
+	parts := strings.Split(callerLongName, ".")
+	callerShortName := parts[len(parts)-1]
+	return callerShortName
+}
+

From 1880f01ff8d4647fd5d928bcfa4bee3120673887 Mon Sep 17 00:00:00 2001
From: Victor Vieux <vieux@docker.com>
Date: Thu, 14 Nov 2013 06:10:20 +0000
Subject: [PATCH 114/184] Integration tests: remove dependency on private APIs
 Upstream-commit: c001a5af67b7b811a8fc69011fcffc2656b8fd99 Component: engine

---
 components/engine/integration/api_test.go     | 223 +++++------
 .../engine/integration/buildfile_test.go      | 130 +++---
 .../engine/integration/commands_test.go       |  92 ++---
 .../engine/integration/container_test.go      | 252 +++++-------
 components/engine/integration/runtime_test.go | 264 ++++++-------
 components/engine/integration/server_test.go  | 239 ++---------
 components/engine/integration/sorter_test.go  |  76 +---
 components/engine/integration/utils_test.go   | 372 +++---------------
 8 files changed, 528 insertions(+), 1120 deletions(-)

diff --git a/components/engine/integration/api_test.go b/components/engine/integration/api_test.go
index 5794abba62..f5c9cc9bad 100644
--- a/components/engine/integration/api_test.go
+++ b/components/engine/integration/api_test.go
@@ -1,76 +1,35 @@
 package docker
 
 import (
-	"archive/tar"
-	"bufio"
-	"bytes"
+	_ "archive/tar"
+	_ "bufio"
+	_ "bytes"
 	"encoding/json"
-	"fmt"
+	"github.com/dotcloud/docker"
 	"github.com/dotcloud/docker/utils"
 	"io"
-	"net"
+	_ "net"
 	"net/http"
 	"net/http/httptest"
-	"os"
-	"path"
-	"strings"
+	_ "os"
+	_ "path"
+	_ "strings"
 	"testing"
 	"time"
 )
 
-func TestGetBoolParam(t *testing.T) {
-	if ret, err := getBoolParam("true"); err != nil || !ret {
-		t.Fatalf("true -> true, nil | got %t %s", ret, err)
-	}
-	if ret, err := getBoolParam("True"); err != nil || !ret {
-		t.Fatalf("True -> true, nil | got %t %s", ret, err)
-	}
-	if ret, err := getBoolParam("1"); err != nil || !ret {
-		t.Fatalf("1 -> true, nil | got %t %s", ret, err)
-	}
-	if ret, err := getBoolParam(""); err != nil || ret {
-		t.Fatalf("\"\" -> false, nil | got %t %s", ret, err)
-	}
-	if ret, err := getBoolParam("false"); err != nil || ret {
-		t.Fatalf("false -> false, nil | got %t %s", ret, err)
-	}
-	if ret, err := getBoolParam("0"); err != nil || ret {
-		t.Fatalf("0 -> false, nil | got %t %s", ret, err)
-	}
-	if ret, err := getBoolParam("faux"); err == nil || ret {
-		t.Fatalf("faux -> false, err | got %t %s", ret, err)
-	}
-}
-
-func TesthttpError(t *testing.T) {
-	r := httptest.NewRecorder()
-
-	httpError(r, fmt.Errorf("No such method"))
-	if r.Code != http.StatusNotFound {
-		t.Fatalf("Expected %d, got %d", http.StatusNotFound, r.Code)
-	}
-
-	httpError(r, fmt.Errorf("This accound hasn't been activated"))
-	if r.Code != http.StatusForbidden {
-		t.Fatalf("Expected %d, got %d", http.StatusForbidden, r.Code)
-	}
-
-	httpError(r, fmt.Errorf("Some error"))
-	if r.Code != http.StatusInternalServerError {
-		t.Fatalf("Expected %d, got %d", http.StatusInternalServerError, r.Code)
-	}
-}
-
+/*
 func TestGetVersion(t *testing.T) {
-	var err error
-	runtime := mkRuntime(t)
+	runtime := mkRuntime()
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
+	var err error
 	r := httptest.NewRecorder()
 
-	if err := getVersion(srv, APIVERSION, r, nil, nil); err != nil {
+	// FIXME getting the version should require an actual running Server
+	if err := getVersion(srv, docker.APIVERSION, r, nil, nil); err != nil {
 		t.Fatal(err)
 	}
 
@@ -83,11 +42,29 @@ func TestGetVersion(t *testing.T) {
 	}
 }
 
+	var err error
+	r := httptest.NewRecorder()
+
+	// FIXME getting the version should require an actual running Server
+	if err := getVersion(&docker.Server{}, docker.APIVERSION, r, nil, nil); err != nil {
+		t.Fatal(err)
+	}
+
+	v := &APIVersion{}
+	if err = json.Unmarshal(r.Body.Bytes(), v); err != nil {
+		t.Fatal(err)
+	}
+	if v.Version != VERSION {
+		t.Errorf("Expected version %s, %s found", VERSION, v.Version)
+	}
+}
+
+
 func TestGetInfo(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	initialImages, err := srv.runtime.graph.Map()
 	if err != nil {
@@ -96,7 +73,7 @@ func TestGetInfo(t *testing.T) {
 
 	r := httptest.NewRecorder()
 
-	if err := getInfo(srv, APIVERSION, r, nil, nil); err != nil {
+	if err := getInfo(srv, docker.APIVERSION, r, nil, nil); err != nil {
 		t.Fatal(err)
 	}
 
@@ -109,18 +86,25 @@ func TestGetInfo(t *testing.T) {
 		t.Errorf("Expected images: %d, %d found", len(initialImages), infos.Images)
 	}
 }
+*/
 
 func TestGetEvents(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	srv := mkServerFromEngine(eng, t)
+	// FIXME: we might not need runtime, why not simply nuke
+	// the engine?
+	runtime := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime)
-	srv := &Server{
-		runtime:   runtime,
-		events:    make([]utils.JSONMessage, 0, 64),
-		listeners: make(map[string]chan utils.JSONMessage),
-	}
 
-	srv.LogEvent("fakeaction", "fakeid", "fakeimage")
-	srv.LogEvent("fakeaction2", "fakeid", "fakeimage")
+	var events []*utils.JSONMessage
+	for _, parts := range [][3]string{
+		{"fakeaction", "fakeid", "fakeimage"},
+		{"fakeaction2", "fakeid", "fakeimage"},
+	} {
+		action, id, from := parts[0], parts[1], parts[2]
+		ev := srv.LogEvent(action, id, from)
+		events = append(events, ev)
+	}
 
 	req, err := http.NewRequest("GET", "/events?since=1", nil)
 	if err != nil {
@@ -129,7 +113,7 @@ func TestGetEvents(t *testing.T) {
 
 	r := httptest.NewRecorder()
 	setTimeout(t, "", 500*time.Millisecond, func() {
-		if err := getEvents(srv, APIVERSION, r, req, nil); err != nil {
+		if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 			t.Fatal(err)
 		}
 	})
@@ -142,18 +126,20 @@ func TestGetEvents(t *testing.T) {
 		} else if err != nil {
 			t.Fatal(err)
 		}
-		if jm != srv.events[i] {
+		if jm != *events[i] {
 			t.Fatalf("Event received it different than expected")
 		}
 	}
 
 }
 
+/*
+
 func TestGetImagesJSON(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	// all=0
 
@@ -169,7 +155,7 @@ func TestGetImagesJSON(t *testing.T) {
 
 	r := httptest.NewRecorder()
 
-	if err := getImagesJSON(srv, APIVERSION, r, req, nil); err != nil {
+	if err := getImagesJSON(srv, docker.APIVERSION, r, req, nil); err != nil {
 		t.Fatal(err)
 	}
 
@@ -207,7 +193,7 @@ func TestGetImagesJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if err := getImagesJSON(srv, APIVERSION, r2, req2, nil); err != nil {
+	if err := getImagesJSON(srv, docker.APIVERSION, r2, req2, nil); err != nil {
 		t.Fatal(err)
 	}
 
@@ -239,7 +225,7 @@ func TestGetImagesJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if err := getImagesJSON(srv, APIVERSION, r3, req3, nil); err != nil {
+	if err := getImagesJSON(srv, docker.APIVERSION, r3, req3, nil); err != nil {
 		t.Fatal(err)
 	}
 
@@ -260,7 +246,7 @@ func TestGetImagesJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = getImagesJSON(srv, APIVERSION, r4, req4, nil)
+	err = getImagesJSON(srv, docker.APIVERSION, r4, req4, nil)
 	if err == nil {
 		t.Fatalf("Error expected, received none")
 	}
@@ -279,11 +265,11 @@ func TestGetImagesHistory(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	r := httptest.NewRecorder()
 
-	if err := getImagesHistory(srv, APIVERSION, r, nil, map[string]string{"name": unitTestImageName}); err != nil {
+	if err := getImagesHistory(srv, docker.APIVERSION, r, nil, map[string]string{"name": unitTestImageName}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -300,14 +286,14 @@ func TestGetImagesByName(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	r := httptest.NewRecorder()
-	if err := getImagesByName(srv, APIVERSION, r, nil, map[string]string{"name": unitTestImageName}); err != nil {
+	if err := getImagesByName(srv, docker.APIVERSION, r, nil, map[string]string{"name": unitTestImageName}); err != nil {
 		t.Fatal(err)
 	}
 
-	img := &Image{}
+	img := &docker.Image{}
 	if err := json.Unmarshal(r.Body.Bytes(), img); err != nil {
 		t.Fatal(err)
 	}
@@ -320,7 +306,7 @@ func TestGetContainersJSON(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	beginLen := runtime.containers.Len()
 
@@ -339,7 +325,7 @@ func TestGetContainersJSON(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-	if err := getContainersJSON(srv, APIVERSION, r, req, nil); err != nil {
+	if err := getContainersJSON(srv, docker.APIVERSION, r, req, nil); err != nil {
 		t.Fatal(err)
 	}
 	containers := []APIContainers{}
@@ -358,7 +344,7 @@ func TestGetContainersExport(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	// Create a container and remove a file
 	container, _, err := runtime.Create(
@@ -378,7 +364,7 @@ func TestGetContainersExport(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-	if err = getContainersExport(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
+	if err = getContainersExport(srv, docker.APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -409,7 +395,7 @@ func TestGetContainersChanges(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	// Create a container and remove a file
 	container, _, err := runtime.Create(
@@ -429,7 +415,7 @@ func TestGetContainersChanges(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-	if err := getContainersChanges(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
+	if err := getContainersChanges(srv, docker.APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
 		t.Fatal(err)
 	}
 	changes := []Change{}
@@ -454,7 +440,7 @@ func TestGetContainersTop(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	container, _, err := runtime.Create(
 		&Config{
@@ -505,7 +491,7 @@ func TestGetContainersTop(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := getContainersTop(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+	if err := getContainersTop(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
 		t.Fatal(err)
 	}
 	procs := APITop{}
@@ -535,7 +521,7 @@ func TestGetContainersByName(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	// Create a container and remove a file
 	container, _, err := runtime.Create(
@@ -551,10 +537,10 @@ func TestGetContainersByName(t *testing.T) {
 	defer runtime.Destroy(container)
 
 	r := httptest.NewRecorder()
-	if err := getContainersByName(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
+	if err := getContainersByName(srv, docker.APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
 		t.Fatal(err)
 	}
-	outContainer := &Container{}
+	outContainer := &docker.Container{}
 	if err := json.Unmarshal(r.Body.Bytes(), outContainer); err != nil {
 		t.Fatal(err)
 	}
@@ -567,7 +553,7 @@ func TestPostCommit(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	// Create a container and remove a file
 	container, _, err := runtime.Create(
@@ -592,7 +578,7 @@ func TestPostCommit(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-	if err := postCommit(srv, APIVERSION, r, req, nil); err != nil {
+	if err := postCommit(srv, docker.APIVERSION, r, req, nil); err != nil {
 		t.Fatal(err)
 	}
 	if r.Code != http.StatusCreated {
@@ -629,7 +615,7 @@ func TestPostContainersCreate(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-	if err := postContainersCreate(srv, APIVERSION, r, req, nil); err != nil {
+	if err := postContainersCreate(srv, docker.APIVERSION, r, req, nil); err != nil {
 		t.Fatal(err)
 	}
 	if r.Code != http.StatusCreated {
@@ -663,7 +649,7 @@ func TestPostContainersKill(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	container, _, err := runtime.Create(
 		&Config{
@@ -690,7 +676,7 @@ func TestPostContainersKill(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-	if err := postContainersKill(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
+	if err := postContainersKill(srv, docker.APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
 		t.Fatal(err)
 	}
 	if r.Code != http.StatusNoContent {
@@ -705,7 +691,7 @@ func TestPostContainersRestart(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	container, _, err := runtime.Create(
 		&Config{
@@ -736,7 +722,7 @@ func TestPostContainersRestart(t *testing.T) {
 		t.Fatal(err)
 	}
 	r := httptest.NewRecorder()
-	if err := postContainersRestart(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+	if err := postContainersRestart(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
 		t.Fatal(err)
 	}
 	if r.Code != http.StatusNoContent {
@@ -780,7 +766,7 @@ func TestPostContainersStart(t *testing.T) {
 	req.Header.Set("Content-Type", "application/json")
 
 	r := httptest.NewRecorder()
-	if err := postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": id}); err != nil {
+	if err := postContainersStart(srv, docker.APIVERSION, r, req, map[string]string{"name": id}); err != nil {
 		t.Fatal(err)
 	}
 	if r.Code != http.StatusNoContent {
@@ -799,7 +785,7 @@ func TestPostContainersStart(t *testing.T) {
 	}
 
 	r = httptest.NewRecorder()
-	if err = postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": id}); err == nil {
+	if err = postContainersStart(srv, docker.APIVERSION, r, req, map[string]string{"name": id}); err == nil {
 		t.Fatalf("A running container should be able to be started")
 	}
 
@@ -812,7 +798,7 @@ func TestPostContainersStop(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	container, _, err := runtime.Create(
 		&Config{
@@ -844,7 +830,7 @@ func TestPostContainersStop(t *testing.T) {
 		t.Fatal(err)
 	}
 	r := httptest.NewRecorder()
-	if err := postContainersStop(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+	if err := postContainersStop(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
 		t.Fatal(err)
 	}
 	if r.Code != http.StatusNoContent {
@@ -859,7 +845,7 @@ func TestPostContainersWait(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	container, _, err := runtime.Create(
 		&Config{
@@ -880,7 +866,7 @@ func TestPostContainersWait(t *testing.T) {
 
 	setTimeout(t, "Wait timed out", 3*time.Second, func() {
 		r := httptest.NewRecorder()
-		if err := postContainersWait(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
+		if err := postContainersWait(srv, docker.APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
 			t.Fatal(err)
 		}
 		apiWait := &APIWait{}
@@ -901,7 +887,7 @@ func TestPostContainersAttach(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	container, _, err := runtime.Create(
 		&Config{
@@ -946,7 +932,7 @@ func TestPostContainersAttach(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		if err := postContainersAttach(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+		if err := postContainersAttach(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
 			t.Fatal(err)
 		}
 	}()
@@ -990,7 +976,7 @@ func TestPostContainersAttachStderr(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	container, _, err := runtime.Create(
 		&Config{
@@ -1035,7 +1021,7 @@ func TestPostContainersAttachStderr(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		if err := postContainersAttach(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+		if err := postContainersAttach(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
 			t.Fatal(err)
 		}
 	}()
@@ -1082,7 +1068,7 @@ func TestDeleteContainers(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	container, _, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
@@ -1102,7 +1088,7 @@ func TestDeleteContainers(t *testing.T) {
 		t.Fatal(err)
 	}
 	r := httptest.NewRecorder()
-	if err := deleteContainers(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+	if err := deleteContainers(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
 		t.Fatal(err)
 	}
 	if r.Code != http.StatusNoContent {
@@ -1123,7 +1109,7 @@ func TestOptionsRoute(t *testing.T) {
 	defer nuke(runtime)
 
 	runtime.config.EnableCors = true
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	r := httptest.NewRecorder()
 	router, err := createRouter(srv, false)
@@ -1147,7 +1133,7 @@ func TestGetEnabledCors(t *testing.T) {
 	defer nuke(runtime)
 
 	runtime.config.EnableCors = true
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	r := httptest.NewRecorder()
 
@@ -1185,7 +1171,7 @@ func TestDeleteImages(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	initialImages, err := srv.Images(false, "")
 	if err != nil {
@@ -1211,7 +1197,7 @@ func TestDeleteImages(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-	if err := deleteImages(srv, APIVERSION, r, req, map[string]string{"name": unitTestImageID}); err == nil {
+	if err := deleteImages(srv, docker.APIVERSION, r, req, map[string]string{"name": unitTestImageID}); err == nil {
 		t.Fatalf("Expected conflict error, got none")
 	}
 
@@ -1221,7 +1207,7 @@ func TestDeleteImages(t *testing.T) {
 	}
 
 	r2 := httptest.NewRecorder()
-	if err := deleteImages(srv, APIVERSION, r2, req2, map[string]string{"name": "test:test"}); err != nil {
+	if err := deleteImages(srv, docker.APIVERSION, r2, req2, map[string]string{"name": "test:test"}); err != nil {
 		t.Fatal(err)
 	}
 	if r2.Code != http.StatusOK {
@@ -1243,14 +1229,6 @@ func TestDeleteImages(t *testing.T) {
 	if len(images[0].RepoTags) != len(initialImages[0].RepoTags) {
 		t.Errorf("Expected %d image, %d found", len(initialImages), len(images))
 	}
-
-	/*	if c := runtime.Get(container.Id); c != nil {
-			t.Fatalf("The container as not been deleted")
-		}
-
-		if _, err := os.Stat(path.Join(container.rwPath(), "test")); err == nil {
-			t.Fatalf("The test file has not been deleted")
-		} */
 }
 
 func TestJsonContentType(t *testing.T) {
@@ -1271,7 +1249,7 @@ func TestPostContainersCopy(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	srv := &Server{runtime: runtime}
+	srv := &docker.Server{runtime: runtime}
 
 	// Create a container and remove a file
 	container, _, err := runtime.Create(
@@ -1303,7 +1281,7 @@ func TestPostContainersCopy(t *testing.T) {
 		t.Fatal(err)
 	}
 	req.Header.Add("Content-Type", "application/json")
-	if err = postContainersCopy(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+	if err = postContainersCopy(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -1356,3 +1334,4 @@ func (t *hijackTester) Hijack() (net.Conn, *bufio.ReadWriter, error) {
 	}
 	return conn, bufrw, nil
 }
+*/
diff --git a/components/engine/integration/buildfile_test.go b/components/engine/integration/buildfile_test.go
index d3fca3c788..964b58403b 100644
--- a/components/engine/integration/buildfile_test.go
+++ b/components/engine/integration/buildfile_test.go
@@ -2,7 +2,9 @@ package docker
 
 import (
 	"fmt"
+	"github.com/dotcloud/docker"
 	"github.com/dotcloud/docker/archive"
+	"github.com/dotcloud/docker/engine"
 	"io/ioutil"
 	"net"
 	"net/http"
@@ -14,7 +16,7 @@ import (
 // mkTestContext generates a build context from the contents of the provided dockerfile.
 // This context is suitable for use as an argument to BuildFile.Build()
 func mkTestContext(dockerfile string, files [][2]string, t *testing.T) archive.Archive {
-	context, err := mkBuildContext(dockerfile, files)
+	context, err := docker.MkBuildContext(dockerfile, files)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -228,17 +230,15 @@ func TestBuild(t *testing.T) {
 	}
 }
 
-func buildImage(context testContextTemplate, t *testing.T, srv *Server, useCache bool) *Image {
-	if srv == nil {
-		runtime := mkRuntime(t)
+func buildImage(context testContextTemplate, t *testing.T, eng *engine.Engine, useCache bool) *docker.Image {
+	if eng == nil {
+		eng = NewTestEngine(t)
+		runtime := mkRuntimeFromEngine(eng, t)
+		// FIXME: we might not need runtime, why not simply nuke
+		// the engine?
 		defer nuke(runtime)
-
-		srv = &Server{
-			runtime:     runtime,
-			pullingPool: make(map[string]struct{}),
-			pushingPool: make(map[string]struct{}),
-		}
 	}
+	srv := mkServerFromEngine(eng, t)
 
 	httpServer, err := mkTestingFileServer(context.remoteFiles)
 	if err != nil {
@@ -252,10 +252,17 @@ func buildImage(context testContextTemplate, t *testing.T, srv *Server, useCache
 	}
 	port := httpServer.URL[idx+1:]
 
-	ip := srv.runtime.networkManager.bridgeNetwork.IP
+	iIP := eng.Hack_GetGlobalVar("httpapi.bridgeIP")
+	if iIP == nil {
+		t.Fatal("Legacy bridgeIP field not set in engine")
+	}
+	ip, ok := iIP.(net.IP)
+	if !ok {
+		panic("Legacy bridgeIP field in engine does not cast to net.IP")
+	}
 	dockerfile := constructDockerfile(context.dockerfile, ip, port)
 
-	buildfile := NewBuildFile(srv, ioutil.Discard, false, useCache, false)
+	buildfile := docker.NewBuildFile(srv, ioutil.Discard, false, useCache, false)
 	id, err := buildfile.Build(mkTestContext(dockerfile, context.files, t))
 	if err != nil {
 		t.Fatal(err)
@@ -368,20 +375,14 @@ func TestBuildEntrypoint(t *testing.T) {
 // testing #1405 - config.Cmd does not get cleaned up if
 // utilizing cache
 func TestBuildEntrypointRunCleanup(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &Server{
-		runtime:     runtime,
-		pullingPool: make(map[string]struct{}),
-		pushingPool: make(map[string]struct{}),
-	}
+	eng := NewTestEngine(t)
+	defer nuke(mkRuntimeFromEngine(eng, t))
 
 	img := buildImage(testContextTemplate{`
         from {IMAGE}
         run echo "hello"
         `,
-		nil, nil}, t, srv, true)
+		nil, nil}, t, eng, true)
 
 	img = buildImage(testContextTemplate{`
         from {IMAGE}
@@ -389,7 +390,7 @@ func TestBuildEntrypointRunCleanup(t *testing.T) {
         add foo /foo
         entrypoint ["/bin/echo"]
         `,
-		[][2]string{{"foo", "HEYO"}}, nil}, t, srv, true)
+		[][2]string{{"foo", "HEYO"}}, nil}, t, eng, true)
 
 	if len(img.Config.Cmd) != 0 {
 		t.Fail()
@@ -397,14 +398,8 @@ func TestBuildEntrypointRunCleanup(t *testing.T) {
 }
 
 func TestBuildImageWithCache(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &Server{
-		runtime:     runtime,
-		pullingPool: make(map[string]struct{}),
-		pushingPool: make(map[string]struct{}),
-	}
+	eng := NewTestEngine(t)
+	defer nuke(mkRuntimeFromEngine(eng, t))
 
 	template := testContextTemplate{`
         from {IMAGE}
@@ -412,11 +407,11 @@ func TestBuildImageWithCache(t *testing.T) {
         `,
 		nil, nil}
 
-	img := buildImage(template, t, srv, true)
+	img := buildImage(template, t, eng, true)
 	imageId := img.ID
 
 	img = nil
-	img = buildImage(template, t, srv, true)
+	img = buildImage(template, t, eng, true)
 
 	if imageId != img.ID {
 		t.Logf("Image ids should match: %s != %s", imageId, img.ID)
@@ -425,14 +420,8 @@ func TestBuildImageWithCache(t *testing.T) {
 }
 
 func TestBuildImageWithoutCache(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &Server{
-		runtime:     runtime,
-		pullingPool: make(map[string]struct{}),
-		pushingPool: make(map[string]struct{}),
-	}
+	eng := NewTestEngine(t)
+	defer nuke(mkRuntimeFromEngine(eng, t))
 
 	template := testContextTemplate{`
         from {IMAGE}
@@ -440,11 +429,11 @@ func TestBuildImageWithoutCache(t *testing.T) {
         `,
 		nil, nil}
 
-	img := buildImage(template, t, srv, true)
+	img := buildImage(template, t, eng, true)
 	imageId := img.ID
 
 	img = nil
-	img = buildImage(template, t, srv, false)
+	img = buildImage(template, t, eng, false)
 
 	if imageId == img.ID {
 		t.Logf("Image ids should not match: %s == %s", imageId, img.ID)
@@ -453,14 +442,9 @@ func TestBuildImageWithoutCache(t *testing.T) {
 }
 
 func TestForbiddenContextPath(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &Server{
-		runtime:     runtime,
-		pullingPool: make(map[string]struct{}),
-		pushingPool: make(map[string]struct{}),
-	}
+	eng := NewTestEngine(t)
+	defer nuke(mkRuntimeFromEngine(eng, t))
+	srv := mkServerFromEngine(eng, t)
 
 	context := testContextTemplate{`
         from {IMAGE}
@@ -481,10 +465,17 @@ func TestForbiddenContextPath(t *testing.T) {
 	}
 	port := httpServer.URL[idx+1:]
 
-	ip := srv.runtime.networkManager.bridgeNetwork.IP
+	iIP := eng.Hack_GetGlobalVar("httpapi.bridgeIP")
+	if iIP == nil {
+		t.Fatal("Legacy bridgeIP field not set in engine")
+	}
+	ip, ok := iIP.(net.IP)
+	if !ok {
+		panic("Legacy bridgeIP field in engine does not cast to net.IP")
+	}
 	dockerfile := constructDockerfile(context.dockerfile, ip, port)
 
-	buildfile := NewBuildFile(srv, ioutil.Discard, false, true, false)
+	buildfile := docker.NewBuildFile(srv, ioutil.Discard, false, true, false)
 	_, err = buildfile.Build(mkTestContext(dockerfile, context.files, t))
 
 	if err == nil {
@@ -499,14 +490,8 @@ func TestForbiddenContextPath(t *testing.T) {
 }
 
 func TestBuildADDFileNotFound(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &Server{
-		runtime:     runtime,
-		pullingPool: make(map[string]struct{}),
-		pushingPool: make(map[string]struct{}),
-	}
+	eng := NewTestEngine(t)
+	defer nuke(mkRuntimeFromEngine(eng, t))
 
 	context := testContextTemplate{`
         from {IMAGE}
@@ -526,10 +511,17 @@ func TestBuildADDFileNotFound(t *testing.T) {
 	}
 	port := httpServer.URL[idx+1:]
 
-	ip := srv.runtime.networkManager.bridgeNetwork.IP
+	iIP := eng.Hack_GetGlobalVar("httpapi.bridgeIP")
+	if iIP == nil {
+		t.Fatal("Legacy bridgeIP field not set in engine")
+	}
+	ip, ok := iIP.(net.IP)
+	if !ok {
+		panic("Legacy bridgeIP field in engine does not cast to net.IP")
+	}
 	dockerfile := constructDockerfile(context.dockerfile, ip, port)
 
-	buildfile := NewBuildFile(srv, ioutil.Discard, false, true, false)
+	buildfile := docker.NewBuildFile(mkServerFromEngine(eng, t), ioutil.Discard, false, true, false)
 	_, err = buildfile.Build(mkTestContext(dockerfile, context.files, t))
 
 	if err == nil {
@@ -544,26 +536,20 @@ func TestBuildADDFileNotFound(t *testing.T) {
 }
 
 func TestBuildInheritance(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &Server{
-		runtime:     runtime,
-		pullingPool: make(map[string]struct{}),
-		pushingPool: make(map[string]struct{}),
-	}
+	eng := NewTestEngine(t)
+	defer nuke(mkRuntimeFromEngine(eng, t))
 
 	img := buildImage(testContextTemplate{`
             from {IMAGE}
             expose 4243
             `,
-		nil, nil}, t, srv, true)
+		nil, nil}, t, eng, true)
 
 	img2 := buildImage(testContextTemplate{fmt.Sprintf(`
             from %s
             entrypoint ["/bin/echo"]
             `, img.ID),
-		nil, nil}, t, srv, true)
+		nil, nil}, t, eng, true)
 
 	// from child
 	if img2.Config.Entrypoint[0] != "/bin/echo" {
diff --git a/components/engine/integration/commands_test.go b/components/engine/integration/commands_test.go
index 1778f1b89f..ab186f4a2c 100644
--- a/components/engine/integration/commands_test.go
+++ b/components/engine/integration/commands_test.go
@@ -3,6 +3,8 @@ package docker
 import (
 	"bufio"
 	"fmt"
+	"github.com/dotcloud/docker"
+	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/utils"
 	"io"
 	"io/ioutil"
@@ -66,8 +68,8 @@ func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error
 func TestRunHostname(t *testing.T) {
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	c := make(chan struct{})
 	go func() {
@@ -111,8 +113,8 @@ func TestRunHostname(t *testing.T) {
 func TestRunWorkdir(t *testing.T) {
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	c := make(chan struct{})
 	go func() {
@@ -156,8 +158,8 @@ func TestRunWorkdir(t *testing.T) {
 func TestRunWorkdirExists(t *testing.T) {
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	c := make(chan struct{})
 	go func() {
@@ -201,8 +203,8 @@ func TestRunExit(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	c1 := make(chan struct{})
 	go func() {
@@ -254,8 +256,8 @@ func TestRunDisconnect(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	c1 := make(chan struct{})
 	go func() {
@@ -299,8 +301,8 @@ func TestRunDisconnectTty(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	c1 := make(chan struct{})
 	go func() {
@@ -356,8 +358,8 @@ func TestRunAttachStdin(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	ch := make(chan struct{})
 	go func() {
@@ -420,8 +422,8 @@ func TestRunDetach(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	ch := make(chan struct{})
 	go func() {
@@ -466,8 +468,8 @@ func TestAttachDetach(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	ch := make(chan struct{})
 	go func() {
@@ -477,7 +479,7 @@ func TestAttachDetach(t *testing.T) {
 		}
 	}()
 
-	var container *Container
+	var container *docker.Container
 
 	setTimeout(t, "Reading container's id timed out", 10*time.Second, func() {
 		buf := make([]byte, 1024)
@@ -498,7 +500,7 @@ func TestAttachDetach(t *testing.T) {
 
 	stdin, stdinPipe = io.Pipe()
 	stdout, stdoutPipe = io.Pipe()
-	cli = NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	cli = docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
 
 	ch = make(chan struct{})
 	go func() {
@@ -546,8 +548,8 @@ func TestAttachDetachTruncatedID(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	go stdout.Read(make([]byte, 1024))
 	setTimeout(t, "Starting container timed out", 2*time.Second, func() {
@@ -560,7 +562,7 @@ func TestAttachDetachTruncatedID(t *testing.T) {
 
 	stdin, stdinPipe = io.Pipe()
 	stdout, stdoutPipe = io.Pipe()
-	cli = NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	cli = docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
 
 	ch := make(chan struct{})
 	go func() {
@@ -608,8 +610,8 @@ func TestAttachDisconnect(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	go func() {
 		// Start a process in daemon mode
@@ -677,8 +679,8 @@ func TestAttachDisconnect(t *testing.T) {
 func TestRunAutoRemove(t *testing.T) {
 	t.Skip("Fixme. Skipping test for now, race condition")
 	stdout, stdoutPipe := io.Pipe()
-	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	c := make(chan struct{})
 	go func() {
@@ -712,8 +714,8 @@ func TestRunAutoRemove(t *testing.T) {
 }
 
 func TestCmdLogs(t *testing.T) {
-	cli := NewDockerCli(nil, ioutil.Discard, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(nil, ioutil.Discard, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	if err := cli.CmdRun(unitTestImageID, "sh", "-c", "ls -l"); err != nil {
 		t.Fatal(err)
@@ -730,8 +732,8 @@ func TestCmdLogs(t *testing.T) {
 // Expected behaviour: using / as a bind mount source should throw an error
 func TestRunErrorBindMountRootSource(t *testing.T) {
 
-	cli := NewDockerCli(nil, nil, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(nil, nil, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	c := make(chan struct{})
 	go func() {
@@ -749,8 +751,8 @@ func TestRunErrorBindMountRootSource(t *testing.T) {
 // Expected behaviour: error out when attempting to bind mount non-existing source paths
 func TestRunErrorBindNonExistingSource(t *testing.T) {
 
-	cli := NewDockerCli(nil, nil, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(nil, nil, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	c := make(chan struct{})
 	go func() {
@@ -768,11 +770,10 @@ func TestRunErrorBindNonExistingSource(t *testing.T) {
 func TestImagesViz(t *testing.T) {
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
-	srv := &Server{runtime: globalRuntime}
-	image := buildTestImages(t, srv)
+	image := buildTestImages(t, globalEngine)
 
 	c := make(chan struct{})
 	go func() {
@@ -819,11 +820,10 @@ func TestImagesViz(t *testing.T) {
 func TestImagesTree(t *testing.T) {
 	stdout, stdoutPipe := io.Pipe()
 
-	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
-	srv := &Server{runtime: globalRuntime}
-	image := buildTestImages(t, srv)
+	image := buildTestImages(t, globalEngine)
 
 	c := make(chan struct{})
 	go func() {
@@ -867,7 +867,7 @@ func TestImagesTree(t *testing.T) {
 	})
 }
 
-func buildTestImages(t *testing.T, srv *Server) *Image {
+func buildTestImages(t *testing.T, eng *engine.Engine) *docker.Image {
 
 	var testBuilder = testContextTemplate{
 		`
@@ -880,9 +880,9 @@ run    [ "$(ls -d /var/run/sshd)" = "/var/run/sshd" ]
 		nil,
 		nil,
 	}
-	image := buildImage(testBuilder, t, srv, true)
+	image := buildImage(testBuilder, t, eng, true)
 
-	err := srv.ContainerTag(image.ID, "test", "latest", false)
+	err := mkServerFromEngine(eng, t).ContainerTag(image.ID, "test", "latest", false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -902,8 +902,8 @@ func TestRunCidFile(t *testing.T) {
 	}
 	tmpCidFile := path.Join(tmpDir, "cid")
 
-	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalRuntime)
+	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalEngine, t)
 
 	c := make(chan struct{})
 	go func() {
diff --git a/components/engine/integration/container_test.go b/components/engine/integration/container_test.go
index 26007a732d..149a321983 100644
--- a/components/engine/integration/container_test.go
+++ b/components/engine/integration/container_test.go
@@ -3,10 +3,10 @@ package docker
 import (
 	"bufio"
 	"fmt"
+	"github.com/dotcloud/docker"
 	"github.com/dotcloud/docker/utils"
 	"io"
 	"io/ioutil"
-	"math/rand"
 	"os"
 	"path"
 	"regexp"
@@ -20,7 +20,7 @@ func TestIDFormat(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 	container1, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"/bin/sh", "-c", "echo hello world"},
 		},
@@ -134,7 +134,8 @@ func TestMultipleAttachRestart(t *testing.T) {
 }
 
 func TestDiff(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	runtime := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime)
 	// Create a container and remove a file
 	container1, _ := mkContainer(runtime, []string{"_", "/bin/rm", "/etc/passwd"}, t)
@@ -169,11 +170,7 @@ func TestDiff(t *testing.T) {
 	}
 
 	// Commit the container
-	rwTar, err := container1.ExportRw()
-	if err != nil {
-		t.Error(err)
-	}
-	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image - diff", "", nil)
+	img, err := runtime.Commit(container1, "", "", "unit test commited image - diff", "", nil)
 	if err != nil {
 		t.Error(err)
 	}
@@ -237,11 +234,7 @@ func TestCommitAutoRun(t *testing.T) {
 		t.Errorf("Container shouldn't be running")
 	}
 
-	rwTar, err := container1.ExportRw()
-	if err != nil {
-		t.Error(err)
-	}
-	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image", "", &Config{Cmd: []string{"cat", "/world"}})
+	img, err := runtime.Commit(container1, "", "", "unit test commited image", "", &docker.Config{Cmd: []string{"cat", "/world"}})
 	if err != nil {
 		t.Error(err)
 	}
@@ -297,11 +290,7 @@ func TestCommitRun(t *testing.T) {
 		t.Errorf("Container shouldn't be running")
 	}
 
-	rwTar, err := container1.ExportRw()
-	if err != nil {
-		t.Error(err)
-	}
-	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image", "", nil)
+	img, err := runtime.Commit(container1, "", "", "unit test commited image", "", nil)
 	if err != nil {
 		t.Error(err)
 	}
@@ -391,7 +380,7 @@ func TestOutput(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 	container, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"echo", "-n", "foobar"},
 		},
@@ -414,7 +403,7 @@ func TestContainerNetwork(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 	container, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"ping", "-c", "1", "127.0.0.1"},
 		},
@@ -436,7 +425,7 @@ func TestKillDifferentUser(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image:     GetTestImage(runtime).ID,
 		Cmd:       []string{"cat"},
 		OpenStdin: true,
@@ -448,7 +437,9 @@ func TestKillDifferentUser(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer runtime.Destroy(container)
-	defer container.stdin.Close()
+	// FIXME @shykes: this seems redundant, but is very old, I'm leaving it in case
+	// there is a side effect I'm not seeing.
+	// defer container.stdin.Close()
 
 	if container.State.Running {
 		t.Errorf("Container shouldn't be running")
@@ -490,22 +481,35 @@ func TestKillDifferentUser(t *testing.T) {
 
 // Test that creating a container with a volume doesn't crash. Regression test for #995.
 func TestCreateVolume(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	runtime := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime)
 
-	config, hc, _, err := ParseRun([]string{"-v", "/var/lib/data", GetTestImage(runtime).ID, "echo", "hello", "world"}, nil)
+	config, hc, _, err := docker.ParseRun([]string{"-v", "/var/lib/data", unitTestImageID, "echo", "hello", "world"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	c, _, err := runtime.Create(config, "")
-	if err != nil {
+	jobCreate := eng.Job("create")
+	if err := jobCreate.ImportEnv(config); err != nil {
 		t.Fatal(err)
 	}
-	defer runtime.Destroy(c)
-	c.hostConfig = hc
-	if err := c.Start(); err != nil {
+	var id string
+	jobCreate.StdoutParseString(&id)
+	if err := jobCreate.Run(); err != nil {
 		t.Fatal(err)
 	}
+	jobStart := eng.Job("start", id)
+	if err := jobStart.ImportEnv(hc); err != nil {
+		t.Fatal(err)
+	}
+	if err := jobStart.Run(); err != nil {
+		t.Fatal(err)
+	}
+	// FIXME: this hack can be removed once Wait is a job
+	c := runtime.Get(id)
+	if c == nil {
+		t.Fatalf("Couldn't retrieve container %s from runtime", id)
+	}
 	c.WaitTimeout(500 * time.Millisecond)
 	c.Wait()
 }
@@ -513,7 +517,7 @@ func TestCreateVolume(t *testing.T) {
 func TestKill(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"sleep", "2"},
 	},
@@ -557,7 +561,7 @@ func TestExitCode(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	trueContainer, _, err := runtime.Create(&Config{
+	trueContainer, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"/bin/true", ""},
 	}, "")
@@ -572,7 +576,7 @@ func TestExitCode(t *testing.T) {
 		t.Errorf("Unexpected exit code %d (expected 0)", trueContainer.State.ExitCode)
 	}
 
-	falseContainer, _, err := runtime.Create(&Config{
+	falseContainer, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"/bin/false", ""},
 	}, "")
@@ -591,7 +595,7 @@ func TestExitCode(t *testing.T) {
 func TestRestart(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"echo", "-n", "foobar"},
 	},
@@ -622,7 +626,7 @@ func TestRestart(t *testing.T) {
 func TestRestartStdin(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"cat"},
 
@@ -700,7 +704,7 @@ func TestUser(t *testing.T) {
 	defer nuke(runtime)
 
 	// Default user must be root
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 	},
@@ -719,7 +723,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a username
-	container, _, err = runtime.Create(&Config{
+	container, _, err = runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 
@@ -740,7 +744,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a UID
-	container, _, err = runtime.Create(&Config{
+	container, _, err = runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 
@@ -761,7 +765,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a different user by uid
-	container, _, err = runtime.Create(&Config{
+	container, _, err = runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 
@@ -784,7 +788,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a different user by username
-	container, _, err = runtime.Create(&Config{
+	container, _, err = runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 
@@ -805,7 +809,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Test an wrong username
-	container, _, err = runtime.Create(&Config{
+	container, _, err = runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 
@@ -827,7 +831,7 @@ func TestMultipleContainers(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	container1, _, err := runtime.Create(&Config{
+	container1, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"sleep", "2"},
 	},
@@ -838,7 +842,7 @@ func TestMultipleContainers(t *testing.T) {
 	}
 	defer runtime.Destroy(container1)
 
-	container2, _, err := runtime.Create(&Config{
+	container2, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"sleep", "2"},
 	},
@@ -882,7 +886,7 @@ func TestMultipleContainers(t *testing.T) {
 func TestStdin(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"cat"},
 
@@ -927,7 +931,7 @@ func TestStdin(t *testing.T) {
 func TestTty(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"cat"},
 
@@ -974,7 +978,7 @@ func TestEnv(t *testing.T) {
 	os.Setenv("TRICKY", "tri\ncky\n")
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	config, _, _, err := ParseRun([]string{"-e=FALSE=true", "-e=TRUE", "-e=TRICKY", GetTestImage(runtime).ID, "env"}, nil)
+	config, _, _, err := docker.ParseRun([]string{"-e=FALSE=true", "-e=TRUE", "-e=TRICKY", GetTestImage(runtime).ID, "env"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1028,7 +1032,7 @@ func TestEntrypoint(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 	container, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image:      GetTestImage(runtime).ID,
 			Entrypoint: []string{"/bin/echo"},
 			Cmd:        []string{"-n", "foobar"},
@@ -1052,7 +1056,7 @@ func TestEntrypointNoCmd(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 	container, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image:      GetTestImage(runtime).ID,
 			Entrypoint: []string{"/bin/echo", "foobar"},
 		},
@@ -1071,96 +1075,11 @@ func TestEntrypointNoCmd(t *testing.T) {
 	}
 }
 
-func grepFile(t *testing.T, path string, pattern string) {
-	f, err := os.Open(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-	r := bufio.NewReader(f)
-	var (
-		line string
-	)
-	err = nil
-	for err == nil {
-		line, err = r.ReadString('\n')
-		if strings.Contains(line, pattern) == true {
-			return
-		}
-	}
-	t.Fatalf("grepFile: pattern \"%s\" not found in \"%s\"", pattern, path)
-}
-
-func TestLXCConfig(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-	// Memory is allocated randomly for testing
-	rand.Seed(time.Now().UTC().UnixNano())
-	memMin := 33554432
-	memMax := 536870912
-	mem := memMin + rand.Intn(memMax-memMin)
-	// CPU shares as well
-	cpuMin := 100
-	cpuMax := 10000
-	cpu := cpuMin + rand.Intn(cpuMax-cpuMin)
-	container, _, err := runtime.Create(&Config{
-		Image: GetTestImage(runtime).ID,
-		Cmd:   []string{"/bin/true"},
-
-		Hostname:  "foobar",
-		Memory:    int64(mem),
-		CpuShares: int64(cpu),
-	},
-		"",
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-	container.generateLXCConfig()
-	grepFile(t, container.lxcConfigPath(), "lxc.utsname = foobar")
-	grepFile(t, container.lxcConfigPath(),
-		fmt.Sprintf("lxc.cgroup.memory.limit_in_bytes = %d", mem))
-	grepFile(t, container.lxcConfigPath(),
-		fmt.Sprintf("lxc.cgroup.memory.memsw.limit_in_bytes = %d", mem*2))
-}
-
-func TestCustomLxcConfig(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-	container, _, err := runtime.Create(&Config{
-		Image: GetTestImage(runtime).ID,
-		Cmd:   []string{"/bin/true"},
-
-		Hostname: "foobar",
-	},
-		"",
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-	container.hostConfig = &HostConfig{LxcConf: []KeyValuePair{
-		{
-			Key:   "lxc.utsname",
-			Value: "docker",
-		},
-		{
-			Key:   "lxc.cgroup.cpuset.cpus",
-			Value: "0,1",
-		},
-	}}
-
-	container.generateLXCConfig()
-	grepFile(t, container.lxcConfigPath(), "lxc.utsname = docker")
-	grepFile(t, container.lxcConfigPath(), "lxc.cgroup.cpuset.cpus = 0,1")
-}
-
 func BenchmarkRunSequencial(b *testing.B) {
 	runtime := mkRuntime(b)
 	defer nuke(runtime)
 	for i := 0; i < b.N; i++ {
-		container, _, err := runtime.Create(&Config{
+		container, _, err := runtime.Create(&docker.Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"echo", "-n", "foo"},
 		},
@@ -1193,7 +1112,7 @@ func BenchmarkRunParallel(b *testing.B) {
 		complete := make(chan error)
 		tasks = append(tasks, complete)
 		go func(i int, complete chan error) {
-			container, _, err := runtime.Create(&Config{
+			container, _, err := runtime.Create(&docker.Config{
 				Image: GetTestImage(runtime).ID,
 				Cmd:   []string{"echo", "-n", "foo"},
 			},
@@ -1261,11 +1180,7 @@ func TestCopyVolumeUidGid(t *testing.T) {
 		t.Errorf("Container shouldn't be running")
 	}
 
-	rwTar, err := container1.ExportRw()
-	if err != nil {
-		t.Error(err)
-	}
-	img, err := r.graph.Create(rwTar, container1, "unit test commited image", "", nil)
+	img, err := r.Commit(container1, "", "", "unit test commited image", "", nil)
 	if err != nil {
 		t.Error(err)
 	}
@@ -1298,11 +1213,7 @@ func TestCopyVolumeContent(t *testing.T) {
 		t.Errorf("Container shouldn't be running")
 	}
 
-	rwTar, err := container1.ExportRw()
-	if err != nil {
-		t.Error(err)
-	}
-	img, err := r.graph.Create(rwTar, container1, "unit test commited image", "", nil)
+	img, err := r.Commit(container1, "", "", "unit test commited image", "", nil)
 	if err != nil {
 		t.Error(err)
 	}
@@ -1344,7 +1255,7 @@ func TestFromVolumesInReadonlyMode(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 	container, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image:   GetTestImage(runtime).ID,
 			Cmd:     []string{"/bin/echo", "-n", "foobar"},
 			Volumes: map[string]struct{}{"/test": {}},
@@ -1364,7 +1275,7 @@ func TestFromVolumesInReadonlyMode(t *testing.T) {
 	}
 
 	container2, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image:       GetTestImage(runtime).ID,
 			Cmd:         []string{"/bin/echo", "-n", "foobar"},
 			VolumesFrom: container.ID + ":ro",
@@ -1405,7 +1316,7 @@ func TestVolumesFromReadonlyMount(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 	container, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image:   GetTestImage(runtime).ID,
 			Cmd:     []string{"/bin/echo", "-n", "foobar"},
 			Volumes: map[string]struct{}{"/test": {}},
@@ -1425,7 +1336,7 @@ func TestVolumesFromReadonlyMount(t *testing.T) {
 	}
 
 	container2, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image:       GetTestImage(runtime).ID,
 			Cmd:         []string{"/bin/echo", "-n", "foobar"},
 			VolumesFrom: container.ID,
@@ -1461,7 +1372,7 @@ func TestRestartWithVolumes(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image:   GetTestImage(runtime).ID,
 		Cmd:     []string{"echo", "-n", "foobar"},
 		Volumes: map[string]struct{}{"/test": {}},
@@ -1505,7 +1416,7 @@ func TestVolumesFromWithVolumes(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image:   GetTestImage(runtime).ID,
 		Cmd:     []string{"sh", "-c", "echo -n bar > /test/foo"},
 		Volumes: map[string]struct{}{"/test": {}},
@@ -1534,7 +1445,7 @@ func TestVolumesFromWithVolumes(t *testing.T) {
 	}
 
 	container2, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image:       GetTestImage(runtime).ID,
 			Cmd:         []string{"cat", "/test/foo"},
 			VolumesFrom: container.ID,
@@ -1568,26 +1479,42 @@ func TestVolumesFromWithVolumes(t *testing.T) {
 }
 
 func TestOnlyLoopbackExistsWhenUsingDisableNetworkOption(t *testing.T) {
-	runtime := mkRuntime(t)
+	eng := NewTestEngine(t)
+	runtime := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime)
 
-	config, hc, _, err := ParseRun([]string{"-n=false", GetTestImage(runtime).ID, "ip", "addr", "show"}, nil)
+	config, hc, _, err := docker.ParseRun([]string{"-n=false", GetTestImage(runtime).ID, "ip", "addr", "show"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	c, _, err := runtime.Create(config, "")
-	if err != nil {
+
+	jobCreate := eng.Job("create")
+	if err := jobCreate.ImportEnv(config); err != nil {
 		t.Fatal(err)
 	}
+	var id string
+	jobCreate.StdoutParseString(&id)
+	if err := jobCreate.Run(); err != nil {
+		t.Fatal(err)
+	}
+	// FIXME: this hack can be removed once Wait is a job
+	c := runtime.Get(id)
+	if c == nil {
+		t.Fatalf("Couldn't retrieve container %s from runtime", id)
+	}
 	stdout, err := c.StdoutPipe()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer runtime.Destroy(c)
-	c.hostConfig = hc
-	if err := c.Start(); err != nil {
+
+	jobStart := eng.Job("start", id)
+	if err := jobStart.ImportEnv(hc); err != nil {
 		t.Fatal(err)
 	}
+	if err := jobStart.Run(); err != nil {
+		t.Fatal(err)
+	}
+
 	c.WaitTimeout(500 * time.Millisecond)
 	c.Wait()
 	output, err := ioutil.ReadAll(stdout)
@@ -1602,7 +1529,6 @@ func TestOnlyLoopbackExistsWhenUsingDisableNetworkOption(t *testing.T) {
 	if !strings.HasSuffix(interfaces[0], ": lo") {
 		t.Fatalf("Wrong interface in test container: expected [*: lo], got %s", interfaces)
 	}
-
 }
 
 func TestPrivilegedCanMknod(t *testing.T) {
@@ -1641,7 +1567,7 @@ func TestMultipleVolumesFrom(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image:   GetTestImage(runtime).ID,
 		Cmd:     []string{"sh", "-c", "echo -n bar > /test/foo"},
 		Volumes: map[string]struct{}{"/test": {}},
@@ -1670,7 +1596,7 @@ func TestMultipleVolumesFrom(t *testing.T) {
 	}
 
 	container2, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image:   GetTestImage(runtime).ID,
 			Cmd:     []string{"sh", "-c", "echo -n bar > /other/foo"},
 			Volumes: map[string]struct{}{"/other": {}},
@@ -1692,7 +1618,7 @@ func TestMultipleVolumesFrom(t *testing.T) {
 	}
 
 	container3, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image:       GetTestImage(runtime).ID,
 			Cmd:         []string{"/bin/echo", "-n", "foobar"},
 			VolumesFrom: strings.Join([]string{container.ID, container2.ID}, ","),
@@ -1720,7 +1646,7 @@ func TestRestartGhost(t *testing.T) {
 	defer nuke(runtime)
 
 	container, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image:   GetTestImage(runtime).ID,
 			Cmd:     []string{"sh", "-c", "echo -n bar > /test/foo"},
 			Volumes: map[string]struct{}{"/test": {}},
diff --git a/components/engine/integration/runtime_test.go b/components/engine/integration/runtime_test.go
index 6a365d338d..ffde732c90 100644
--- a/components/engine/integration/runtime_test.go
+++ b/components/engine/integration/runtime_test.go
@@ -3,6 +3,7 @@ package docker
 import (
 	"bytes"
 	"fmt"
+	"github.com/dotcloud/docker"
 	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/sysinit"
 	"github.com/dotcloud/docker/utils"
@@ -15,7 +16,6 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
-	"sync"
 	"syscall"
 	"testing"
 	"time"
@@ -32,39 +32,33 @@ const (
 )
 
 var (
-	globalRuntime   *Runtime
+	// FIXME: globalRuntime is deprecated by globalEngine. All tests should be converted.
+	globalRuntime   *docker.Runtime
+	globalEngine    *engine.Engine
 	startFds        int
 	startGoroutines int
 )
 
-func nuke(runtime *Runtime) 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()
-
-	os.Remove(filepath.Join(runtime.config.Root, "linkgraph.db"))
-	return os.RemoveAll(runtime.config.Root)
+// FIXME: nuke() is deprecated by Runtime.Nuke()
+func nuke(runtime *docker.Runtime) error {
+	return runtime.Nuke()
 }
 
-func cleanup(runtime *Runtime) error {
+// FIXME: cleanup and nuke are redundant.
+func cleanup(eng *engine.Engine, t *testing.T) error {
+	runtime := mkRuntimeFromEngine(eng, t)
 	for _, container := range runtime.List() {
 		container.Kill()
 		runtime.Destroy(container)
 	}
-	images, err := runtime.graph.Map()
+	srv := mkServerFromEngine(eng, t)
+	images, err := srv.Images(true, "")
 	if err != nil {
 		return err
 	}
 	for _, image := range images {
 		if image.ID != unitTestImageID {
-			runtime.graph.Delete(image.ID)
+			srv.ImageDelete(image.ID, false)
 		}
 	}
 	return nil
@@ -133,10 +127,9 @@ func setupBaseImage() {
 		log.Fatalf("Unable to create a runtime for tests:", err)
 	}
 	srv := mkServerFromEngine(eng, log.New(os.Stderr, "", 0))
-	runtime := srv.runtime
 
 	// If the unit test is not found, try to download it.
-	if img, err := runtime.repositories.LookupImage(unitTestImageName); err != nil || img.ID != unitTestImageID {
+	if img, err := srv.ImageInspect(unitTestImageName); err != nil || img.ID != unitTestImageID {
 		// Retrieve the Image
 		if err := srv.ImagePull(unitTestImageName, "", os.Stdout, utils.NewStreamFormatter(false), nil, nil, true); err != nil {
 			log.Fatalf("Unable to pull the test image: %s", err)
@@ -151,8 +144,8 @@ func spawnGlobalDaemon() {
 	}
 	t := log.New(os.Stderr, "", 0)
 	eng := NewTestEngine(t)
-	srv := mkServerFromEngine(eng, t)
-	globalRuntime = srv.runtime
+	globalEngine = eng
+	globalRuntime = mkRuntimeFromEngine(eng, t)
 
 	// Spawn a Daemon
 	go func() {
@@ -174,8 +167,8 @@ func spawnGlobalDaemon() {
 
 // FIXME: test that ImagePull(json=true) send correct json output
 
-func GetTestImage(runtime *Runtime) *Image {
-	imgs, err := runtime.graph.Map()
+func GetTestImage(runtime *docker.Runtime) *docker.Image {
+	imgs, err := runtime.Graph().Map()
 	if err != nil {
 		log.Fatalf("Unable to get the test image:", err)
 	}
@@ -184,7 +177,7 @@ func GetTestImage(runtime *Runtime) *Image {
 			return image
 		}
 	}
-	log.Fatalf("Test image %v not found in %s: %s", unitTestImageID, runtime.graph.Root, imgs)
+	log.Fatalf("Test image %v not found in %s: %s", unitTestImageID, runtime.Graph().Root, imgs)
 	return nil
 }
 
@@ -197,7 +190,7 @@ func TestRuntimeCreate(t *testing.T) {
 		t.Errorf("Expected 0 containers, %v found", len(runtime.List()))
 	}
 
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"ls", "-al"},
 	},
@@ -239,12 +232,12 @@ func TestRuntimeCreate(t *testing.T) {
 	}
 
 	// Make sure create with bad parameters returns an error
-	if _, _, err = runtime.Create(&Config{Image: GetTestImage(runtime).ID}, ""); err == nil {
+	if _, _, err = runtime.Create(&docker.Config{Image: GetTestImage(runtime).ID}, ""); err == nil {
 		t.Fatal("Builder.Create should throw an error when Cmd is missing")
 	}
 
 	if _, _, err := runtime.Create(
-		&Config{
+		&docker.Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{},
 		},
@@ -253,7 +246,7 @@ func TestRuntimeCreate(t *testing.T) {
 		t.Fatal("Builder.Create should throw an error when Cmd is empty")
 	}
 
-	config := &Config{
+	config := &docker.Config{
 		Image:     GetTestImage(runtime).ID,
 		Cmd:       []string{"/bin/ls"},
 		PortSpecs: []string{"80"},
@@ -266,7 +259,7 @@ func TestRuntimeCreate(t *testing.T) {
 	}
 
 	// test expose 80:8000
-	container, warnings, err := runtime.Create(&Config{
+	container, warnings, err := runtime.Create(&docker.Config{
 		Image:     GetTestImage(runtime).ID,
 		Cmd:       []string{"ls", "-al"},
 		PortSpecs: []string{"80:8000"},
@@ -285,7 +278,7 @@ func TestDestroy(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	container, _, err := runtime.Create(&Config{
+	container, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"ls", "-al"},
 	}, "")
@@ -312,12 +305,6 @@ func TestDestroy(t *testing.T) {
 		t.Errorf("Unable to get newly created container")
 	}
 
-	// Make sure the container root directory does not exist anymore
-	_, err = os.Stat(container.root)
-	if err == nil || !os.IsNotExist(err) {
-		t.Errorf("Container root directory still exists after destroy")
-	}
-
 	// Test double destroy
 	if err := runtime.Destroy(container); err == nil {
 		// It should have failed
@@ -352,15 +339,21 @@ func TestGet(t *testing.T) {
 
 }
 
-func startEchoServerContainer(t *testing.T, proto string) (*Runtime, *Container, string) {
+func startEchoServerContainer(t *testing.T, proto string) (*docker.Runtime, *docker.Container, string) {
 	var (
-		err       error
-		container *Container
-		strPort   string
-		runtime   = mkRuntime(t)
-		port      = 5554
-		p         Port
+		err     error
+		id      string
+		strPort string
+		eng     = NewTestEngine(t)
+		runtime = mkRuntimeFromEngine(eng, t)
+		port    = 5554
+		p       docker.Port
 	)
+	defer func() {
+		if err != nil {
+			runtime.Nuke()
+		}
+	}()
 
 	for {
 		port += 1
@@ -373,37 +366,45 @@ func startEchoServerContainer(t *testing.T, proto string) (*Runtime, *Container,
 		} else {
 			t.Fatal(fmt.Errorf("Unknown protocol %v", proto))
 		}
-		ep := make(map[Port]struct{}, 1)
-		p = Port(fmt.Sprintf("%s/%s", strPort, proto))
+		ep := make(map[docker.Port]struct{}, 1)
+		p = docker.Port(fmt.Sprintf("%s/%s", strPort, proto))
 		ep[p] = struct{}{}
 
-		container, _, err = runtime.Create(&Config{
-			Image:        GetTestImage(runtime).ID,
-			Cmd:          []string{"sh", "-c", cmd},
-			PortSpecs:    []string{fmt.Sprintf("%s/%s", strPort, proto)},
-			ExposedPorts: ep,
-		}, "")
-		if err != nil {
-			nuke(runtime)
+		jobCreate := eng.Job("create")
+		jobCreate.Setenv("Image", unitTestImageID)
+		jobCreate.SetenvList("Cmd", []string{"sh", "-c", cmd})
+		jobCreate.SetenvList("PortSpecs", []string{fmt.Sprintf("%s/%s", strPort, proto)})
+		jobCreate.SetenvJson("ExposedPorts", ep)
+		jobCreate.StdoutParseString(&id)
+		if err := jobCreate.Run(); err != nil {
 			t.Fatal(err)
 		}
-
-		if container != nil {
+		// FIXME: this relies on the undocumented behavior of runtime.Create
+		// which will return a nil error AND container if the exposed ports
+		// are invalid. That behavior should be fixed!
+		if id != "" {
 			break
 		}
 		t.Logf("Port %v already in use, trying another one", strPort)
+
 	}
 
-	container.hostConfig = &HostConfig{
-		PortBindings: make(map[Port][]PortBinding),
-	}
-	container.hostConfig.PortBindings[p] = []PortBinding{
+	jobStart := eng.Job("start", id)
+	portBindings := make(map[docker.Port][]docker.PortBinding)
+	portBindings[p] = []docker.PortBinding{
 		{},
 	}
-	if err := container.Start(); err != nil {
-		nuke(runtime)
+	if err := jobStart.SetenvJson("PortsBindings", portBindings); err != nil {
 		t.Fatal(err)
 	}
+	if err := jobStart.Run(); err != nil {
+		t.Fatal(err)
+	}
+
+	container := runtime.Get(id)
+	if container == nil {
+		t.Fatalf("Couldn't fetch test container %s", id)
+	}
 
 	setTimeout(t, "Waiting for the container to be started timed out", 2*time.Second, func() {
 		for !container.State.Running {
@@ -504,8 +505,9 @@ func TestAllocateUDPPortLocalhost(t *testing.T) {
 }
 
 func TestRestore(t *testing.T) {
-	runtime1 := mkRuntime(t)
-	defer nuke(runtime1)
+	eng := NewTestEngine(t)
+	runtime1 := mkRuntimeFromEngine(eng, t)
+	defer runtime1.Nuke()
 	// Create a container with one instance of docker
 	container1, _ := mkContainer(runtime1, []string{"_", "ls", "-al"}, t)
 	defer runtime1.Destroy(container1)
@@ -545,12 +547,14 @@ func TestRestore(t *testing.T) {
 
 	// Here are are simulating a docker restart - that is, reloading all containers
 	// from scratch
-	runtime1.config.AutoRestart = false
-	runtime2, err := NewRuntimeFromDirectory(runtime1.config)
-	if err != nil {
+	job := eng.Job("initapi")
+	job.Setenv("Root", eng.Root())
+	job.SetenvBool("AutoRestart", false)
+	if err := job.Run(); err != nil {
 		t.Fatal(err)
 	}
-	defer nuke(runtime2)
+
+	runtime2 := mkRuntimeFromEngine(eng, t)
 	if len(runtime2.List()) != 2 {
 		t.Errorf("Expected 2 container, %v found", len(runtime2.List()))
 	}
@@ -575,7 +579,24 @@ func TestRestore(t *testing.T) {
 }
 
 func TestReloadContainerLinks(t *testing.T) {
-	runtime1 := mkRuntime(t)
+	// FIXME: here we don't use NewTestEngine because it calls initapi with Autorestart=false,
+	// and we want to set it to true.
+	root, err := newTestDirectory(unitTestStoreBase)
+	if err != nil {
+		t.Fatal(err)
+	}
+	eng, err := engine.New(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	job := eng.Job("initapi")
+	job.Setenv("Root", eng.Root())
+	job.SetenvBool("Autorestart", true)
+	if err := job.Run(); err != nil {
+		t.Fatal(err)
+	}
+
+	runtime1 := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime1)
 	// Create a container with one instance of docker
 	container1, _ := mkContainer(runtime1, []string{"-i", "_", "/bin/sh"}, t)
@@ -590,7 +611,9 @@ func TestReloadContainerLinks(t *testing.T) {
 		t.Fatal(err)
 	}
 	// Add a link to container 2
-	container1.hostConfig.Links = []string{"/" + container2.ID + ":first"}
+	// FIXME @shykes: setting hostConfig.Links seems redundant with calling RegisterLink().
+	// Why do we need it @crosbymichael?
+	// container1.hostConfig.Links = []string{"/" + container2.ID + ":first"}
 	if err := runtime1.RegisterLink(container1, container2, "first"); err != nil {
 		t.Fatal(err)
 	}
@@ -612,12 +635,13 @@ func TestReloadContainerLinks(t *testing.T) {
 
 	// Here are are simulating a docker restart - that is, reloading all containers
 	// from scratch
-	runtime1.config.AutoRestart = true
-	runtime2, err := NewRuntimeFromDirectory(runtime1.config)
-	if err != nil {
+	job = eng.Job("initapi")
+	job.Setenv("Root", eng.Root())
+	job.SetenvBool("AutoRestart", false)
+	if err := job.Run(); err != nil {
 		t.Fatal(err)
 	}
-	defer nuke(runtime2)
+	runtime2 := mkRuntimeFromEngine(eng, t)
 	if len(runtime2.List()) != 2 {
 		t.Errorf("Expected 2 container, %v found", len(runtime2.List()))
 	}
@@ -631,27 +655,32 @@ func TestReloadContainerLinks(t *testing.T) {
 		t.Fatalf("Expected 2 container alive, %d found", runningCount)
 	}
 
+	// FIXME: we no longer test if containers were registered in the right order,
+	// because there is no public
 	// Make sure container 2 ( the child of container 1 ) was registered and started first
 	// with the runtime
-	first := runtime2.containers.Front()
-	if first.Value.(*Container).ID != container2.ID {
+	//
+	containers := runtime2.List()
+	if len(containers) == 0 {
+		t.Fatalf("Runtime has no containers")
+	}
+	first := containers[0]
+	if first.ID != container2.ID {
 		t.Fatalf("Container 2 %s should be registered first in the runtime", container2.ID)
 	}
 
 	// Verify that the link is still registered in the runtime
-	entity := runtime2.containerGraph.Get(container1.Name)
-	if entity == nil {
-		t.Fatal("Entity should not be nil")
+	if c := runtime2.Get(container1.Name); c == nil {
+		t.Fatal("Named container is no longer registered after restart")
 	}
 }
 
 func TestDefaultContainerName(t *testing.T) {
 	eng := NewTestEngine(t)
-	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
+	runtime := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime)
 
-	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
+	config, _, _, err := docker.ParseRun([]string{unitTestImageID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -663,29 +692,19 @@ func TestDefaultContainerName(t *testing.T) {
 		t.Fatalf("Expect /some_name got %s", container.Name)
 	}
 
-	paths := runtime.containerGraph.RefPaths(containerID)
-	if paths == nil || len(paths) == 0 {
-		t.Fatalf("Could not find edges for %s", containerID)
-	}
-	edge := paths[0]
-	if edge.ParentID != "0" {
-		t.Fatalf("Expected engine got %s", edge.ParentID)
-	}
-	if edge.EntityID != containerID {
-		t.Fatalf("Expected %s got %s", containerID, edge.EntityID)
-	}
-	if edge.Name != "some_name" {
-		t.Fatalf("Expected some_name got %s", edge.Name)
+	if c := runtime.Get("/some_name"); c == nil {
+		t.Fatalf("Couldn't retrieve test container as /some_name")
+	} else if c.ID != containerID {
+		t.Fatalf("Container /some_name has ID %s instead of %s", c.ID, containerID)
 	}
 }
 
 func TestRandomContainerName(t *testing.T) {
 	eng := NewTestEngine(t)
-	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
+	runtime := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime)
 
-	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
+	config, _, _, err := docker.ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -697,29 +716,19 @@ func TestRandomContainerName(t *testing.T) {
 		t.Fatalf("Expected not empty container name")
 	}
 
-	paths := runtime.containerGraph.RefPaths(containerID)
-	if paths == nil || len(paths) == 0 {
-		t.Fatalf("Could not find edges for %s", containerID)
-	}
-	edge := paths[0]
-	if edge.ParentID != "0" {
-		t.Fatalf("Expected engine got %s", edge.ParentID)
-	}
-	if edge.EntityID != containerID {
-		t.Fatalf("Expected %s got %s", containerID, edge.EntityID)
-	}
-	if edge.Name == "" {
-		t.Fatalf("Expected not empty container name")
+	if c := runtime.Get(container.Name); c == nil {
+		log.Fatalf("Could not lookup container %s by its name", container.Name)
+	} else if c.ID != containerID {
+		log.Fatalf("Looking up container name %s returned id %s instead of %s", container.Name, c.ID, containerID)
 	}
 }
 
 func TestLinkChildContainer(t *testing.T) {
 	eng := NewTestEngine(t)
-	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
+	runtime := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime)
 
-	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
+	config, _, _, err := docker.ParseRun([]string{unitTestImageID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -735,7 +744,7 @@ func TestLinkChildContainer(t *testing.T) {
 		t.Fatalf("Expect webapp id to match container id: %s != %s", webapp.ID, container.ID)
 	}
 
-	config, _, _, err = ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
+	config, _, _, err = docker.ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -758,11 +767,10 @@ func TestLinkChildContainer(t *testing.T) {
 
 func TestGetAllChildren(t *testing.T) {
 	eng := NewTestEngine(t)
-	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
+	runtime := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime)
 
-	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
+	config, _, _, err := docker.ParseRun([]string{unitTestImageID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -778,7 +786,7 @@ func TestGetAllChildren(t *testing.T) {
 		t.Fatalf("Expect webapp id to match container id: %s != %s", webapp.ID, container.ID)
 	}
 
-	config, _, _, err = ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
+	config, _, _, err = docker.ParseRun([]string{unitTestImageID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -810,19 +818,3 @@ func TestGetAllChildren(t *testing.T) {
 		}
 	}
 }
-
-func TestGetFullName(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	name, err := runtime.getFullName("testing")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if name != "/testing" {
-		t.Fatalf("Expected /testing got %s", name)
-	}
-	if _, err := runtime.getFullName(""); err == nil {
-		t.Fatal("Error should not be nil")
-	}
-}
diff --git a/components/engine/integration/server_test.go b/components/engine/integration/server_test.go
index 1ab38422f5..6c61bedafb 100644
--- a/components/engine/integration/server_test.go
+++ b/components/engine/integration/server_test.go
@@ -1,32 +1,31 @@
 package docker
 
 import (
+	"github.com/dotcloud/docker"
 	"github.com/dotcloud/docker/utils"
 	"io/ioutil"
 	"strings"
 	"testing"
-	"time"
 )
 
 func TestContainerTagImageDelete(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
 
-	srv := &Server{runtime: runtime}
+	srv := mkServerFromEngine(eng, t)
 
 	initialImages, err := srv.Images(false, "")
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	if err := srv.runtime.repositories.Set("utest", "tag1", unitTestImageName, false); err != nil {
+	if err := srv.ContainerTag(unitTestImageName, "utest", "tag1", false); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := srv.runtime.repositories.Set("utest/docker", "tag2", unitTestImageName, false); err != nil {
+	if err := srv.ContainerTag(unitTestImageName, "utest/docker", "tag2", false); err != nil {
 		t.Fatal(err)
 	}
-	if err := srv.runtime.repositories.Set("utest:5000/docker", "tag3", unitTestImageName, false); err != nil {
+	if err := srv.ContainerTag(unitTestImageName, "utest:5000/docker", "tag3", false); err != nil {
 		t.Fatal(err)
 	}
 
@@ -82,46 +81,43 @@ func TestContainerTagImageDelete(t *testing.T) {
 func TestCreateRm(t *testing.T) {
 	eng := NewTestEngine(t)
 	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
-	defer nuke(runtime)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
 
-	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
+	config, _, _, err := docker.ParseRun([]string{unitTestImageID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	id := createTestContainer(eng, config, t)
 
-	if len(runtime.List()) != 1 {
-		t.Errorf("Expected 1 container, %v found", len(runtime.List()))
+	if c := srv.Containers(true, false, -1, "", ""); len(c) != 1 {
+		t.Errorf("Expected 1 container, %v found", len(c))
 	}
 
 	if err = srv.ContainerDestroy(id, true, false); err != nil {
 		t.Fatal(err)
 	}
 
-	if len(runtime.List()) != 0 {
-		t.Errorf("Expected 0 container, %v found", len(runtime.List()))
+	if c := srv.Containers(true, false, -1, "", ""); len(c) != 0 {
+		t.Errorf("Expected 0 container, %v found", len(c))
 	}
 
 }
 
 func TestCreateRmVolumes(t *testing.T) {
 	eng := NewTestEngine(t)
-
 	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
-	defer nuke(runtime)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
 
-	config, hostConfig, _, err := ParseRun([]string{"-v", "/srv", GetTestImage(runtime).ID, "echo test"}, nil)
+	config, hostConfig, _, err := docker.ParseRun([]string{"-v", "/srv", unitTestImageID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	id := createTestContainer(eng, config, t)
 
-	if len(runtime.List()) != 1 {
-		t.Errorf("Expected 1 container, %v found", len(runtime.List()))
+	if c := srv.Containers(true, false, -1, "", ""); len(c) != 1 {
+		t.Errorf("Expected 1 container, %v found", len(c))
 	}
 
 	job := eng.Job("start", id)
@@ -141,18 +137,17 @@ func TestCreateRmVolumes(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(runtime.List()) != 0 {
-		t.Errorf("Expected 0 container, %v found", len(runtime.List()))
+	if c := srv.Containers(true, false, -1, "", ""); len(c) != 0 {
+		t.Errorf("Expected 0 container, %v found", len(c))
 	}
 }
 
 func TestCommit(t *testing.T) {
 	eng := NewTestEngine(t)
 	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
-	defer nuke(runtime)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
 
-	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "/bin/cat"}, nil)
+	config, _, _, err := docker.ParseRun([]string{unitTestImageID, "/bin/cat"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -167,18 +162,17 @@ func TestCommit(t *testing.T) {
 func TestCreateStartRestartStopStartKillRm(t *testing.T) {
 	eng := NewTestEngine(t)
 	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
-	defer nuke(runtime)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
 
-	config, hostConfig, _, err := ParseRun([]string{GetTestImage(runtime).ID, "/bin/cat"}, nil)
+	config, hostConfig, _, err := docker.ParseRun([]string{unitTestImageID, "/bin/cat"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	id := createTestContainer(eng, config, t)
 
-	if len(runtime.List()) != 1 {
-		t.Errorf("Expected 1 container, %v found", len(runtime.List()))
+	if c := srv.Containers(true, false, -1, "", ""); len(c) != 1 {
+		t.Errorf("Expected 1 container, %v found", len(c))
 	}
 
 	job := eng.Job("start", id)
@@ -214,21 +208,18 @@ func TestCreateStartRestartStopStartKillRm(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(runtime.List()) != 0 {
-		t.Errorf("Expected 0 container, %v found", len(runtime.List()))
+	if c := srv.Containers(true, false, -1, "", ""); len(c) != 0 {
+		t.Errorf("Expected 0 container, %v found", len(c))
 	}
-
 }
 
 func TestRunWithTooLowMemoryLimit(t *testing.T) {
 	eng := NewTestEngine(t)
-	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
-	defer nuke(runtime)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
 
 	// Try to create a container with a memory limit of 1 byte less than the minimum allowed limit.
 	job := eng.Job("create")
-	job.Setenv("Image", GetTestImage(runtime).ID)
+	job.Setenv("Image", unitTestImageID)
 	job.Setenv("Memory", "524287")
 	job.Setenv("CpuShares", "1000")
 	job.SetenvList("Cmd", []string{"/bin/cat"})
@@ -239,163 +230,17 @@ func TestRunWithTooLowMemoryLimit(t *testing.T) {
 	}
 }
 
-func TestContainerTop(t *testing.T) {
-	t.Skip("Fixme. Skipping test for now. Reported error: 'server_test.go:236: Expected 2 processes, found 1.'")
-
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &Server{runtime: runtime}
-
-	c, _ := mkContainer(runtime, []string{"_", "/bin/sh", "-c", "sleep 2"}, t)
-	c, err := mkContainer(runtime, []string{"_", "/bin/sh", "-c", "sleep 2"}, t)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	defer runtime.Destroy(c)
-	if err := c.Start(); err != nil {
-		t.Fatal(err)
-	}
-
-	// Give some time to the process to start
-	c.WaitTimeout(500 * time.Millisecond)
-
-	if !c.State.Running {
-		t.Errorf("Container should be running")
-	}
-	procs, err := srv.ContainerTop(c.ID, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(procs.Processes) != 2 {
-		t.Fatalf("Expected 2 processes, found %d.", len(procs.Processes))
-	}
-
-	pos := -1
-	for i := 0; i < len(procs.Titles); i++ {
-		if procs.Titles[i] == "CMD" {
-			pos = i
-			break
-		}
-	}
-
-	if pos == -1 {
-		t.Fatalf("Expected CMD, not found.")
-	}
-
-	if procs.Processes[0][pos] != "sh" && procs.Processes[0][pos] != "busybox" {
-		t.Fatalf("Expected `busybox` or `sh`, found %s.", procs.Processes[0][pos])
-	}
-
-	if procs.Processes[1][pos] != "sh" && procs.Processes[1][pos] != "busybox" {
-		t.Fatalf("Expected `busybox` or `sh`, found %s.", procs.Processes[1][pos])
-	}
-}
-
-func TestPools(t *testing.T) {
-	runtime := mkRuntime(t)
-	srv := &Server{
-		runtime:     runtime,
-		pullingPool: make(map[string]struct{}),
-		pushingPool: make(map[string]struct{}),
-	}
-	defer nuke(runtime)
-
-	err := srv.poolAdd("pull", "test1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = srv.poolAdd("pull", "test2")
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = srv.poolAdd("push", "test1")
-	if err == nil || err.Error() != "pull test1 is already in progress" {
-		t.Fatalf("Expected `pull test1 is already in progress`")
-	}
-	err = srv.poolAdd("pull", "test1")
-	if err == nil || err.Error() != "pull test1 is already in progress" {
-		t.Fatalf("Expected `pull test1 is already in progress`")
-	}
-	err = srv.poolAdd("wait", "test3")
-	if err == nil || err.Error() != "Unknown pool type" {
-		t.Fatalf("Expected `Unknown pool type`")
-	}
-
-	err = srv.poolRemove("pull", "test2")
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = srv.poolRemove("pull", "test2")
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = srv.poolRemove("pull", "test1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = srv.poolRemove("push", "test1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = srv.poolRemove("wait", "test3")
-	if err == nil || err.Error() != "Unknown pool type" {
-		t.Fatalf("Expected `Unknown pool type`")
-	}
-}
-
-func TestLogEvent(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-	srv := &Server{
-		runtime:   runtime,
-		events:    make([]utils.JSONMessage, 0, 64),
-		listeners: make(map[string]chan utils.JSONMessage),
-	}
-
-	srv.LogEvent("fakeaction", "fakeid", "fakeimage")
-
-	listener := make(chan utils.JSONMessage)
-	srv.Lock()
-	srv.listeners["test"] = listener
-	srv.Unlock()
-
-	srv.LogEvent("fakeaction2", "fakeid", "fakeimage")
-
-	if len(srv.events) != 2 {
-		t.Fatalf("Expected 2 events, found %d", len(srv.events))
-	}
-	go func() {
-		time.Sleep(200 * time.Millisecond)
-		srv.LogEvent("fakeaction3", "fakeid", "fakeimage")
-		time.Sleep(200 * time.Millisecond)
-		srv.LogEvent("fakeaction4", "fakeid", "fakeimage")
-	}()
-
-	setTimeout(t, "Listening for events timed out", 2*time.Second, func() {
-		for i := 2; i < 4; i++ {
-			event := <-listener
-			if event != srv.events[i] {
-				t.Fatalf("Event received it different than expected")
-			}
-		}
-	})
-}
-
 func TestRmi(t *testing.T) {
 	eng := NewTestEngine(t)
 	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
-	defer nuke(runtime)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
 
 	initialImages, err := srv.Images(false, "")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	config, hostConfig, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)
+	config, hostConfig, _, err := docker.ParseRun([]string{unitTestImageID, "echo test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -471,19 +316,19 @@ func TestRmi(t *testing.T) {
 }
 
 func TestImagesFilter(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+	eng := NewTestEngine(t)
+	defer nuke(mkRuntimeFromEngine(eng, t))
 
-	srv := &Server{runtime: runtime}
+	srv := mkServerFromEngine(eng, t)
 
-	if err := srv.runtime.repositories.Set("utest", "tag1", unitTestImageName, false); err != nil {
+	if err := srv.ContainerTag(unitTestImageName, "utest", "tag1", false); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := srv.runtime.repositories.Set("utest/docker", "tag2", unitTestImageName, false); err != nil {
+	if err := srv.ContainerTag(unitTestImageName, "utest/docker", "tag2", false); err != nil {
 		t.Fatal(err)
 	}
-	if err := srv.runtime.repositories.Set("utest:5000/docker", "tag3", unitTestImageName, false); err != nil {
+	if err := srv.ContainerTag(unitTestImageName, "utest:5000/docker", "tag3", false); err != nil {
 		t.Fatal(err)
 	}
 
@@ -525,9 +370,9 @@ func TestImagesFilter(t *testing.T) {
 }
 
 func TestImageInsert(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-	srv := &Server{runtime: runtime}
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 	sf := utils.NewStreamFormatter(true)
 
 	// bad image name fails
@@ -536,12 +381,12 @@ func TestImageInsert(t *testing.T) {
 	}
 
 	// bad url fails
-	if err := srv.ImageInsert(GetTestImage(runtime).ID, "http://bad_host_name_that_will_totally_fail.com/", "/foo", ioutil.Discard, sf); err == nil {
+	if err := srv.ImageInsert(unitTestImageID, "http://bad_host_name_that_will_totally_fail.com/", "/foo", ioutil.Discard, sf); err == nil {
 		t.Fatal("expected an error and got none")
 	}
 
 	// success returns nil
-	if err := srv.ImageInsert(GetTestImage(runtime).ID, "https://www.docker.io/static/img/docker-top-logo.png", "/foo", ioutil.Discard, sf); err != nil {
+	if err := srv.ImageInsert(unitTestImageID, "https://www.docker.io/static/img/docker-top-logo.png", "/foo", ioutil.Discard, sf); err != nil {
 		t.Fatalf("expected no error, but got %v", err)
 	}
 }
diff --git a/components/engine/integration/sorter_test.go b/components/engine/integration/sorter_test.go
index 54f647132f..77848c7ddf 100644
--- a/components/engine/integration/sorter_test.go
+++ b/components/engine/integration/sorter_test.go
@@ -1,25 +1,21 @@
 package docker
 
 import (
-	"fmt"
+	"github.com/dotcloud/docker"
+	"github.com/dotcloud/docker/utils"
+	"io/ioutil"
 	"testing"
 	"time"
 )
 
 func TestServerListOrderedImagesByCreationDate(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-	archive, err := fakeTar()
-	if err != nil {
+	if err := generateImage("", srv); err != nil {
 		t.Fatal(err)
 	}
-	_, err = runtime.graph.Create(archive, nil, "Testing", "", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	srv := &Server{runtime: runtime}
 
 	images, err := srv.Images(true, "")
 	if err != nil {
@@ -32,22 +28,22 @@ func TestServerListOrderedImagesByCreationDate(t *testing.T) {
 }
 
 func TestServerListOrderedImagesByCreationDateAndTag(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-	err := generateImage("bar", runtime)
+	err := generateImage("bar", srv)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	time.Sleep(time.Second)
 
-	err = generateImage("zed", runtime)
+	err = generateImage("zed", srv)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	srv := &Server{runtime: runtime}
 	images, err := srv.Images(true, "")
 	if err != nil {
 		t.Fatal(err)
@@ -58,54 +54,10 @@ func TestServerListOrderedImagesByCreationDateAndTag(t *testing.T) {
 	}
 }
 
-func generateImage(name string, runtime *Runtime) error {
-
+func generateImage(name string, srv *docker.Server) error {
 	archive, err := fakeTar()
 	if err != nil {
 		return err
 	}
-	image, err := runtime.graph.Create(archive, nil, "Testing", "", nil)
-	if err != nil {
-		return err
-	}
-
-	srv := &Server{runtime: runtime}
-	srv.ContainerTag(image.ID, "repo", name, false)
-
-	return nil
-}
-
-func TestSortUniquePorts(t *testing.T) {
-	ports := []Port{
-		Port("6379/tcp"),
-		Port("22/tcp"),
-	}
-
-	sortPorts(ports, func(ip, jp Port) bool {
-		return ip.Int() < jp.Int() || (ip.Int() == jp.Int() && ip.Proto() == "tcp")
-	})
-
-	first := ports[0]
-	if fmt.Sprint(first) != "22/tcp" {
-		t.Log(fmt.Sprint(first))
-		t.Fail()
-	}
-}
-
-func TestSortSamePortWithDifferentProto(t *testing.T) {
-	ports := []Port{
-		Port("8888/tcp"),
-		Port("8888/udp"),
-		Port("6379/tcp"),
-		Port("6379/udp"),
-	}
-
-	sortPorts(ports, func(ip, jp Port) bool {
-		return ip.Int() < jp.Int() || (ip.Int() == jp.Int() && ip.Proto() == "tcp")
-	})
-
-	first := ports[0]
-	if fmt.Sprint(first) != "6379/tcp" {
-		t.Fail()
-	}
+	return srv.ImageImport("-", "repo", name, archive, ioutil.Discard, utils.NewStreamFormatter(true))
 }
diff --git a/components/engine/integration/utils_test.go b/components/engine/integration/utils_test.go
index a9678a9bbd..b20194c0dc 100644
--- a/components/engine/integration/utils_test.go
+++ b/components/engine/integration/utils_test.go
@@ -1,14 +1,15 @@
 package docker
 
 import (
-	"fmt"
+	"archive/tar"
+	"bytes"
+	"github.com/dotcloud/docker"
 	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/utils"
 	"io"
 	"io/ioutil"
 	"os"
 	"path"
-	"runtime"
 	"strings"
 	"testing"
 )
@@ -17,20 +18,18 @@ import (
 // It has to be named XXX_test.go, apparently, in other to access private functions
 // from other XXX_test.go functions.
 
-var globalTestID string
-
 // Create a temporary runtime suitable for unit testing.
 // Call t.Fatal() at the first error.
-func mkRuntime(f utils.Fataler) *Runtime {
+func mkRuntime(f utils.Fataler) *docker.Runtime {
 	root, err := newTestDirectory(unitTestStoreBase)
 	if err != nil {
 		f.Fatal(err)
 	}
-	config := &DaemonConfig{
+	config := &docker.DaemonConfig{
 		Root:        root,
 		AutoRestart: false,
 	}
-	r, err := NewRuntimeFromDirectory(config)
+	r, err := docker.NewRuntimeFromDirectory(config)
 	if err != nil {
 		f.Fatal(err)
 	}
@@ -38,7 +37,7 @@ func mkRuntime(f utils.Fataler) *Runtime {
 	return r
 }
 
-func createNamedTestContainer(eng *engine.Engine, config *Config, f utils.Fataler, name string) (shortId string) {
+func createNamedTestContainer(eng *engine.Engine, config *docker.Config, f utils.Fataler, name string) (shortId string) {
 	job := eng.Job("create", name)
 	if err := job.ImportEnv(config); err != nil {
 		f.Fatal(err)
@@ -50,22 +49,34 @@ func createNamedTestContainer(eng *engine.Engine, config *Config, f utils.Fatale
 	return
 }
 
-func createTestContainer(eng *engine.Engine, config *Config, f utils.Fataler) (shortId string) {
+func createTestContainer(eng *engine.Engine, config *docker.Config, f utils.Fataler) (shortId string) {
 	return createNamedTestContainer(eng, config, f, "")
 }
 
-func mkServerFromEngine(eng *engine.Engine, t utils.Fataler) *Server {
+func mkServerFromEngine(eng *engine.Engine, t utils.Fataler) *docker.Server {
 	iSrv := eng.Hack_GetGlobalVar("httpapi.server")
 	if iSrv == nil {
 		panic("Legacy server field not set in engine")
 	}
-	srv, ok := iSrv.(*Server)
+	srv, ok := iSrv.(*docker.Server)
 	if !ok {
-		panic("Legacy server field in engine does not cast to *Server")
+		panic("Legacy server field in engine does not cast to *docker.Server")
 	}
 	return srv
 }
 
+func mkRuntimeFromEngine(eng *engine.Engine, t utils.Fataler) *docker.Runtime {
+	iRuntime := eng.Hack_GetGlobalVar("httpapi.runtime")
+	if iRuntime == nil {
+		panic("Legacy runtime field not set in engine")
+	}
+	runtime, ok := iRuntime.(*docker.Runtime)
+	if !ok {
+		panic("Legacy runtime field in engine does not cast to *docker.Runtime")
+	}
+	return runtime
+}
+
 func NewTestEngine(t utils.Fataler) *engine.Engine {
 	root, err := newTestDirectory(unitTestStoreBase)
 	if err != nil {
@@ -87,31 +98,11 @@ func NewTestEngine(t utils.Fataler) *engine.Engine {
 }
 
 func newTestDirectory(templateDir string) (dir string, err error) {
-	if globalTestID == "" {
-		globalTestID = GenerateID()[:4]
-	}
-	prefix := fmt.Sprintf("docker-test%s-%s-", globalTestID, getCallerName(2))
-	if prefix == "" {
-		prefix = "docker-test-"
-	}
-	dir, err = ioutil.TempDir("", prefix)
-	if err = os.Remove(dir); err != nil {
-		return
-	}
-	if err = utils.CopyDirectory(templateDir, dir); err != nil {
-		return
-	}
-	return
+	return utils.TestDirectory(templateDir)
 }
 
 func getCallerName(depth int) string {
-	// Use the caller function name as a prefix.
-	// This helps trace temp directories back to their test.
-	pc, _, _, _ := runtime.Caller(depth + 1)
-	callerLongName := runtime.FuncForPC(pc).Name()
-	parts := strings.Split(callerLongName, ".")
-	callerShortName := parts[len(parts)-1]
-	return callerShortName
+	return utils.GetCallerName(depth)
 }
 
 // Write `content` to the file at path `dst`, creating it if necessary,
@@ -152,8 +143,8 @@ func readFile(src string, t *testing.T) (content string) {
 // dynamically replaced by the current test image.
 // The caller is responsible for destroying the container.
 // Call t.Fatal() at the first error.
-func mkContainer(r *Runtime, args []string, t *testing.T) (*Container, error) {
-	config, hostConfig, _, err := ParseRun(args, nil)
+func mkContainer(r *docker.Runtime, args []string, t *testing.T) (*docker.Container, error) {
+	config, _, _, err := docker.ParseRun(args, nil)
 	defer func() {
 		if err != nil && t != nil {
 			t.Fatal(err)
@@ -169,7 +160,13 @@ func mkContainer(r *Runtime, args []string, t *testing.T) (*Container, error) {
 	if err != nil {
 		return nil, err
 	}
-	c.hostConfig = hostConfig
+	// NOTE: hostConfig is ignored.
+	// If `args` specify privileged mode, custom lxc conf, external mount binds,
+	// port redirects etc. they will be ignored.
+	// This is because the correct way to set these things is to pass environment
+	// to the `start` job.
+	// FIXME: this helper function should be deprecated in favor of calling
+	// `create` and `start` jobs directly.
 	return c, nil
 }
 
@@ -177,7 +174,7 @@ func mkContainer(r *Runtime, args []string, t *testing.T) (*Container, error) {
 // and return its standard output as a string.
 // The image name (eg. the XXX in []string{"-i", "-t", "XXX", "bash"}, is dynamically replaced by the current test image.
 // If t is not nil, call t.Fatal() at the first error. Otherwise return errors normally.
-func runContainer(r *Runtime, args []string, t *testing.T) (output string, err error) {
+func runContainer(r *docker.Runtime, args []string, t *testing.T) (output string, err error) {
 	defer func() {
 		if err != nil && t != nil {
 			t.Fatal(err)
@@ -205,289 +202,20 @@ func runContainer(r *Runtime, args []string, t *testing.T) (output string, err e
 	return
 }
 
-func TestCompareConfig(t *testing.T) {
-	volumes1 := make(map[string]struct{})
-	volumes1["/test1"] = struct{}{}
-	config1 := Config{
-		Dns:         []string{"1.1.1.1", "2.2.2.2"},
-		PortSpecs:   []string{"1111:1111", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "11111111",
-		Volumes:     volumes1,
-	}
-	config2 := Config{
-		Dns:         []string{"0.0.0.0", "2.2.2.2"},
-		PortSpecs:   []string{"1111:1111", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "11111111",
-		Volumes:     volumes1,
-	}
-	config3 := Config{
-		Dns:         []string{"1.1.1.1", "2.2.2.2"},
-		PortSpecs:   []string{"0000:0000", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "11111111",
-		Volumes:     volumes1,
-	}
-	config4 := Config{
-		Dns:         []string{"1.1.1.1", "2.2.2.2"},
-		PortSpecs:   []string{"0000:0000", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "22222222",
-		Volumes:     volumes1,
-	}
-	volumes2 := make(map[string]struct{})
-	volumes2["/test2"] = struct{}{}
-	config5 := Config{
-		Dns:         []string{"1.1.1.1", "2.2.2.2"},
-		PortSpecs:   []string{"0000:0000", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "11111111",
-		Volumes:     volumes2,
-	}
-	if CompareConfig(&config1, &config2) {
-		t.Fatalf("CompareConfig should return false, Dns are different")
-	}
-	if CompareConfig(&config1, &config3) {
-		t.Fatalf("CompareConfig should return false, PortSpecs are different")
-	}
-	if CompareConfig(&config1, &config4) {
-		t.Fatalf("CompareConfig should return false, VolumesFrom are different")
-	}
-	if CompareConfig(&config1, &config5) {
-		t.Fatalf("CompareConfig should return false, Volumes are different")
-	}
-	if !CompareConfig(&config1, &config1) {
-		t.Fatalf("CompareConfig should return true")
-	}
-}
-
-func TestMergeConfig(t *testing.T) {
-	volumesImage := make(map[string]struct{})
-	volumesImage["/test1"] = struct{}{}
-	volumesImage["/test2"] = struct{}{}
-	configImage := &Config{
-		Dns:         []string{"1.1.1.1", "2.2.2.2"},
-		PortSpecs:   []string{"1111:1111", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "1111",
-		Volumes:     volumesImage,
-	}
-
-	volumesUser := make(map[string]struct{})
-	volumesUser["/test3"] = struct{}{}
-	configUser := &Config{
-		Dns:       []string{"3.3.3.3"},
-		PortSpecs: []string{"3333:2222", "3333:3333"},
-		Env:       []string{"VAR2=3", "VAR3=3"},
-		Volumes:   volumesUser,
-	}
-
-	if err := MergeConfig(configUser, configImage); err != nil {
-		t.Error(err)
-	}
-
-	if len(configUser.Dns) != 3 {
-		t.Fatalf("Expected 3 dns, 1.1.1.1, 2.2.2.2 and 3.3.3.3, found %d", len(configUser.Dns))
-	}
-	for _, dns := range configUser.Dns {
-		if dns != "1.1.1.1" && dns != "2.2.2.2" && dns != "3.3.3.3" {
-			t.Fatalf("Expected 1.1.1.1 or 2.2.2.2 or 3.3.3.3, found %s", dns)
-		}
-	}
-
-	if len(configUser.ExposedPorts) != 3 {
-		t.Fatalf("Expected 3 ExposedPorts, 1111, 2222 and 3333, found %d", len(configUser.ExposedPorts))
-	}
-	for portSpecs := range configUser.ExposedPorts {
-		if portSpecs.Port() != "1111" && portSpecs.Port() != "2222" && portSpecs.Port() != "3333" {
-			t.Fatalf("Expected 1111 or 2222 or 3333, found %s", portSpecs)
-		}
-	}
-	if len(configUser.Env) != 3 {
-		t.Fatalf("Expected 3 env var, VAR1=1, VAR2=3 and VAR3=3, found %d", len(configUser.Env))
-	}
-	for _, env := range configUser.Env {
-		if env != "VAR1=1" && env != "VAR2=3" && env != "VAR3=3" {
-			t.Fatalf("Expected VAR1=1 or VAR2=3 or VAR3=3, found %s", env)
-		}
-	}
-
-	if len(configUser.Volumes) != 3 {
-		t.Fatalf("Expected 3 volumes, /test1, /test2 and /test3, found %d", len(configUser.Volumes))
-	}
-	for v := range configUser.Volumes {
-		if v != "/test1" && v != "/test2" && v != "/test3" {
-			t.Fatalf("Expected /test1 or /test2 or /test3, found %s", v)
-		}
-	}
-
-	if configUser.VolumesFrom != "1111" {
-		t.Fatalf("Expected VolumesFrom to be 1111, found %s", configUser.VolumesFrom)
-	}
-
-	ports, _, err := parsePortSpecs([]string{"0000"})
-	if err != nil {
-		t.Error(err)
-	}
-	configImage2 := &Config{
-		ExposedPorts: ports,
-	}
-
-	if err := MergeConfig(configUser, configImage2); err != nil {
-		t.Error(err)
-	}
-
-	if len(configUser.ExposedPorts) != 4 {
-		t.Fatalf("Expected 4 ExposedPorts, 0000, 1111, 2222 and 3333, found %d", len(configUser.ExposedPorts))
-	}
-	for portSpecs := range configUser.ExposedPorts {
-		if portSpecs.Port() != "0000" && portSpecs.Port() != "1111" && portSpecs.Port() != "2222" && portSpecs.Port() != "3333" {
-			t.Fatalf("Expected 0000 or 1111 or 2222 or 3333, found %s", portSpecs)
-		}
-	}
-
-}
-
-func TestParseLxcConfOpt(t *testing.T) {
-	opts := []string{"lxc.utsname=docker", "lxc.utsname = docker "}
-
-	for _, o := range opts {
-		k, v, err := parseLxcOpt(o)
-		if err != nil {
-			t.FailNow()
-		}
-		if k != "lxc.utsname" {
-			t.Fail()
-		}
-		if v != "docker" {
-			t.Fail()
-		}
-	}
-}
-
-func TestParseNetworkOptsPrivateOnly(t *testing.T) {
-	ports, bindings, err := parsePortSpecs([]string{"192.168.1.100::80"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(ports) != 1 {
-		t.Logf("Expected 1 got %d", len(ports))
-		t.FailNow()
-	}
-	if len(bindings) != 1 {
-		t.Logf("Expected 1 got %d", len(bindings))
-		t.FailNow()
-	}
-	for k := range ports {
-		if k.Proto() != "tcp" {
-			t.Logf("Expected tcp got %s", k.Proto())
-			t.Fail()
-		}
-		if k.Port() != "80" {
-			t.Logf("Expected 80 got %s", k.Port())
-			t.Fail()
-		}
-		b, exists := bindings[k]
-		if !exists {
-			t.Log("Binding does not exist")
-			t.FailNow()
-		}
-		if len(b) != 1 {
-			t.Logf("Expected 1 got %d", len(b))
-			t.FailNow()
-		}
-		s := b[0]
-		if s.HostPort != "" {
-			t.Logf("Expected \"\" got %s", s.HostPort)
-			t.Fail()
-		}
-		if s.HostIp != "192.168.1.100" {
-			t.Fail()
-		}
-	}
-}
-
-func TestParseNetworkOptsPublic(t *testing.T) {
-	ports, bindings, err := parsePortSpecs([]string{"192.168.1.100:8080:80"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(ports) != 1 {
-		t.Logf("Expected 1 got %d", len(ports))
-		t.FailNow()
-	}
-	if len(bindings) != 1 {
-		t.Logf("Expected 1 got %d", len(bindings))
-		t.FailNow()
-	}
-	for k := range ports {
-		if k.Proto() != "tcp" {
-			t.Logf("Expected tcp got %s", k.Proto())
-			t.Fail()
-		}
-		if k.Port() != "80" {
-			t.Logf("Expected 80 got %s", k.Port())
-			t.Fail()
-		}
-		b, exists := bindings[k]
-		if !exists {
-			t.Log("Binding does not exist")
-			t.FailNow()
-		}
-		if len(b) != 1 {
-			t.Logf("Expected 1 got %d", len(b))
-			t.FailNow()
-		}
-		s := b[0]
-		if s.HostPort != "8080" {
-			t.Logf("Expected 8080 got %s", s.HostPort)
-			t.Fail()
-		}
-		if s.HostIp != "192.168.1.100" {
-			t.Fail()
-		}
-	}
-}
-
-func TestParseNetworkOptsUdp(t *testing.T) {
-	ports, bindings, err := parsePortSpecs([]string{"192.168.1.100::6000/udp"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(ports) != 1 {
-		t.Logf("Expected 1 got %d", len(ports))
-		t.FailNow()
-	}
-	if len(bindings) != 1 {
-		t.Logf("Expected 1 got %d", len(bindings))
-		t.FailNow()
-	}
-	for k := range ports {
-		if k.Proto() != "udp" {
-			t.Logf("Expected udp got %s", k.Proto())
-			t.Fail()
-		}
-		if k.Port() != "6000" {
-			t.Logf("Expected 6000 got %s", k.Port())
-			t.Fail()
-		}
-		b, exists := bindings[k]
-		if !exists {
-			t.Log("Binding does not exist")
-			t.FailNow()
-		}
-		if len(b) != 1 {
-			t.Logf("Expected 1 got %d", len(b))
-			t.FailNow()
-		}
-		s := b[0]
-		if s.HostPort != "" {
-			t.Logf("Expected \"\" got %s", s.HostPort)
-			t.Fail()
-		}
-		if s.HostIp != "192.168.1.100" {
-			t.Fail()
-		}
+// FIXME: this is duplicated from graph_test.go in the docker package.
+func fakeTar() (io.Reader, error) {
+	content := []byte("Hello world!\n")
+	buf := new(bytes.Buffer)
+	tw := tar.NewWriter(buf)
+	for _, name := range []string{"/etc/postgres/postgres.conf", "/etc/passwd", "/var/log/postgres/postgres.conf"} {
+		hdr := new(tar.Header)
+		hdr.Size = int64(len(content))
+		hdr.Name = name
+		if err := tw.WriteHeader(hdr); err != nil {
+			return nil, err
+		}
+		tw.Write([]byte(content))
 	}
+	tw.Close()
+	return buf, nil
 }

From 13d08cbd03159a319b89a133d8e8123c9745ca18 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Thu, 14 Nov 2013 06:11:28 +0000
Subject: [PATCH 115/184] gofmt Upstream-commit:
 2a209afe5fe0f27296e3e06a199bb5305910e1cf Component: engine

---
 components/engine/container_unit_test.go | 7 -------
 components/engine/http_test.go           | 3 +--
 components/engine/runtime.go             | 1 -
 components/engine/server_unit_test.go    | 1 -
 components/engine/tags_unit_test.go      | 5 ++---
 components/engine/utils/utils.go         | 3 ---
 6 files changed, 3 insertions(+), 17 deletions(-)

diff --git a/components/engine/container_unit_test.go b/components/engine/container_unit_test.go
index 9647327d98..679f25eee7 100644
--- a/components/engine/container_unit_test.go
+++ b/components/engine/container_unit_test.go
@@ -4,8 +4,6 @@ import (
 	"testing"
 )
 
-
-
 func TestParseLxcConfOpt(t *testing.T) {
 	opts := []string{"lxc.utsname=docker", "lxc.utsname = docker "}
 
@@ -149,12 +147,8 @@ func TestParseNetworkOptsUdp(t *testing.T) {
 	}
 }
 
-
-
-
 // FIXME: test that destroying a container actually removes its root directory
 
-
 /*
 func TestLXCConfig(t *testing.T) {
 	// Memory is allocated randomly for testing
@@ -242,7 +236,6 @@ func grepFile(t *testing.T, path string, pattern string) {
 }
 */
 
-
 func TestGetFullName(t *testing.T) {
 	name, err := getFullName("testing")
 	if err != nil {
diff --git a/components/engine/http_test.go b/components/engine/http_test.go
index 64764424cb..b9ecd6a203 100644
--- a/components/engine/http_test.go
+++ b/components/engine/http_test.go
@@ -1,13 +1,12 @@
 package docker
 
 import (
-	"testing"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"testing"
 )
 
-
 func TestGetBoolParam(t *testing.T) {
 	if ret, err := getBoolParam("true"); err != nil || !ret {
 		t.Fatalf("true -> true, nil | got %t %s", ret, err)
diff --git a/components/engine/runtime.go b/components/engine/runtime.go
index bb90301d48..4559164e28 100644
--- a/components/engine/runtime.go
+++ b/components/engine/runtime.go
@@ -680,7 +680,6 @@ func (runtime *Runtime) Nuke() error {
 	return os.RemoveAll(runtime.config.Root)
 }
 
-
 func linkLxcStart(root string) error {
 	sourcePath, err := exec.LookPath("lxc-start")
 	if err != nil {
diff --git a/components/engine/server_unit_test.go b/components/engine/server_unit_test.go
index 7ce03e3547..a51e2ddff5 100644
--- a/components/engine/server_unit_test.go
+++ b/components/engine/server_unit_test.go
@@ -55,7 +55,6 @@ func TestPools(t *testing.T) {
 	}
 }
 
-
 func TestLogEvent(t *testing.T) {
 	srv := &Server{
 		events:    make([]utils.JSONMessage, 0, 64),
diff --git a/components/engine/tags_unit_test.go b/components/engine/tags_unit_test.go
index 89f31676f7..0f72e30200 100644
--- a/components/engine/tags_unit_test.go
+++ b/components/engine/tags_unit_test.go
@@ -2,9 +2,9 @@ package docker
 
 import (
 	"github.com/dotcloud/docker/utils"
-	"testing"
-	"path"
 	"os"
+	"path"
+	"testing"
 )
 
 const (
@@ -35,7 +35,6 @@ func mkTestTagStore(root string, t *testing.T) *TagStore {
 	return store
 }
 
-
 func TestLookupImage(t *testing.T) {
 	tmp, err := utils.TestDirectory("")
 	if err != nil {
diff --git a/components/engine/utils/utils.go b/components/engine/utils/utils.go
index 0844abdde6..1361cfaf8d 100644
--- a/components/engine/utils/utils.go
+++ b/components/engine/utils/utils.go
@@ -1208,8 +1208,6 @@ func PartParser(template, data string) (map[string]string, error) {
 	return out, nil
 }
 
-
-
 var globalTestID string
 
 // TestDirectory creates a new temporary directory and returns its path.
@@ -1246,4 +1244,3 @@ func GetCallerName(depth int) string {
 	callerShortName := parts[len(parts)-1]
 	return callerShortName
 }
-

From 54481185b5c9b37428e91613829d61c8e18cb3ca Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Thu, 14 Nov 2013 06:14:23 +0000
Subject: [PATCH 116/184] Remove deprecated tags_test.go Upstream-commit:
 e9624bf715134294a7fac1ab8a43508139000253 Component: engine

---
 components/engine/tags_test.go | 46 ----------------------------------
 1 file changed, 46 deletions(-)
 delete mode 100644 components/engine/tags_test.go

diff --git a/components/engine/tags_test.go b/components/engine/tags_test.go
deleted file mode 100644
index d920943795..0000000000
--- a/components/engine/tags_test.go
+++ /dev/null
@@ -1,46 +0,0 @@
-package docker
-
-import (
-	"testing"
-)
-
-func TestLookupImage(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	if img, err := runtime.repositories.LookupImage(unitTestImageName); err != nil {
-		t.Fatal(err)
-	} else if img == nil {
-		t.Errorf("Expected 1 image, none found")
-	}
-
-	if img, err := runtime.repositories.LookupImage(unitTestImageName + ":" + DEFAULTTAG); err != nil {
-		t.Fatal(err)
-	} else if img == nil {
-		t.Errorf("Expected 1 image, none found")
-	}
-
-	if img, err := runtime.repositories.LookupImage(unitTestImageName + ":" + "fail"); err == nil {
-		t.Errorf("Expected error, none found")
-	} else if img != nil {
-		t.Errorf("Expected 0 image, 1 found")
-	}
-
-	if img, err := runtime.repositories.LookupImage("fail:fail"); err == nil {
-		t.Errorf("Expected error, none found")
-	} else if img != nil {
-		t.Errorf("Expected 0 image, 1 found")
-	}
-
-	if img, err := runtime.repositories.LookupImage(unitTestImageID); err != nil {
-		t.Fatal(err)
-	} else if img == nil {
-		t.Errorf("Expected 1 image, none found")
-	}
-
-	if img, err := runtime.repositories.LookupImage(unitTestImageName + ":" + unitTestImageID); err != nil {
-		t.Fatal(err)
-	} else if img == nil {
-		t.Errorf("Expected 1 image, none found")
-	}
-}

From 7456f6a4662d6eba944800edbeb01af1006e52b7 Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Thu, 14 Nov 2013 12:33:15 -0800
Subject: [PATCH 117/184] fix Integration tests Upstream-commit:
 661a8a0e0ce95d9bcb222184c14373fb1dbb1aec Component: engine

---
 .../engine/integration/container_test.go      | 78 ++++++++++---------
 components/engine/integration/runtime_test.go | 28 ++++---
 components/engine/integration/utils_test.go   | 22 ++++--
 3 files changed, 76 insertions(+), 52 deletions(-)

diff --git a/components/engine/integration/container_test.go b/components/engine/integration/container_test.go
index 149a321983..3658d9d4dc 100644
--- a/components/engine/integration/container_test.go
+++ b/components/engine/integration/container_test.go
@@ -41,7 +41,7 @@ func TestIDFormat(t *testing.T) {
 func TestMultipleAttachRestart(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, _ := mkContainer(
+	container, _, _ := mkContainer(
 		runtime,
 		[]string{"_", "/bin/sh", "-c", "i=1; while [ $i -le 5 ]; do i=`expr $i + 1`;  echo hello; done"},
 		t,
@@ -138,7 +138,7 @@ func TestDiff(t *testing.T) {
 	runtime := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime)
 	// Create a container and remove a file
-	container1, _ := mkContainer(runtime, []string{"_", "/bin/rm", "/etc/passwd"}, t)
+	container1, _, _ := mkContainer(runtime, []string{"_", "/bin/rm", "/etc/passwd"}, t)
 	defer runtime.Destroy(container1)
 
 	// The changelog should be empty and not fail before run. See #1705
@@ -176,7 +176,7 @@ func TestDiff(t *testing.T) {
 	}
 
 	// Create a new container from the commited image
-	container2, _ := mkContainer(runtime, []string{img.ID, "cat", "/etc/passwd"}, t)
+	container2, _, _ := mkContainer(runtime, []string{img.ID, "cat", "/etc/passwd"}, t)
 	defer runtime.Destroy(container2)
 
 	if err := container2.Run(); err != nil {
@@ -195,7 +195,7 @@ func TestDiff(t *testing.T) {
 	}
 
 	// Create a new container
-	container3, _ := mkContainer(runtime, []string{"_", "rm", "/bin/httpd"}, t)
+	container3, _, _ := mkContainer(runtime, []string{"_", "rm", "/bin/httpd"}, t)
 	defer runtime.Destroy(container3)
 
 	if err := container3.Run(); err != nil {
@@ -221,7 +221,7 @@ func TestDiff(t *testing.T) {
 func TestCommitAutoRun(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container1, _ := mkContainer(runtime, []string{"_", "/bin/sh", "-c", "echo hello > /world"}, t)
+	container1, _, _ := mkContainer(runtime, []string{"_", "/bin/sh", "-c", "echo hello > /world"}, t)
 	defer runtime.Destroy(container1)
 
 	if container1.State.Running {
@@ -240,7 +240,7 @@ func TestCommitAutoRun(t *testing.T) {
 	}
 
 	// FIXME: Make a TestCommit that stops here and check docker.root/layers/img.id/world
-	container2, _ := mkContainer(runtime, []string{img.ID}, t)
+	container2, _, _ := mkContainer(runtime, []string{img.ID}, t)
 	defer runtime.Destroy(container2)
 	stdout, err := container2.StdoutPipe()
 	if err != nil {
@@ -277,7 +277,7 @@ func TestCommitRun(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	container1, _ := mkContainer(runtime, []string{"_", "/bin/sh", "-c", "echo hello > /world"}, t)
+	container1, _, _ := mkContainer(runtime, []string{"_", "/bin/sh", "-c", "echo hello > /world"}, t)
 	defer runtime.Destroy(container1)
 
 	if container1.State.Running {
@@ -296,7 +296,7 @@ func TestCommitRun(t *testing.T) {
 	}
 
 	// FIXME: Make a TestCommit that stops here and check docker.root/layers/img.id/world
-	container2, _ := mkContainer(runtime, []string{img.ID, "cat", "/world"}, t)
+	container2, _, _ := mkContainer(runtime, []string{img.ID, "cat", "/world"}, t)
 	defer runtime.Destroy(container2)
 	stdout, err := container2.StdoutPipe()
 	if err != nil {
@@ -332,7 +332,7 @@ func TestCommitRun(t *testing.T) {
 func TestStart(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, _ := mkContainer(runtime, []string{"-m", "33554432", "-c", "1000", "-i", "_", "/bin/cat"}, t)
+	container, _, _ := mkContainer(runtime, []string{"-m", "33554432", "-c", "1000", "-i", "_", "/bin/cat"}, t)
 	defer runtime.Destroy(container)
 
 	cStdin, err := container.StdinPipe()
@@ -362,7 +362,7 @@ func TestStart(t *testing.T) {
 func TestRun(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, _ := mkContainer(runtime, []string{"_", "ls", "-al"}, t)
+	container, _, _ := mkContainer(runtime, []string{"_", "ls", "-al"}, t)
 	defer runtime.Destroy(container)
 
 	if container.State.Running {
@@ -1163,11 +1163,12 @@ func tempDir(t *testing.T) string {
 
 // Test for #1737
 func TestCopyVolumeUidGid(t *testing.T) {
-	r := mkRuntime(t)
-	defer nuke(r)
+	eng := NewTestEngine(t)
+	r := mkRuntimeFromEngine(eng, t)
+	defer r.Nuke()
 
 	// Add directory not owned by root
-	container1, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello && touch /hello/test.txt && chown daemon.daemon /hello"}, t)
+	container1, _, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello && touch /hello/test.txt && chown daemon.daemon /hello"}, t)
 	defer r.Destroy(container1)
 
 	if container1.State.Running {
@@ -1188,7 +1189,7 @@ func TestCopyVolumeUidGid(t *testing.T) {
 	// Test that the uid and gid is copied from the image to the volume
 	tmpDir1 := tempDir(t)
 	defer os.RemoveAll(tmpDir1)
-	stdout1, _ := runContainer(r, []string{"-v", "/hello", img.ID, "stat", "-c", "%U %G", "/hello"}, t)
+	stdout1, _ := runContainer(eng, r, []string{"-v", "/hello", img.ID, "stat", "-c", "%U %G", "/hello"}, t)
 	if !strings.Contains(stdout1, "daemon daemon") {
 		t.Fatal("Container failed to transfer uid and gid to volume")
 	}
@@ -1196,11 +1197,12 @@ func TestCopyVolumeUidGid(t *testing.T) {
 
 // Test for #1582
 func TestCopyVolumeContent(t *testing.T) {
-	r := mkRuntime(t)
-	defer nuke(r)
+	eng := NewTestEngine(t)
+	r := mkRuntimeFromEngine(eng, t)
+	defer r.Nuke()
 
 	// Put some content in a directory of a container and commit it
-	container1, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello/local && echo hello > /hello/local/world"}, t)
+	container1, _, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello/local && echo hello > /hello/local/world"}, t)
 	defer r.Destroy(container1)
 
 	if container1.State.Running {
@@ -1221,31 +1223,33 @@ func TestCopyVolumeContent(t *testing.T) {
 	// Test that the content is copied from the image to the volume
 	tmpDir1 := tempDir(t)
 	defer os.RemoveAll(tmpDir1)
-	stdout1, _ := runContainer(r, []string{"-v", "/hello", img.ID, "find", "/hello"}, t)
+	stdout1, _ := runContainer(eng, r, []string{"-v", "/hello", img.ID, "find", "/hello"}, t)
 	if !(strings.Contains(stdout1, "/hello/local/world") && strings.Contains(stdout1, "/hello/local")) {
 		t.Fatal("Container failed to transfer content to volume")
 	}
 }
 
 func TestBindMounts(t *testing.T) {
-	r := mkRuntime(t)
-	defer nuke(r)
+	eng := NewTestEngine(t)
+	r := mkRuntimeFromEngine(eng, t)
+	defer r.Nuke()
+
 	tmpDir := tempDir(t)
 	defer os.RemoveAll(tmpDir)
 	writeFile(path.Join(tmpDir, "touch-me"), "", t)
 
 	// Test reading from a read-only bind mount
-	stdout, _ := runContainer(r, []string{"-v", fmt.Sprintf("%s:/tmp:ro", tmpDir), "_", "ls", "/tmp"}, t)
+	stdout, _ := runContainer(eng, r, []string{"-v", fmt.Sprintf("%s:/tmp:ro", tmpDir), "_", "ls", "/tmp"}, t)
 	if !strings.Contains(stdout, "touch-me") {
 		t.Fatal("Container failed to read from bind mount")
 	}
 
 	// test writing to bind mount
-	runContainer(r, []string{"-v", fmt.Sprintf("%s:/tmp:rw", tmpDir), "_", "touch", "/tmp/holla"}, t)
+	runContainer(eng, r, []string{"-v", fmt.Sprintf("%s:/tmp:rw", tmpDir), "_", "touch", "/tmp/holla"}, t)
 	readFile(path.Join(tmpDir, "holla"), t) // Will fail if the file doesn't exist
 
 	// test mounting to an illegal destination directory
-	if _, err := runContainer(r, []string{"-v", fmt.Sprintf("%s:.", tmpDir), "_", "ls", "."}, nil); err == nil {
+	if _, err := runContainer(eng, r, []string{"-v", fmt.Sprintf("%s:.", tmpDir), "_", "ls", "."}, nil); err == nil {
 		t.Fatal("Container bind mounted illegal directory")
 	}
 }
@@ -1532,33 +1536,37 @@ func TestOnlyLoopbackExistsWhenUsingDisableNetworkOption(t *testing.T) {
 }
 
 func TestPrivilegedCanMknod(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-	if output, _ := runContainer(runtime, []string{"-privileged", "_", "sh", "-c", "mknod /tmp/sda b 8 0 && echo ok"}, t); output != "ok\n" {
+	eng := NewTestEngine(t)
+	runtime := mkRuntimeFromEngine(eng, t)
+	defer runtime.Nuke()
+	if output, _ := runContainer(eng, runtime, []string{"-privileged", "_", "sh", "-c", "mknod /tmp/sda b 8 0 && echo ok"}, t); output != "ok\n" {
 		t.Fatal("Could not mknod into privileged container")
 	}
 }
 
 func TestPrivilegedCanMount(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-	if output, _ := runContainer(runtime, []string{"-privileged", "_", "sh", "-c", "mount -t tmpfs none /tmp && echo ok"}, t); output != "ok\n" {
+	eng := NewTestEngine(t)
+	runtime := mkRuntimeFromEngine(eng, t)
+	defer runtime.Nuke()
+	if output, _ := runContainer(eng, runtime, []string{"-privileged", "_", "sh", "-c", "mount -t tmpfs none /tmp && echo ok"}, t); output != "ok\n" {
 		t.Fatal("Could not mount into privileged container")
 	}
 }
 
 func TestPrivilegedCannotMknod(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-	if output, _ := runContainer(runtime, []string{"_", "sh", "-c", "mknod /tmp/sda b 8 0 || echo ok"}, t); output != "ok\n" {
+	eng := NewTestEngine(t)
+	runtime := mkRuntimeFromEngine(eng, t)
+	defer runtime.Nuke()
+	if output, _ := runContainer(eng, runtime, []string{"_", "sh", "-c", "mknod /tmp/sda b 8 0 || echo ok"}, t); output != "ok\n" {
 		t.Fatal("Could mknod into secure container")
 	}
 }
 
 func TestPrivilegedCannotMount(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-	if output, _ := runContainer(runtime, []string{"_", "sh", "-c", "mount -t tmpfs none /tmp || echo ok"}, t); output != "ok\n" {
+	eng := NewTestEngine(t)
+	runtime := mkRuntimeFromEngine(eng, t)
+	defer runtime.Nuke()
+	if output, _ := runContainer(eng, runtime, []string{"_", "sh", "-c", "mount -t tmpfs none /tmp || echo ok"}, t); output != "ok\n" {
 		t.Fatal("Could mount into secure container")
 	}
 }
diff --git a/components/engine/integration/runtime_test.go b/components/engine/integration/runtime_test.go
index ffde732c90..fb928d8160 100644
--- a/components/engine/integration/runtime_test.go
+++ b/components/engine/integration/runtime_test.go
@@ -316,13 +316,13 @@ func TestGet(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	container1, _ := mkContainer(runtime, []string{"_", "ls", "-al"}, t)
+	container1, _, _ := mkContainer(runtime, []string{"_", "ls", "-al"}, t)
 	defer runtime.Destroy(container1)
 
-	container2, _ := mkContainer(runtime, []string{"_", "ls", "-al"}, t)
+	container2, _, _ := mkContainer(runtime, []string{"_", "ls", "-al"}, t)
 	defer runtime.Destroy(container2)
 
-	container3, _ := mkContainer(runtime, []string{"_", "ls", "-al"}, t)
+	container3, _, _ := mkContainer(runtime, []string{"_", "ls", "-al"}, t)
 	defer runtime.Destroy(container3)
 
 	if runtime.Get(container1.ID) != container1 {
@@ -509,11 +509,11 @@ func TestRestore(t *testing.T) {
 	runtime1 := mkRuntimeFromEngine(eng, t)
 	defer runtime1.Nuke()
 	// Create a container with one instance of docker
-	container1, _ := mkContainer(runtime1, []string{"_", "ls", "-al"}, t)
+	container1, _, _ := mkContainer(runtime1, []string{"_", "ls", "-al"}, t)
 	defer runtime1.Destroy(container1)
 
 	// Create a second container meant to be killed
-	container2, _ := mkContainer(runtime1, []string{"-i", "_", "/bin/cat"}, t)
+	container2, _, _ := mkContainer(runtime1, []string{"-i", "_", "/bin/cat"}, t)
 	defer runtime1.Destroy(container2)
 
 	// Start the container non blocking
@@ -547,9 +547,14 @@ func TestRestore(t *testing.T) {
 
 	// Here are are simulating a docker restart - that is, reloading all containers
 	// from scratch
+	root := eng.Root()
+	eng, err := engine.New(root)
+	if err != nil {
+		t.Fatal(err)
+	}
 	job := eng.Job("initapi")
 	job.Setenv("Root", eng.Root())
-	job.SetenvBool("AutoRestart", false)
+	job.SetenvBool("Autorestart", false)
 	if err := job.Run(); err != nil {
 		t.Fatal(err)
 	}
@@ -599,11 +604,11 @@ func TestReloadContainerLinks(t *testing.T) {
 	runtime1 := mkRuntimeFromEngine(eng, t)
 	defer nuke(runtime1)
 	// Create a container with one instance of docker
-	container1, _ := mkContainer(runtime1, []string{"-i", "_", "/bin/sh"}, t)
+	container1, _, _ := mkContainer(runtime1, []string{"-i", "_", "/bin/sh"}, t)
 	defer runtime1.Destroy(container1)
 
 	// Create a second container meant to be killed
-	container2, _ := mkContainer(runtime1, []string{"-i", "_", "/bin/cat"}, t)
+	container2, _, _ := mkContainer(runtime1, []string{"-i", "_", "/bin/cat"}, t)
 	defer runtime1.Destroy(container2)
 
 	// Start the container non blocking
@@ -635,12 +640,17 @@ func TestReloadContainerLinks(t *testing.T) {
 
 	// Here are are simulating a docker restart - that is, reloading all containers
 	// from scratch
+	eng, err = engine.New(root)
+	if err != nil {
+		t.Fatal(err)
+	}
 	job = eng.Job("initapi")
 	job.Setenv("Root", eng.Root())
-	job.SetenvBool("AutoRestart", false)
+	job.SetenvBool("Autorestart", false)
 	if err := job.Run(); err != nil {
 		t.Fatal(err)
 	}
+
 	runtime2 := mkRuntimeFromEngine(eng, t)
 	if len(runtime2.List()) != 2 {
 		t.Errorf("Expected 2 container, %v found", len(runtime2.List()))
diff --git a/components/engine/integration/utils_test.go b/components/engine/integration/utils_test.go
index b20194c0dc..3eb1e52d6a 100644
--- a/components/engine/integration/utils_test.go
+++ b/components/engine/integration/utils_test.go
@@ -143,22 +143,22 @@ func readFile(src string, t *testing.T) (content string) {
 // dynamically replaced by the current test image.
 // The caller is responsible for destroying the container.
 // Call t.Fatal() at the first error.
-func mkContainer(r *docker.Runtime, args []string, t *testing.T) (*docker.Container, error) {
-	config, _, _, err := docker.ParseRun(args, nil)
+func mkContainer(r *docker.Runtime, args []string, t *testing.T) (*docker.Container, *docker.HostConfig, error) {
+	config, hc, _, err := docker.ParseRun(args, nil)
 	defer func() {
 		if err != nil && t != nil {
 			t.Fatal(err)
 		}
 	}()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	if config.Image == "_" {
 		config.Image = GetTestImage(r).ID
 	}
 	c, _, err := r.Create(config, "")
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	// NOTE: hostConfig is ignored.
 	// If `args` specify privileged mode, custom lxc conf, external mount binds,
@@ -167,20 +167,20 @@ func mkContainer(r *docker.Runtime, args []string, t *testing.T) (*docker.Contai
 	// to the `start` job.
 	// FIXME: this helper function should be deprecated in favor of calling
 	// `create` and `start` jobs directly.
-	return c, nil
+	return c, hc, nil
 }
 
 // Create a test container, start it, wait for it to complete, destroy it,
 // and return its standard output as a string.
 // The image name (eg. the XXX in []string{"-i", "-t", "XXX", "bash"}, is dynamically replaced by the current test image.
 // If t is not nil, call t.Fatal() at the first error. Otherwise return errors normally.
-func runContainer(r *docker.Runtime, args []string, t *testing.T) (output string, err error) {
+func runContainer(eng *engine.Engine, r *docker.Runtime, args []string, t *testing.T) (output string, err error) {
 	defer func() {
 		if err != nil && t != nil {
 			t.Fatal(err)
 		}
 	}()
-	container, err := mkContainer(r, args, t)
+	container, hc, err := mkContainer(r, args, t)
 	if err != nil {
 		return "", err
 	}
@@ -190,9 +190,15 @@ func runContainer(r *docker.Runtime, args []string, t *testing.T) (output string
 		return "", err
 	}
 	defer stdout.Close()
-	if err := container.Start(); err != nil {
+
+	job := eng.Job("start", container.ID)
+	if err := job.ImportEnv(hc); err != nil {
 		return "", err
 	}
+	if err := job.Run(); err != nil {
+		return "", err
+	}
+
 	container.Wait()
 	data, err := ioutil.ReadAll(stdout)
 	if err != nil {

From 26146eb208af5ceebb64025a6bfa78009573c028 Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Thu, 14 Nov 2013 15:17:31 -0800
Subject: [PATCH 118/184] move TestMount to integration Upstream-commit:
 596810d8db17c246c9c5107e7ecc6eb781454f36 Component: engine

---
 components/engine/graph_test.go             | 36 -------------
 components/engine/integration/graph_test.go | 57 +++++++++++++++++++++
 2 files changed, 57 insertions(+), 36 deletions(-)
 create mode 100644 components/engine/integration/graph_test.go

diff --git a/components/engine/graph_test.go b/components/engine/graph_test.go
index 1102129aba..f08752a192 100644
--- a/components/engine/graph_test.go
+++ b/components/engine/graph_test.go
@@ -9,7 +9,6 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
-	"path"
 	"testing"
 	"time"
 )
@@ -121,41 +120,6 @@ func TestRegister(t *testing.T) {
 	}
 }
 
-func TestMount(t *testing.T) {
-	graph := tempGraph(t)
-	defer os.RemoveAll(graph.Root)
-	archive, err := fakeTar()
-	if err != nil {
-		t.Fatal(err)
-	}
-	image, err := graph.Create(archive, nil, "Testing", "", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	tmp, err := ioutil.TempDir("", "docker-test-graph-mount-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmp)
-	rootfs := path.Join(tmp, "rootfs")
-	if err := os.MkdirAll(rootfs, 0700); err != nil {
-		t.Fatal(err)
-	}
-	rw := path.Join(tmp, "rw")
-	if err := os.MkdirAll(rw, 0700); err != nil {
-		t.Fatal(err)
-	}
-	if err := image.Mount(rootfs, rw); err != nil {
-		t.Fatal(err)
-	}
-	// FIXME: test for mount contents
-	defer func() {
-		if err := Unmount(rootfs); err != nil {
-			t.Error(err)
-		}
-	}()
-}
-
 // Test that an image can be deleted by its shorthand prefix
 func TestDeletePrefix(t *testing.T) {
 	graph := tempGraph(t)
diff --git a/components/engine/integration/graph_test.go b/components/engine/integration/graph_test.go
new file mode 100644
index 0000000000..bfbedfa48f
--- /dev/null
+++ b/components/engine/integration/graph_test.go
@@ -0,0 +1,57 @@
+package docker
+
+import (
+	"github.com/dotcloud/docker"
+	"io/ioutil"
+	"os"
+	"path"
+	"testing"
+)
+
+func TestMount(t *testing.T) {
+	graph := tempGraph(t)
+	defer os.RemoveAll(graph.Root)
+	archive, err := fakeTar()
+	if err != nil {
+		t.Fatal(err)
+	}
+	image, err := graph.Create(archive, nil, "Testing", "", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tmp, err := ioutil.TempDir("", "docker-test-graph-mount-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmp)
+	rootfs := path.Join(tmp, "rootfs")
+	if err := os.MkdirAll(rootfs, 0700); err != nil {
+		t.Fatal(err)
+	}
+	rw := path.Join(tmp, "rw")
+	if err := os.MkdirAll(rw, 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := image.Mount(rootfs, rw); err != nil {
+		t.Fatal(err)
+	}
+	// FIXME: test for mount contents
+	defer func() {
+		if err := docker.Unmount(rootfs); err != nil {
+			t.Error(err)
+		}
+	}()
+}
+
+//FIXME: duplicate
+func tempGraph(t *testing.T) *docker.Graph {
+	tmp, err := ioutil.TempDir("", "docker-graph-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	graph, err := docker.NewGraph(tmp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return graph
+}

From d641b4b09e69fa694b5484919c63d21374a6a9ff Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Thu, 14 Nov 2013 23:53:43 +0000
Subject: [PATCH 119/184] Fix the brittle errorstring-to-httperror recognition
 code which in turn is required by autopull (the client issues a pull if
 container creation returns 404) Upstream-commit:
 693ff4d2ae5f0d723469340f67bb55f7aa3e824b Component: engine

---
 components/engine/api.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index c5a91de5b5..60c4d68327 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -61,7 +61,10 @@ func parseMultipartForm(r *http.Request) error {
 
 func httpError(w http.ResponseWriter, err error) {
 	statusCode := http.StatusInternalServerError
-	if strings.HasPrefix(err.Error(), "No such") {
+	// FIXME: this is brittle and should not be necessary.
+	// If we need to differentiate between different possible error types, we should
+	// create appropriate error types with clearly defined meaning.
+	if strings.Contains(err.Error(), "No such") {
 		statusCode = http.StatusNotFound
 	} else if strings.HasPrefix(err.Error(), "Bad parameter") {
 		statusCode = http.StatusBadRequest

From 2a4f3940f033e37f036c62bedd1c23f21e0f6c62 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Fri, 15 Nov 2013 01:13:20 +0000
Subject: [PATCH 120/184] Split auth tests between unit tests and integration
 tests Upstream-commit: 8d3e35cd8d92d184dc66041c235163cab4953842 Component:
 engine

---
 components/engine/auth/auth_test.go        | 49 -----------------
 components/engine/integration/auth_test.go | 63 ++++++++++++++++++++++
 2 files changed, 63 insertions(+), 49 deletions(-)
 create mode 100644 components/engine/integration/auth_test.go

diff --git a/components/engine/auth/auth_test.go b/components/engine/auth/auth_test.go
index 5dc634a719..5f2d3b85fd 100644
--- a/components/engine/auth/auth_test.go
+++ b/components/engine/auth/auth_test.go
@@ -1,11 +1,8 @@
 package auth
 
 import (
-	"crypto/rand"
-	"encoding/hex"
 	"io/ioutil"
 	"os"
-	"strings"
 	"testing"
 )
 
@@ -29,52 +26,6 @@ func TestEncodeAuth(t *testing.T) {
 	}
 }
 
-func TestLogin(t *testing.T) {
-	os.Setenv("DOCKER_INDEX_URL", "https://indexstaging-docker.dotcloud.com")
-	defer os.Setenv("DOCKER_INDEX_URL", "")
-	authConfig := &AuthConfig{Username: "unittester", Password: "surlautrerivejetattendrai", Email: "noise+unittester@dotcloud.com"}
-	status, err := Login(authConfig, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if status != "Login Succeeded" {
-		t.Fatalf("Expected status \"Login Succeeded\", found \"%s\" instead", status)
-	}
-}
-
-func TestCreateAccount(t *testing.T) {
-	os.Setenv("DOCKER_INDEX_URL", "https://indexstaging-docker.dotcloud.com")
-	defer os.Setenv("DOCKER_INDEX_URL", "")
-	tokenBuffer := make([]byte, 16)
-	_, err := rand.Read(tokenBuffer)
-	if err != nil {
-		t.Fatal(err)
-	}
-	token := hex.EncodeToString(tokenBuffer)[:12]
-	username := "ut" + token
-	authConfig := &AuthConfig{Username: username, Password: "test42", Email: "docker-ut+" + token + "@example.com"}
-	status, err := Login(authConfig, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	expectedStatus := "Account created. Please use the confirmation link we sent" +
-		" to your e-mail to activate it."
-	if status != expectedStatus {
-		t.Fatalf("Expected status: \"%s\", found \"%s\" instead.", expectedStatus, status)
-	}
-
-	status, err = Login(authConfig, nil)
-	if err == nil {
-		t.Fatalf("Expected error but found nil instead")
-	}
-
-	expectedError := "Login: Account is not Active"
-
-	if !strings.Contains(err.Error(), expectedError) {
-		t.Fatalf("Expected message \"%s\" but found \"%s\" instead", expectedError, err)
-	}
-}
-
 func setupTempConfigFile() (*ConfigFile, error) {
 	root, err := ioutil.TempDir("", "docker-test-auth")
 	if err != nil {
diff --git a/components/engine/integration/auth_test.go b/components/engine/integration/auth_test.go
new file mode 100644
index 0000000000..dfeb9002bf
--- /dev/null
+++ b/components/engine/integration/auth_test.go
@@ -0,0 +1,63 @@
+package docker
+
+import (
+	"github.com/dotcloud/docker/auth"
+	"crypto/rand"
+	"encoding/hex"
+	"os"
+	"strings"
+	"testing"
+)
+
+// FIXME: these tests have an external dependency on a staging index hosted
+// on the docker.io infrastructure. That dependency should be removed.
+// - Unit tests should have no side-effect dependencies.
+// - Integration tests should have side-effects limited to the host environment being tested.
+
+func TestLogin(t *testing.T) {
+	os.Setenv("DOCKER_INDEX_URL", "https://indexstaging-docker.dotcloud.com")
+	defer os.Setenv("DOCKER_INDEX_URL", "")
+	authConfig := &auth.AuthConfig{Username: "unittester", Password: "surlautrerivejetattendrai", Email: "noise+unittester@dotcloud.com"}
+	status, err := auth.Login(authConfig, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if status != "Login Succeeded" {
+		t.Fatalf("Expected status \"Login Succeeded\", found \"%s\" instead", status)
+	}
+}
+
+
+
+func TestCreateAccount(t *testing.T) {
+	os.Setenv("DOCKER_INDEX_URL", "https://indexstaging-docker.dotcloud.com")
+	defer os.Setenv("DOCKER_INDEX_URL", "")
+	tokenBuffer := make([]byte, 16)
+	_, err := rand.Read(tokenBuffer)
+	if err != nil {
+		t.Fatal(err)
+	}
+	token := hex.EncodeToString(tokenBuffer)[:12]
+	username := "ut" + token
+	authConfig := &auth.AuthConfig{Username: username, Password: "test42", Email: "docker-ut+" + token + "@example.com"}
+	status, err := auth.Login(authConfig, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expectedStatus := "Account created. Please use the confirmation link we sent" +
+		" to your e-mail to activate it."
+	if status != expectedStatus {
+		t.Fatalf("Expected status: \"%s\", found \"%s\" instead.", expectedStatus, status)
+	}
+
+	status, err = auth.Login(authConfig, nil)
+	if err == nil {
+		t.Fatalf("Expected error but found nil instead")
+	}
+
+	expectedError := "Login: Account is not Active"
+
+	if !strings.Contains(err.Error(), expectedError) {
+		t.Fatalf("Expected message \"%s\" but found \"%s\" instead", expectedError, err)
+	}
+}

From 3372c0c790c1b19f4c7acf4d2def54206bef01fd Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Fri, 15 Nov 2013 01:15:39 +0000
Subject: [PATCH 121/184] Move iptables test to integration tests
 Upstream-commit: 823674816e59e1e8c3f768a97585c69e1d86ead8 Component: engine

---
 .../engine/integration/iptables_test.go       | 22 +++++++++++++++++++
 components/engine/iptables/iptables_test.go   | 18 ---------------
 2 files changed, 22 insertions(+), 18 deletions(-)
 create mode 100644 components/engine/integration/iptables_test.go
 delete mode 100644 components/engine/iptables/iptables_test.go

diff --git a/components/engine/integration/iptables_test.go b/components/engine/integration/iptables_test.go
new file mode 100644
index 0000000000..060d0fe074
--- /dev/null
+++ b/components/engine/integration/iptables_test.go
@@ -0,0 +1,22 @@
+package docker
+
+import (
+	"github.com/dotcloud/docker/iptables"
+	"os"
+	"testing"
+)
+
+// FIXME: this test should be a unit test.
+// For example by mocking os/exec to make sure iptables is not actually called.
+
+func TestIptables(t *testing.T) {
+	if _, err := iptables.Raw("-L"); err != nil {
+		t.Fatal(err)
+	}
+	path := os.Getenv("PATH")
+	os.Setenv("PATH", "")
+	defer os.Setenv("PATH", path)
+	if _, err := iptables.Raw("-L"); err == nil {
+		t.Fatal("Not finding iptables in the PATH should cause an error")
+	}
+}
diff --git a/components/engine/iptables/iptables_test.go b/components/engine/iptables/iptables_test.go
deleted file mode 100644
index 886a63c03f..0000000000
--- a/components/engine/iptables/iptables_test.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package iptables
-
-import (
-	"os"
-	"testing"
-)
-
-func TestIptables(t *testing.T) {
-	if _, err := Raw("-L"); err != nil {
-		t.Fatal(err)
-	}
-	path := os.Getenv("PATH")
-	os.Setenv("PATH", "")
-	defer os.Setenv("PATH", path)
-	if _, err := Raw("-L"); err == nil {
-		t.Fatal("Not finding iptables in the PATH should cause an error")
-	}
-}

From bc283849de55d28799eaffb8b46906e9e29d56ab Mon Sep 17 00:00:00 2001
From: eugenkrizo <eugen.krizo@gmail.com>
Date: Fri, 15 Nov 2013 16:16:59 +0100
Subject: [PATCH 122/184] path needs to be specified to 'docker build' command

current folder '.' appended as a path
Upstream-commit: 007964793dd619279bfb48c3fa84ada65aa599bd
Component: engine
---
 .../engine/docs/sources/examples/running_redis_service.rst      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/docs/sources/examples/running_redis_service.rst b/components/engine/docs/sources/examples/running_redis_service.rst
index edcf73e657..744eca7ca5 100644
--- a/components/engine/docs/sources/examples/running_redis_service.rst
+++ b/components/engine/docs/sources/examples/running_redis_service.rst
@@ -29,7 +29,7 @@ with your own user name.
 
 .. code-block:: bash
 
-    sudo docker build -t <your username>/redis
+    sudo docker build -t <your username>/redis .
 
 Run the service
 ---------------

From 3c67b070939e241c9628b9ded9db53929df56948 Mon Sep 17 00:00:00 2001
From: eugenkrizo <eugen.krizo@gmail.com>
Date: Fri, 15 Nov 2013 17:12:48 +0100
Subject: [PATCH 123/184] port published explicitly (for docker 0.6.6)

port 5984 to couchdb needs to be published explicitly in docker version 0.6.6
Upstream-commit: 492ce4c665b7d55d1496fb7e822a49ff0d44809d
Component: engine
---
 .../engine/docs/sources/examples/couchdb_data_volumes.rst | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/components/engine/docs/sources/examples/couchdb_data_volumes.rst b/components/engine/docs/sources/examples/couchdb_data_volumes.rst
index 60674fe9a0..1f6b4b7910 100644
--- a/components/engine/docs/sources/examples/couchdb_data_volumes.rst
+++ b/components/engine/docs/sources/examples/couchdb_data_volumes.rst
@@ -20,7 +20,7 @@ Note that we're marking ``/var/lib/couchdb`` as a data volume.
 
 .. code-block:: bash
 
-    COUCH1=$(sudo docker run -d -v /var/lib/couchdb shykes/couchdb:2013-05-03)
+    COUCH1=$(sudo docker run -d -p 5984 -v /var/lib/couchdb shykes/couchdb:2013-05-03)
 
 Add data to the first database
 ------------------------------
@@ -31,7 +31,7 @@ replace ``localhost`` with the public IP of your Docker host.
 .. code-block:: bash
 
     HOST=localhost
-    URL="http://$HOST:$(sudo docker port $COUCH1 5984)/_utils/"
+    URL="http://$HOST:$(sudo docker port $COUCH1 5984 | grep -Po '\d+$')/_utils/"
     echo "Navigate to $URL in your browser, and use the couch interface to add data"
 
 Create second database
@@ -41,7 +41,7 @@ This time, we're requesting shared access to ``$COUCH1``'s volumes.
 
 .. code-block:: bash
 
-    COUCH2=$(sudo docker run -d -volumes-from $COUCH1 shykes/couchdb:2013-05-03)
+    COUCH2=$(sudo docker run -d -p 5984 -volumes-from $COUCH1 shykes/couchdb:2013-05-03)
 
 Browse data on the second database
 ----------------------------------
@@ -49,7 +49,7 @@ Browse data on the second database
 .. code-block:: bash
 
     HOST=localhost
-    URL="http://$HOST:$(sudo docker port $COUCH2 5984)/_utils/"
+    URL="http://$HOST:$(sudo docker port $COUCH2 5984 | grep -Po '\d+$')/_utils/"
     echo "Navigate to $URL in your browser. You should see the same data as in the first database"'!'
 
 Congratulations, you are now running two Couchdb containers, completely

From da637b552f42a258275e54489483d7826a3fc4b3 Mon Sep 17 00:00:00 2001
From: Andy Rothfusz <github@metaliveblog.com>
Date: Fri, 15 Nov 2013 11:38:03 -0800
Subject: [PATCH 124/184] Fix typos, add links, streamline content of #2592
 Upstream-commit: 9a9d3239e10b55cc15bb38788a411d9a16c477fc Component: engine

---
 .../docs/sources/examples/example_header.inc  |  9 ++---
 .../docs/sources/examples/hello_world.rst     |  3 +-
 components/engine/docs/sources/use/basics.rst | 33 +++++++++----------
 3 files changed, 20 insertions(+), 25 deletions(-)

diff --git a/components/engine/docs/sources/examples/example_header.inc b/components/engine/docs/sources/examples/example_header.inc
index 7d0feddeb9..0621b39794 100644
--- a/components/engine/docs/sources/examples/example_header.inc
+++ b/components/engine/docs/sources/examples/example_header.inc
@@ -1,10 +1,7 @@
 
 .. note::
     
-    This example assumes you have Docker running in daemon mode. For more information please see :ref:`running_examples`
+    * This example assumes you have Docker running in daemon mode. For
+      more information please see :ref:`running_examples`.
+    * **If you don't like sudo** then see :ref:`dockergroup`
 
-.. note::
-
-   These examples use ``sudo`` before each ``docker`` command you could also
-   add your current ``<username>`` to docker's group and get rid of ``sudo``.
-   You just need to type: ``$ sudo usermod -a -G docker <username>``
diff --git a/components/engine/docs/sources/examples/hello_world.rst b/components/engine/docs/sources/examples/hello_world.rst
index d6f75de09c..99eaa2c483 100644
--- a/components/engine/docs/sources/examples/hello_world.rst
+++ b/components/engine/docs/sources/examples/hello_world.rst
@@ -131,7 +131,8 @@ Attach to the container to see the results in real-time.
 
 - **"docker attach**" This will allow us to attach to a background
   process to see what is going on.
-- **"-sig-proxy=true" Proxify all received signal to the process (even in non-tty mode)
+- **"-sig-proxy=true"** Proxify all received signal to the process
+  (even in non-tty mode)
 - **$CONTAINER_ID** The Id of the container we want to attach too.
 
 Exit from the container attachment by pressing Control-C.
diff --git a/components/engine/docs/sources/use/basics.rst b/components/engine/docs/sources/use/basics.rst
index 30444c4f81..0b3fafced1 100644
--- a/components/engine/docs/sources/use/basics.rst
+++ b/components/engine/docs/sources/use/basics.rst
@@ -53,39 +53,36 @@ Running an interactive shell
 
 .. _dockergroup:
 
-Why ``sudo``?
--------------
+sudo and the docker Group
+-------------------------
 
 The ``docker`` daemon always runs as root, and since ``docker``
 version 0.5.2, ``docker`` binds to a Unix socket instead of a TCP
 port. By default that Unix socket is owned by the user *root*, and so,
 by default, you can access it with ``sudo``.
 
-Starting in version 0.5.3, if you create a Unix group called *docker*
-and add users to it, then the ``docker`` daemon will make the
-ownership of the Unix socket read/writable by the *docker* group when
-the daemon starts. The ``docker`` daemon must always run as root, but
-if you run the ``docker`` client as a user in the *docker* group then
-you don't need to add ``sudo`` to all the client commands.
+Starting in version 0.5.3, if you (or your Docker installer) create a
+Unix group called *docker* and add users to it, then the ``docker``
+daemon will make the ownership of the Unix socket read/writable by the
+*docker* group when the daemon starts. The ``docker`` daemon must
+always run as root, but if you run the ``docker`` client as a user in
+the *docker* group then you don't need to add ``sudo`` to all the
+client commands.
 
-Alternative to ``sudo``?
--------------
-
-You can add your current ``<username>`` to docker's group and get rid of
-``sudo`` before each ``docker`` command. You just need to type:
-``$ sudo usermod -a -G docker <username>``
+**Example:**
 
 .. code-block:: bash
 
-  # Add the docker group
+  # Add the docker group if it doesn't already exist.
   sudo groupadd docker
 
-  # Add the ubuntu user to the docker group
+  # Add the user "ubuntu" to the docker group.
+  # Change the user name to match your preferred user.
   # You may have to logout and log back in again for
-  # this to take effect
+  # this to take effect.
   sudo gpasswd -a ubuntu docker
 
-  # Restart the docker daemon
+  # Restart the docker daemon.
   sudo service docker restart
 
 .. _bind_docker:

From d46ca98228629bfccf0ef7ac3273f22509e58ba9 Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Fri, 15 Nov 2013 11:09:29 -0800
Subject: [PATCH 125/184] bring back tests about LXCConfig Upstream-commit:
 c06d903edd7b16588e68680a989b73e27d990871 Component: engine

---
 components/engine/container_unit_test.go    |  89 -----------------
 components/engine/lxc_template_unit_test.go | 102 ++++++++++++++++++++
 2 files changed, 102 insertions(+), 89 deletions(-)
 create mode 100644 components/engine/lxc_template_unit_test.go

diff --git a/components/engine/container_unit_test.go b/components/engine/container_unit_test.go
index 679f25eee7..679ff57e73 100644
--- a/components/engine/container_unit_test.go
+++ b/components/engine/container_unit_test.go
@@ -147,95 +147,6 @@ func TestParseNetworkOptsUdp(t *testing.T) {
 	}
 }
 
-// FIXME: test that destroying a container actually removes its root directory
-
-/*
-func TestLXCConfig(t *testing.T) {
-	// Memory is allocated randomly for testing
-	rand.Seed(time.Now().UTC().UnixNano())
-	memMin := 33554432
-	memMax := 536870912
-	mem := memMin + rand.Intn(memMax-memMin)
-	// CPU shares as well
-	cpuMin := 100
-	cpuMax := 10000
-	cpu := cpuMin + rand.Intn(cpuMax-cpuMin)
-	container, _, err := runtime.Create(&Config{
-		Image: GetTestImage(runtime).ID,
-		Cmd:   []string{"/bin/true"},
-
-		Hostname:  "foobar",
-		Memory:    int64(mem),
-		CpuShares: int64(cpu),
-	},
-		"",
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-	container.generateLXCConfig()
-	grepFile(t, container.lxcConfigPath(), "lxc.utsname = foobar")
-	grepFile(t, container.lxcConfigPath(),
-		fmt.Sprintf("lxc.cgroup.memory.limit_in_bytes = %d", mem))
-	grepFile(t, container.lxcConfigPath(),
-		fmt.Sprintf("lxc.cgroup.memory.memsw.limit_in_bytes = %d", mem*2))
-}
-
-
-func TestCustomLxcConfig(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-	container, _, err := runtime.Create(&Config{
-		Image: GetTestImage(runtime).ID,
-		Cmd:   []string{"/bin/true"},
-
-		Hostname: "foobar",
-	},
-		"",
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-	container.hostConfig = &HostConfig{LxcConf: []KeyValuePair{
-		{
-			Key:   "lxc.utsname",
-			Value: "docker",
-		},
-		{
-			Key:   "lxc.cgroup.cpuset.cpus",
-			Value: "0,1",
-		},
-	}}
-
-	container.generateLXCConfig()
-	grepFile(t, container.lxcConfigPath(), "lxc.utsname = docker")
-	grepFile(t, container.lxcConfigPath(), "lxc.cgroup.cpuset.cpus = 0,1")
-}
-
-
-func grepFile(t *testing.T, path string, pattern string) {
-	f, err := os.Open(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-	r := bufio.NewReader(f)
-	var (
-		line string
-	)
-	err = nil
-	for err == nil {
-		line, err = r.ReadString('\n')
-		if strings.Contains(line, pattern) == true {
-			return
-		}
-	}
-	t.Fatalf("grepFile: pattern \"%s\" not found in \"%s\"", pattern, path)
-}
-*/
-
 func TestGetFullName(t *testing.T) {
 	name, err := getFullName("testing")
 	if err != nil {
diff --git a/components/engine/lxc_template_unit_test.go b/components/engine/lxc_template_unit_test.go
new file mode 100644
index 0000000000..ce5af1d321
--- /dev/null
+++ b/components/engine/lxc_template_unit_test.go
@@ -0,0 +1,102 @@
+package docker
+
+import (
+	"bufio"
+	"fmt"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestLXCConfig(t *testing.T) {
+	root, err := ioutil.TempDir("", "TestLXCConfig")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(root)
+	// Memory is allocated randomly for testing
+	rand.Seed(time.Now().UTC().UnixNano())
+	memMin := 33554432
+	memMax := 536870912
+	mem := memMin + rand.Intn(memMax-memMin)
+	// CPU shares as well
+	cpuMin := 100
+	cpuMax := 10000
+	cpu := cpuMin + rand.Intn(cpuMax-cpuMin)
+	container := &Container{
+		root: root,
+		Config: &Config{
+			Hostname:        "foobar",
+			Memory:          int64(mem),
+			CpuShares:       int64(cpu),
+			NetworkDisabled: true,
+		},
+		hostConfig: &HostConfig{
+			Privileged: false,
+		},
+	}
+	if err := container.generateLXCConfig(); err != nil {
+		t.Fatal(err)
+	}
+	grepFile(t, container.lxcConfigPath(), "lxc.utsname = foobar")
+	grepFile(t, container.lxcConfigPath(),
+		fmt.Sprintf("lxc.cgroup.memory.limit_in_bytes = %d", mem))
+	grepFile(t, container.lxcConfigPath(),
+		fmt.Sprintf("lxc.cgroup.memory.memsw.limit_in_bytes = %d", mem*2))
+}
+
+func TestCustomLxcConfig(t *testing.T) {
+	root, err := ioutil.TempDir("", "TestCustomLxcConfig")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(root)
+	container := &Container{
+		root: root,
+		Config: &Config{
+			Hostname:        "foobar",
+			NetworkDisabled: true,
+		},
+		hostConfig: &HostConfig{
+			Privileged: false,
+			LxcConf: []KeyValuePair{
+				{
+					Key:   "lxc.utsname",
+					Value: "docker",
+				},
+				{
+					Key:   "lxc.cgroup.cpuset.cpus",
+					Value: "0,1",
+				},
+			},
+		},
+	}
+	if err := container.generateLXCConfig(); err != nil {
+		t.Fatal(err)
+	}
+	grepFile(t, container.lxcConfigPath(), "lxc.utsname = docker")
+	grepFile(t, container.lxcConfigPath(), "lxc.cgroup.cpuset.cpus = 0,1")
+}
+
+func grepFile(t *testing.T, path string, pattern string) {
+	f, err := os.Open(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	r := bufio.NewReader(f)
+	var (
+		line string
+	)
+	err = nil
+	for err == nil {
+		line, err = r.ReadString('\n')
+		if strings.Contains(line, pattern) == true {
+			return
+		}
+	}
+	t.Fatalf("grepFile: pattern \"%s\" not found in \"%s\"", pattern, path)
+}

From 10d4ab171f0e3c5730a314a5f41d690c3a8dbc7d Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Fri, 15 Nov 2013 16:23:55 -0800
Subject: [PATCH 126/184] Fix tmp dir never cleanup Upstream-commit:
 926169059374fb7a7a7035dde4e78f3418778a80 Component: engine

---
 components/engine/server.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/engine/server.go b/components/engine/server.go
index 28858d6f6b..562a091bdf 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -933,6 +933,7 @@ func (srv *Server) pushImage(r *registry.Registry, out io.Writer, remote, imgID,
 	if err != nil {
 		return "", fmt.Errorf("Failed to generate layer archive: %s", err)
 	}
+	defer os.RemoveAll(layerData.Name())
 
 	// Send the layer
 	if checksum, err := r.PushImageLayerRegistry(imgData.ID, utils.ProgressReader(layerData, int(layerData.Size), out, sf.FormatProgress("", "Pushing", "%8v/%v (%v)"), sf, false), ep, token, jsonRaw); err != nil {

From 25c99ca04e06cf0cd91dc8166b362a02e1332369 Mon Sep 17 00:00:00 2001
From: Solomon Hykes <solomon@dotcloud.com>
Date: Sat, 16 Nov 2013 00:05:57 +0000
Subject: [PATCH 127/184] Re-enable api integration tests using only public
 remote API. Upstream-commit: afe230718ead8cb1d1053a7132a034f0bd55b424
 Component: engine

---
 components/engine/api_unit_tests.go         |  20 +
 components/engine/integration/api_test.go   | 848 +++++++++-----------
 components/engine/integration/utils_test.go | 105 +++
 3 files changed, 488 insertions(+), 485 deletions(-)
 create mode 100644 components/engine/api_unit_tests.go

diff --git a/components/engine/api_unit_tests.go b/components/engine/api_unit_tests.go
new file mode 100644
index 0000000000..36996c6adf
--- /dev/null
+++ b/components/engine/api_unit_tests.go
@@ -0,0 +1,20 @@
+package docker
+
+import (
+	"testing"
+)
+
+func TestJsonContentType(t *testing.T) {
+	if !matchesContentType("application/json", "application/json") {
+		t.Fail()
+	}
+
+	if !matchesContentType("application/json; charset=utf-8", "application/json") {
+		t.Fail()
+	}
+
+	if matchesContentType("dockerapplication/json", "application/json") {
+		t.Fail()
+	}
+}
+
diff --git a/components/engine/integration/api_test.go b/components/engine/integration/api_test.go
index f5c9cc9bad..0f49bf897b 100644
--- a/components/engine/integration/api_test.go
+++ b/components/engine/integration/api_test.go
@@ -1,83 +1,73 @@
 package docker
 
 import (
-	_ "archive/tar"
-	_ "bufio"
-	_ "bytes"
+	"archive/tar"
+	"bufio"
+	"bytes"
 	"encoding/json"
+	"fmt"
 	"github.com/dotcloud/docker"
 	"github.com/dotcloud/docker/utils"
 	"io"
-	_ "net"
+	"net"
 	"net/http"
 	"net/http/httptest"
-	_ "os"
-	_ "path"
-	_ "strings"
+	"strings"
 	"testing"
 	"time"
 )
 
-/*
+
 func TestGetVersion(t *testing.T) {
-	runtime := mkRuntime()
-	defer nuke(runtime)
-
-	srv := &docker.Server{runtime: runtime}
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	var err error
 	r := httptest.NewRecorder()
 
-	// FIXME getting the version should require an actual running Server
-	if err := getVersion(srv, docker.APIVERSION, r, nil, nil); err != nil {
+	req, err := http.NewRequest("GET", "/version", nil)
+	if err != nil {
 		t.Fatal(err)
 	}
+	// FIXME getting the version should require an actual running Server
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 
-	v := &APIVersion{}
+	v := &docker.APIVersion{}
 	if err = json.Unmarshal(r.Body.Bytes(), v); err != nil {
 		t.Fatal(err)
 	}
-	if v.Version != VERSION {
-		t.Errorf("Expected version %s, %s found", VERSION, v.Version)
-	}
-}
-
-	var err error
-	r := httptest.NewRecorder()
-
-	// FIXME getting the version should require an actual running Server
-	if err := getVersion(&docker.Server{}, docker.APIVERSION, r, nil, nil); err != nil {
-		t.Fatal(err)
-	}
-
-	v := &APIVersion{}
-	if err = json.Unmarshal(r.Body.Bytes(), v); err != nil {
-		t.Fatal(err)
-	}
-	if v.Version != VERSION {
-		t.Errorf("Expected version %s, %s found", VERSION, v.Version)
+	if v.Version != docker.VERSION {
+		t.Errorf("Expected version %s, %s found", docker.VERSION, v.Version)
 	}
 }
 
 
 func TestGetInfo(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
-
-	initialImages, err := srv.runtime.graph.Map()
+	initialImages, err := srv.Images(false, "")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	r := httptest.NewRecorder()
-
-	if err := getInfo(srv, docker.APIVERSION, r, nil, nil); err != nil {
+	req, err := http.NewRequest("GET", "/info", nil)
+	if err != nil {
 		t.Fatal(err)
 	}
+	r := httptest.NewRecorder()
 
-	infos := &APIInfo{}
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+        assertHttpNotError(r, t)
+
+	infos := &docker.APIInfo{}
 	err = json.Unmarshal(r.Body.Bytes(), infos)
 	if err != nil {
 		t.Fatal(err)
@@ -86,7 +76,6 @@ func TestGetInfo(t *testing.T) {
 		t.Errorf("Expected images: %d, %d found", len(initialImages), infos.Images)
 	}
 }
-*/
 
 func TestGetEvents(t *testing.T) {
 	eng := NewTestEngine(t)
@@ -116,6 +105,7 @@ func TestGetEvents(t *testing.T) {
 		if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 			t.Fatal(err)
 		}
+		assertHttpNotError(r, t)
 	})
 
 	dec := json.NewDecoder(r.Body)
@@ -133,13 +123,10 @@ func TestGetEvents(t *testing.T) {
 
 }
 
-/*
-
 func TestGetImagesJSON(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &docker.Server{runtime: runtime}
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	// all=0
 
@@ -155,11 +142,12 @@ func TestGetImagesJSON(t *testing.T) {
 
 	r := httptest.NewRecorder()
 
-	if err := getImagesJSON(srv, docker.APIVERSION, r, req, nil); err != nil {
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 		t.Fatal(err)
 	}
+        assertHttpNotError(r, t)
 
-	images := []APIImages{}
+	images := []docker.APIImages{}
 	if err := json.Unmarshal(r.Body.Bytes(), &images); err != nil {
 		t.Fatal(err)
 	}
@@ -192,12 +180,13 @@ func TestGetImagesJSON(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	if err := getImagesJSON(srv, docker.APIVERSION, r2, req2, nil); err != nil {
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r2, req2); err != nil {
 		t.Fatal(err)
 	}
+        assertHttpNotError(r2, t)
 
-	images2 := []APIImages{}
+
+	images2 := []docker.APIImages{}
 	if err := json.Unmarshal(r2.Body.Bytes(), &images2); err != nil {
 		t.Fatal(err)
 	}
@@ -208,13 +197,13 @@ func TestGetImagesJSON(t *testing.T) {
 
 	found = false
 	for _, img := range images2 {
-		if img.ID == GetTestImage(runtime).ID {
+		if img.ID == unitTestImageID {
 			found = true
 			break
 		}
 	}
 	if !found {
-		t.Errorf("Retrieved image Id differs, expected %s, received %+v", GetTestImage(runtime).ID, images2)
+		t.Errorf("Retrieved image Id differs, expected %s, received %+v", unitTestImageID, images2)
 	}
 
 	r3 := httptest.NewRecorder()
@@ -225,11 +214,12 @@ func TestGetImagesJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if err := getImagesJSON(srv, docker.APIVERSION, r3, req3, nil); err != nil {
-		t.Fatal(err)
-	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r3, req3); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r3, t)
 
-	images3 := []APIImages{}
+	images3 := []docker.APIImages{}
 	if err := json.Unmarshal(r3.Body.Bytes(), &images3); err != nil {
 		t.Fatal(err)
 	}
@@ -246,34 +236,32 @@ func TestGetImagesJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = getImagesJSON(srv, docker.APIVERSION, r4, req4, nil)
-	if err == nil {
-		t.Fatalf("Error expected, received none")
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r4, req4); err != nil {
+		t.Fatal(err)
 	}
-
-	if !strings.HasPrefix(err.Error(), "Bad parameter") {
-		t.Fatalf("Error should starts with \"Bad parameter\"")
-	}
-	http.Error(r4, err.Error(), http.StatusBadRequest)
-
+	// Don't assert against HTTP error since we expect an error
 	if r4.Code != http.StatusBadRequest {
 		t.Fatalf("%d Bad Request expected, received %d\n", http.StatusBadRequest, r4.Code)
 	}
 }
 
 func TestGetImagesHistory(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &docker.Server{runtime: runtime}
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	r := httptest.NewRecorder()
 
-	if err := getImagesHistory(srv, docker.APIVERSION, r, nil, map[string]string{"name": unitTestImageName}); err != nil {
+	req, err := http.NewRequest("GET", fmt.Sprintf("/images/%s/history", unitTestImageName), nil)
+	if err != nil {
 		t.Fatal(err)
 	}
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+        assertHttpNotError(r, t)
 
-	history := []APIHistory{}
+	history := []docker.APIHistory{}
 	if err := json.Unmarshal(r.Body.Bytes(), &history); err != nil {
 		t.Fatal(err)
 	}
@@ -283,15 +271,20 @@ func TestGetImagesHistory(t *testing.T) {
 }
 
 func TestGetImagesByName(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
+	req, err := http.NewRequest("GET", "/images/"+unitTestImageName+"/json", nil)
+	if err != nil {
+	    t.Fatal(err)
+	}
 
 	r := httptest.NewRecorder()
-	if err := getImagesByName(srv, docker.APIVERSION, r, nil, map[string]string{"name": unitTestImageName}); err != nil {
-		t.Fatal(err)
-	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
 
 	img := &docker.Image{}
 	if err := json.Unmarshal(r.Body.Bytes(), img); err != nil {
@@ -303,21 +296,16 @@ func TestGetImagesByName(t *testing.T) {
 }
 
 func TestGetContainersJSON(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
+	beginLen := len(srv.Containers(true, false, -1, "", ""))
 
-	beginLen := runtime.containers.Len()
-
-	container, _, err := runtime.Create(&Config{
-		Image: GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng, &docker.Config{
+		Image: unitTestImageID,
 		Cmd:   []string{"echo", "test"},
-	}, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
+	}, t)
 
 	req, err := http.NewRequest("GET", "/containers/json?all=1", nil)
 	if err != nil {
@@ -325,48 +313,47 @@ func TestGetContainersJSON(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-	if err := getContainersJSON(srv, docker.APIVERSION, r, req, nil); err != nil {
-		t.Fatal(err)
-	}
-	containers := []APIContainers{}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
+	containers := []docker.APIContainers{}
 	if err := json.Unmarshal(r.Body.Bytes(), &containers); err != nil {
 		t.Fatal(err)
 	}
 	if len(containers) != beginLen+1 {
 		t.Fatalf("Expected %d container, %d found (started with: %d)", beginLen+1, len(containers), beginLen)
 	}
-	if containers[0].ID != container.ID {
-		t.Fatalf("Container ID mismatch. Expected: %s, received: %s\n", container.ID, containers[0].ID)
+	if containers[0].ID != containerID {
+		t.Fatalf("Container ID mismatch. Expected: %s, received: %s\n", containerID, containers[0].ID)
 	}
 }
 
 func TestGetContainersExport(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &docker.Server{runtime: runtime}
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
 	// Create a container and remove a file
-	container, _, err := runtime.Create(
-		&Config{
-			Image: GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image: unitTestImageID,
 			Cmd:   []string{"touch", "/test"},
 		},
-		"",
+		t,
 	)
+	containerRun(eng, containerID, t)
+
+	r := httptest.NewRecorder()
+
+	req, err := http.NewRequest("GET", "/containers/" + containerID + "/export", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer runtime.Destroy(container)
-
-	if err := container.Run(); err != nil {
-		t.Fatal(err)
-	}
-
-	r := httptest.NewRecorder()
-	if err = getContainersExport(srv, docker.APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
-		t.Fatal(err)
-	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
 
 	if r.Code != http.StatusOK {
 		t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code)
@@ -392,33 +379,30 @@ func TestGetContainersExport(t *testing.T) {
 }
 
 func TestGetContainersChanges(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &docker.Server{runtime: runtime}
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
 	// Create a container and remove a file
-	container, _, err := runtime.Create(
-		&Config{
-			Image: GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image: unitTestImageID,
 			Cmd:   []string{"/bin/rm", "/etc/passwd"},
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-
-	if err := container.Run(); err != nil {
-		t.Fatal(err)
-	}
+        containerRun(eng, containerID, t)
 
 	r := httptest.NewRecorder()
-	if err := getContainersChanges(srv, docker.APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
-		t.Fatal(err)
+	req, err := http.NewRequest("GET", "/containers/"+containerID+"/changes", nil)
+	if err != nil {
+	    t.Fatal(err)
 	}
-	changes := []Change{}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
+	changes := []docker.Change{}
 	if err := json.Unmarshal(r.Body.Bytes(), &changes); err != nil {
 		t.Fatal(err)
 	}
@@ -437,64 +421,57 @@ func TestGetContainersChanges(t *testing.T) {
 
 func TestGetContainersTop(t *testing.T) {
 	t.Skip("Fixme. Skipping test for now. Reported error when testing using dind: 'api_test.go:527: Expected 2 processes, found 0.'")
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
-
-	container, _, err := runtime.Create(
-		&Config{
-			Image:     GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/sh", "-c", "cat"},
 			OpenStdin: true,
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
 	defer func() {
 		// Make sure the process dies before destroying runtime
-		container.stdin.Close()
-		container.WaitTimeout(2 * time.Second)
+		containerKill(eng, containerID, t)
+		containerWait(eng, containerID, t)
 	}()
 
-	if err := container.Start(); err != nil {
-		t.Fatal(err)
-	}
+	startContainer(eng, containerID, t)
 
 	setTimeout(t, "Waiting for the container to be started timed out", 10*time.Second, func() {
 		for {
-			if container.State.Running {
+			if containerRunning(eng, containerID, t) {
 				break
 			}
 			time.Sleep(10 * time.Millisecond)
 		}
 	})
 
-	if !container.State.Running {
+	if !containerRunning(eng, containerID, t) {
 		t.Fatalf("Container should be running")
 	}
 
 	// Make sure sh spawn up cat
 	setTimeout(t, "read/write assertion timed out", 2*time.Second, func() {
-		in, _ := container.StdinPipe()
-		out, _ := container.StdoutPipe()
+		in, out := containerAttach(eng, containerID, t)
 		if err := assertPipe("hello\n", "hello", out, in, 15); err != nil {
 			t.Fatal(err)
 		}
 	})
 
 	r := httptest.NewRecorder()
-	req, err := http.NewRequest("GET", "/"+container.ID+"/top?ps_args=u", bytes.NewReader([]byte{}))
+	req, err := http.NewRequest("GET", "/"+containerID+"/top?ps_args=u", bytes.NewReader([]byte{}))
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := getContainersTop(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
-		t.Fatal(err)
-	}
-	procs := APITop{}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
+	procs := docker.APITop{}
 	if err := json.Unmarshal(r.Body.Bytes(), &procs); err != nil {
 		t.Fatal(err)
 	}
@@ -518,90 +495,83 @@ func TestGetContainersTop(t *testing.T) {
 }
 
 func TestGetContainersByName(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &docker.Server{runtime: runtime}
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
 	// Create a container and remove a file
-	container, _, err := runtime.Create(
-		&Config{
-			Image: GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image: unitTestImageID,
 			Cmd:   []string{"echo", "test"},
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
 
 	r := httptest.NewRecorder()
-	if err := getContainersByName(srv, docker.APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
-		t.Fatal(err)
+	req, err := http.NewRequest("GET", "/containers/"+containerID+"/json", nil)
+	if err != nil {
+	    t.Fatal(err)
 	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
 	outContainer := &docker.Container{}
 	if err := json.Unmarshal(r.Body.Bytes(), outContainer); err != nil {
 		t.Fatal(err)
 	}
-	if outContainer.ID != container.ID {
-		t.Fatalf("Wrong containers retrieved. Expected %s, received %s", container.ID, outContainer.ID)
+	if outContainer.ID != containerID {
+		t.Fatalf("Wrong containers retrieved. Expected %s, received %s", containerID, outContainer.ID)
 	}
 }
 
 func TestPostCommit(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &docker.Server{runtime: runtime}
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
 	// Create a container and remove a file
-	container, _, err := runtime.Create(
-		&Config{
-			Image: GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image: unitTestImageID,
 			Cmd:   []string{"touch", "/test"},
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
 
-	if err := container.Run(); err != nil {
-		t.Fatal(err)
-	}
+        containerRun(eng, containerID, t)
 
-	req, err := http.NewRequest("POST", "/commit?repo=testrepo&testtag=tag&container="+container.ID, bytes.NewReader([]byte{}))
+	req, err := http.NewRequest("POST", "/commit?repo=testrepo&testtag=tag&container="+containerID, bytes.NewReader([]byte{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	r := httptest.NewRecorder()
-	if err := postCommit(srv, docker.APIVERSION, r, req, nil); err != nil {
-		t.Fatal(err)
-	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
 	if r.Code != http.StatusCreated {
 		t.Fatalf("%d Created expected, received %d\n", http.StatusCreated, r.Code)
 	}
 
-	apiID := &APIID{}
+	apiID := &docker.APIID{}
 	if err := json.Unmarshal(r.Body.Bytes(), apiID); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := runtime.graph.Get(apiID.ID); err != nil {
-		t.Fatalf("The image has not been commited")
+	if _, err := srv.ImageInspect(apiID.ID); err != nil {
+		t.Fatalf("The image has not been committed")
 	}
 }
 
 func TestPostContainersCreate(t *testing.T) {
 	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
 	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
-	defer nuke(runtime)
 
-	configJSON, err := json.Marshal(&Config{
-		Image:  GetTestImage(runtime).ID,
+	configJSON, err := json.Marshal(&docker.Config{
+		Image:  unitTestImageID,
 		Memory: 33554432,
 		Cmd:    []string{"touch", "/test"},
 	})
@@ -615,150 +585,132 @@ func TestPostContainersCreate(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-	if err := postContainersCreate(srv, docker.APIVERSION, r, req, nil); err != nil {
-		t.Fatal(err)
-	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
 	if r.Code != http.StatusCreated {
 		t.Fatalf("%d Created expected, received %d\n", http.StatusCreated, r.Code)
 	}
 
-	apiRun := &APIRun{}
+	apiRun := &docker.APIRun{}
 	if err := json.Unmarshal(r.Body.Bytes(), apiRun); err != nil {
 		t.Fatal(err)
 	}
+	containerID := apiRun.ID
 
-	container := srv.runtime.Get(apiRun.ID)
-	if container == nil {
-		t.Fatalf("Container not created")
-	}
+	containerAssertExists(eng, containerID, t)
+        containerRun(eng, containerID, t)
 
-	if err := container.Run(); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := os.Stat(path.Join(container.rwPath(), "test")); err != nil {
-		if os.IsNotExist(err) {
-			utils.Debugf("Err: %s", err)
-			t.Fatalf("The test file has not been created")
-		}
-		t.Fatal(err)
+	if !containerFileExists(eng, containerID, "test", t) {
+		t.Fatal("Test file was not created")
 	}
 }
 
 func TestPostContainersKill(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
-
-	container, _, err := runtime.Create(
-		&Config{
-			Image:     GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/cat"},
 			OpenStdin: true,
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
 
-	if err := container.Start(); err != nil {
-		t.Fatal(err)
-	}
+        startContainer(eng, containerID, t)
 
 	// Give some time to the process to start
-	container.WaitTimeout(500 * time.Millisecond)
+	containerWaitTimeout(eng, containerID, t)
 
-	if !container.State.Running {
+	if !containerRunning(eng, containerID, t) {
 		t.Errorf("Container should be running")
 	}
 
 	r := httptest.NewRecorder()
-	if err := postContainersKill(srv, docker.APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
-		t.Fatal(err)
+	req, err := http.NewRequest("POST", "/containers/"+containerID+"/kill", bytes.NewReader([]byte{}))
+	if err != nil {
+	    t.Fatal(err)
 	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
-	if container.State.Running {
+	if containerRunning(eng, containerID, t) {
 		t.Fatalf("The container hasn't been killed")
 	}
 }
 
 func TestPostContainersRestart(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
-
-	container, _, err := runtime.Create(
-		&Config{
-			Image:     GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/top"},
 			OpenStdin: true,
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
 
-	if err := container.Start(); err != nil {
-		t.Fatal(err)
-	}
+        startContainer(eng, containerID, t)
 
 	// Give some time to the process to start
-	container.WaitTimeout(500 * time.Millisecond)
+	containerWaitTimeout(eng, containerID, t)
 
-	if !container.State.Running {
+	if !containerRunning(eng, containerID, t) {
 		t.Errorf("Container should be running")
 	}
 
-	req, err := http.NewRequest("POST", "/containers/"+container.ID+"/restart?t=1", bytes.NewReader([]byte{}))
+	req, err := http.NewRequest("POST", "/containers/"+containerID+"/restart?t=1", bytes.NewReader([]byte{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	r := httptest.NewRecorder()
-	if err := postContainersRestart(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
-		t.Fatal(err)
-	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
 
 	// Give some time to the process to restart
-	container.WaitTimeout(500 * time.Millisecond)
+	containerWaitTimeout(eng, containerID, t)
 
-	if !container.State.Running {
+	if !containerRunning(eng, containerID, t) {
 		t.Fatalf("Container should be running")
 	}
 
-	if err := container.Kill(); err != nil {
-		t.Fatal(err)
-	}
+        containerKill(eng, containerID, t)
 }
 
 func TestPostContainersStart(t *testing.T) {
 	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
 	srv := mkServerFromEngine(eng, t)
-	runtime := srv.runtime
-	defer nuke(runtime)
 
-	id := createTestContainer(
+	containerID := createTestContainer(
 		eng,
-		&Config{
-			Image:     GetTestImage(runtime).ID,
+		&docker.Config{
+			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/cat"},
 			OpenStdin: true,
 		},
-		t)
+		t,
+	)
 
-	hostConfigJSON, err := json.Marshal(&HostConfig{})
+	hostConfigJSON, err := json.Marshal(&docker.HostConfig{})
 
-	req, err := http.NewRequest("POST", "/containers/"+id+"/start", bytes.NewReader(hostConfigJSON))
+	req, err := http.NewRequest("POST", "/containers/"+containerID+"/start", bytes.NewReader(hostConfigJSON))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -766,110 +718,101 @@ func TestPostContainersStart(t *testing.T) {
 	req.Header.Set("Content-Type", "application/json")
 
 	r := httptest.NewRecorder()
-	if err := postContainersStart(srv, docker.APIVERSION, r, req, map[string]string{"name": id}); err != nil {
-		t.Fatal(err)
-	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
 
-	container := runtime.Get(id)
-	if container == nil {
-		t.Fatalf("Container %s was not created", id)
-	}
+	containerAssertExists(eng, containerID, t)
 	// Give some time to the process to start
 	// FIXME: use Wait once it's available as a job
-	container.WaitTimeout(500 * time.Millisecond)
-	if !container.State.Running {
+	containerWaitTimeout(eng, containerID, t)
+	if !containerRunning(eng, containerID, t) {
 		t.Errorf("Container should be running")
 	}
 
 	r = httptest.NewRecorder()
-	if err = postContainersStart(srv, docker.APIVERSION, r, req, map[string]string{"name": id}); err == nil {
-		t.Fatalf("A running container should be able to be started")
-	}
-
-	if err := container.Kill(); err != nil {
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 		t.Fatal(err)
 	}
+	// Starting an already started container should return an error
+	// FIXME: verify a precise error code. There is a possible bug here
+	// which causes this to return 404 even though the container exists.
+	assertHttpError(r, t)
+	containerAssertExists(eng, containerID, t)
+        containerKill(eng, containerID, t)
 }
 
 func TestPostContainersStop(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
-
-	container, _, err := runtime.Create(
-		&Config{
-			Image:     GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/top"},
 			OpenStdin: true,
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
 
-	if err := container.Start(); err != nil {
-		t.Fatal(err)
-	}
+        startContainer(eng, containerID, t)
 
 	// Give some time to the process to start
-	container.WaitTimeout(500 * time.Millisecond)
+	containerWaitTimeout(eng, containerID, t)
 
-	if !container.State.Running {
+	if !containerRunning(eng, containerID, t) {
 		t.Errorf("Container should be running")
 	}
 
 	// Note: as it is a POST request, it requires a body.
-	req, err := http.NewRequest("POST", "/containers/"+container.ID+"/stop?t=1", bytes.NewReader([]byte{}))
+	req, err := http.NewRequest("POST", "/containers/"+containerID+"/stop?t=1", bytes.NewReader([]byte{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	r := httptest.NewRecorder()
-	if err := postContainersStop(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
-		t.Fatal(err)
-	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
-	if container.State.Running {
+	if containerRunning(eng, containerID, t) {
 		t.Fatalf("The container hasn't been stopped")
 	}
 }
 
 func TestPostContainersWait(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
-
-	container, _, err := runtime.Create(
-		&Config{
-			Image:     GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/sleep", "1"},
 			OpenStdin: true,
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-
-	if err := container.Start(); err != nil {
-		t.Fatal(err)
-	}
+        startContainer(eng, containerID, t)
 
 	setTimeout(t, "Wait timed out", 3*time.Second, func() {
 		r := httptest.NewRecorder()
-		if err := postContainersWait(srv, docker.APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil {
-			t.Fatal(err)
+		req, err := http.NewRequest("POST", "/containers/"+containerID+"/wait", bytes.NewReader([]byte{}))
+		if err != nil {
+		    t.Fatal(err)
 		}
-		apiWait := &APIWait{}
+		if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		    t.Fatal(err)
+		}
+        assertHttpNotError(r, t)
+		apiWait := &docker.APIWait{}
 		if err := json.Unmarshal(r.Body.Bytes(), apiWait); err != nil {
 			t.Fatal(err)
 		}
@@ -878,34 +821,26 @@ func TestPostContainersWait(t *testing.T) {
 		}
 	})
 
-	if container.State.Running {
+	if containerRunning(eng, containerID, t) {
 		t.Fatalf("The container should be stopped after wait")
 	}
 }
 
 func TestPostContainersAttach(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
-
-	container, _, err := runtime.Create(
-		&Config{
-			Image:     GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/cat"},
 			OpenStdin: true,
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-
 	// Start the process
-	if err := container.Start(); err != nil {
-		t.Fatal(err)
-	}
+        startContainer(eng, containerID, t)
 
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
@@ -913,7 +848,7 @@ func TestPostContainersAttach(t *testing.T) {
 	// Try to avoid the timeout in destroy. Best effort, don't check error
 	defer func() {
 		closeWrap(stdin, stdinPipe, stdout, stdoutPipe)
-		container.Kill()
+		containerKill(eng, containerID, t)
 	}()
 
 	// Attach to it
@@ -927,14 +862,15 @@ func TestPostContainersAttach(t *testing.T) {
 			out:              stdoutPipe,
 		}
 
-		req, err := http.NewRequest("POST", "/containers/"+container.ID+"/attach?stream=1&stdin=1&stdout=1&stderr=1", bytes.NewReader([]byte{}))
+		req, err := http.NewRequest("POST", "/containers/"+containerID+"/attach?stream=1&stdin=1&stdout=1&stderr=1", bytes.NewReader([]byte{}))
 		if err != nil {
 			t.Fatal(err)
 		}
 
-		if err := postContainersAttach(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
-			t.Fatal(err)
+		if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		    t.Fatal(err)
 		}
+        assertHttpNotError(r.ResponseRecorder, t)
 	}()
 
 	// Acknowledge hijack
@@ -961,40 +897,29 @@ func TestPostContainersAttach(t *testing.T) {
 
 	// We closed stdin, expect /bin/cat to still be running
 	// Wait a little bit to make sure container.monitor() did his thing
-	err = container.WaitTimeout(500 * time.Millisecond)
-	if err == nil || !container.State.Running {
-		t.Fatalf("/bin/cat is not running after closing stdin")
-	}
+	containerWaitTimeout(eng, containerID, t)
 
 	// Try to avoid the timeout in destroy. Best effort, don't check error
-	cStdin, _ := container.StdinPipe()
+	cStdin, _ := containerAttach(eng, containerID, t)
 	cStdin.Close()
-	container.Wait()
+	containerWait(eng, containerID, t)
 }
 
 func TestPostContainersAttachStderr(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
-
-	container, _, err := runtime.Create(
-		&Config{
-			Image:     GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/sh", "-c", "/bin/cat >&2"},
 			OpenStdin: true,
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-
 	// Start the process
-	if err := container.Start(); err != nil {
-		t.Fatal(err)
-	}
+        startContainer(eng, containerID, t)
 
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
@@ -1002,7 +927,7 @@ func TestPostContainersAttachStderr(t *testing.T) {
 	// Try to avoid the timeout in destroy. Best effort, don't check error
 	defer func() {
 		closeWrap(stdin, stdinPipe, stdout, stdoutPipe)
-		container.Kill()
+		containerKill(eng, containerID, t)
 	}()
 
 	// Attach to it
@@ -1016,14 +941,15 @@ func TestPostContainersAttachStderr(t *testing.T) {
 			out:              stdoutPipe,
 		}
 
-		req, err := http.NewRequest("POST", "/containers/"+container.ID+"/attach?stream=1&stdin=1&stdout=1&stderr=1", bytes.NewReader([]byte{}))
+		req, err := http.NewRequest("POST", "/containers/"+containerID+"/attach?stream=1&stdin=1&stdout=1&stderr=1", bytes.NewReader([]byte{}))
 		if err != nil {
 			t.Fatal(err)
 		}
 
-		if err := postContainersAttach(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+		if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 			t.Fatal(err)
 		}
+        assertHttpNotError(r.ResponseRecorder, t)
 	}()
 
 	// Acknowledge hijack
@@ -1050,104 +976,76 @@ func TestPostContainersAttachStderr(t *testing.T) {
 
 	// We closed stdin, expect /bin/cat to still be running
 	// Wait a little bit to make sure container.monitor() did his thing
-	err = container.WaitTimeout(500 * time.Millisecond)
-	if err == nil || !container.State.Running {
-		t.Fatalf("/bin/cat is not running after closing stdin")
-	}
+	containerWaitTimeout(eng, containerID, t)
 
 	// Try to avoid the timeout in destroy. Best effort, don't check error
-	cStdin, _ := container.StdinPipe()
+	cStdin, _ := containerAttach(eng, containerID, t)
 	cStdin.Close()
-	container.Wait()
+	containerWait(eng, containerID, t)
 }
 
 // FIXME: Test deleting running container
 // FIXME: Test deleting container with volume
 // FIXME: Test deleting volume in use by other container
 func TestDeleteContainers(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
-	srv := &docker.Server{runtime: runtime}
-
-	container, _, err := runtime.Create(&Config{
-		Image: GetTestImage(runtime).ID,
-		Cmd:   []string{"touch", "/test"},
-	}, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-
-	if err := container.Run(); err != nil {
-		t.Fatal(err)
-	}
-
-	req, err := http.NewRequest("DELETE", "/containers/"+container.ID, nil)
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image: unitTestImageID,
+			Cmd:   []string{"touch", "/test"},
+		},
+		t,
+	)
+	req, err := http.NewRequest("DELETE", "/containers/"+containerID, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 	r := httptest.NewRecorder()
-	if err := deleteContainers(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
-		t.Fatal(err)
-	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r, t)
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
-
-	if c := runtime.Get(container.ID); c != nil {
-		t.Fatalf("The container as not been deleted")
-	}
-
-	if _, err := os.Stat(path.Join(container.rwPath(), "test")); err == nil {
-		t.Fatalf("The test file has not been deleted")
-	}
+	containerAssertNotExists(eng, containerID, t)
 }
 
 func TestOptionsRoute(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	runtime.config.EnableCors = true
-	srv := &docker.Server{runtime: runtime}
-
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 	r := httptest.NewRecorder()
-	router, err := createRouter(srv, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-
 	req, err := http.NewRequest("OPTIONS", "/", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	router.ServeHTTP(r, req)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+        assertHttpNotError(r, t)
 	if r.Code != http.StatusOK {
 		t.Errorf("Expected response for OPTIONS request to be \"200\", %v found.", r.Code)
 	}
 }
 
 func TestGetEnabledCors(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	runtime.config.EnableCors = true
-	srv := &docker.Server{runtime: runtime}
-
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 	r := httptest.NewRecorder()
 
-	router, err := createRouter(srv, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-
 	req, err := http.NewRequest("GET", "/version", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	router.ServeHTTP(r, req)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+        assertHttpNotError(r, t)
 	if r.Code != http.StatusOK {
 		t.Errorf("Expected response for OPTIONS request to be \"200\", %v found.", r.Code)
 	}
@@ -1168,20 +1066,18 @@ func TestGetEnabledCors(t *testing.T) {
 }
 
 func TestDeleteImages(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &docker.Server{runtime: runtime}
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
 	initialImages, err := srv.Images(false, "")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if err := srv.runtime.repositories.Set("test", "test", unitTestImageName, true); err != nil {
+	if err := srv.ContainerTag(unitTestImageName, "test", "test", false); err != nil {
 		t.Fatal(err)
 	}
-
 	images, err := srv.Images(false, "")
 	if err != nil {
 		t.Fatal(err)
@@ -1197,8 +1093,11 @@ func TestDeleteImages(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-	if err := deleteImages(srv, docker.APIVERSION, r, req, map[string]string{"name": unitTestImageID}); err == nil {
-		t.Fatalf("Expected conflict error, got none")
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+            t.Fatal(err)
+        }
+	if r.Code != http.StatusConflict {
+		t.Fatalf("Expected http status 409-conflict, got %v", r.Code)
 	}
 
 	req2, err := http.NewRequest("DELETE", "/images/test:test", nil)
@@ -1207,14 +1106,15 @@ func TestDeleteImages(t *testing.T) {
 	}
 
 	r2 := httptest.NewRecorder()
-	if err := deleteImages(srv, docker.APIVERSION, r2, req2, map[string]string{"name": "test:test"}); err != nil {
-		t.Fatal(err)
-	}
+        if err := docker.ServeRequest(srv, docker.APIVERSION, r2, req2); err != nil {
+            t.Fatal(err)
+        }
+        assertHttpNotError(r2, t)
 	if r2.Code != http.StatusOK {
 		t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code)
 	}
 
-	var outs []APIRmi
+	var outs []docker.APIRmi
 	if err := json.Unmarshal(r2.Body.Bytes(), &outs); err != nil {
 		t.Fatal(err)
 	}
@@ -1231,59 +1131,38 @@ func TestDeleteImages(t *testing.T) {
 	}
 }
 
-func TestJsonContentType(t *testing.T) {
-	if !matchesContentType("application/json", "application/json") {
-		t.Fail()
-	}
-
-	if !matchesContentType("application/json; charset=utf-8", "application/json") {
-		t.Fail()
-	}
-
-	if matchesContentType("dockerapplication/json", "application/json") {
-		t.Fail()
-	}
-}
-
 func TestPostContainersCopy(t *testing.T) {
-	runtime := mkRuntime(t)
-	defer nuke(runtime)
-
-	srv := &docker.Server{runtime: runtime}
+        eng := NewTestEngine(t)
+        defer mkRuntimeFromEngine(eng, t).Nuke()
+        srv := mkServerFromEngine(eng, t)
 
 	// Create a container and remove a file
-	container, _, err := runtime.Create(
-		&Config{
-			Image: GetTestImage(runtime).ID,
+        containerID := createTestContainer(eng,
+		&docker.Config{
+			Image: unitTestImageID,
 			Cmd:   []string{"touch", "/test.txt"},
 		},
-		"",
+		t,
 	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-
-	if err := container.Run(); err != nil {
-		t.Fatal(err)
-	}
+        containerRun(eng, containerID, t)
 
 	r := httptest.NewRecorder()
-	copyData := APICopy{HostPath: ".", Resource: "/test.txt"}
+	copyData := docker.APICopy{HostPath: ".", Resource: "/test.txt"}
 
 	jsonData, err := json.Marshal(copyData)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	req, err := http.NewRequest("POST", "/containers/"+container.ID+"/copy", bytes.NewReader(jsonData))
+	req, err := http.NewRequest("POST", "/containers/"+containerID+"/copy", bytes.NewReader(jsonData))
 	if err != nil {
 		t.Fatal(err)
 	}
 	req.Header.Add("Content-Type", "application/json")
-	if err = postContainersCopy(srv, docker.APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 		t.Fatal(err)
 	}
+        assertHttpNotError(r, t)
 
 	if r.Code != http.StatusOK {
 		t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code)
@@ -1334,4 +1213,3 @@ func (t *hijackTester) Hijack() (net.Conn, *bufio.ReadWriter, error) {
 	}
 	return conn, bufrw, nil
 }
-*/
diff --git a/components/engine/integration/utils_test.go b/components/engine/integration/utils_test.go
index 3eb1e52d6a..7a46bed16c 100644
--- a/components/engine/integration/utils_test.go
+++ b/components/engine/integration/utils_test.go
@@ -6,12 +6,16 @@ import (
 	"github.com/dotcloud/docker"
 	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/utils"
+	"fmt"
 	"io"
 	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"path"
 	"strings"
 	"testing"
+	"time"
 )
 
 // This file contains utility functions for docker's unit test suite.
@@ -53,6 +57,105 @@ func createTestContainer(eng *engine.Engine, config *docker.Config, f utils.Fata
 	return createNamedTestContainer(eng, config, f, "")
 }
 
+func startContainer(eng *engine.Engine, id string, t utils.Fataler) {
+	job := eng.Job("start", id)
+	if err := job.Run(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+
+func containerRun(eng *engine.Engine, id string, t utils.Fataler) {
+	startContainer(eng, id, t)
+	containerWait(eng, id, t)
+}
+
+func containerFileExists(eng *engine.Engine, id, dir string, t utils.Fataler) bool {
+	c := getContainer(eng, id, t)
+	if err := c.EnsureMounted(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(path.Join(c.RootfsPath(), dir)); err != nil {
+		if os.IsNotExist(err) {
+			return false
+		}
+		t.Fatal(err)
+	}
+	return true
+}
+
+func containerAttach(eng *engine.Engine, id string, t utils.Fataler) (io.WriteCloser, io.ReadCloser) {
+	c := getContainer(eng, id, t)
+	i, err := c.StdinPipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	o, err := c.StdoutPipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	return i, o
+}
+
+
+func containerWait(eng *engine.Engine, id string, t utils.Fataler) int {
+	return getContainer(eng, id, t).Wait()
+}
+
+
+func containerWaitTimeout(eng *engine.Engine, id string, t utils.Fataler) error {
+	return getContainer(eng, id, t).WaitTimeout(500 * time.Millisecond)
+}
+
+func containerKill(eng *engine.Engine, id string, t utils.Fataler) {
+	if err := getContainer(eng, id, t).Kill(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func containerRunning(eng *engine.Engine, id string, t utils.Fataler) bool {
+	return getContainer(eng, id, t).State.Running
+}
+
+func containerAssertExists(eng *engine.Engine, id string, t utils.Fataler) {
+	getContainer(eng, id, t)
+}
+
+func containerAssertNotExists(eng *engine.Engine, id string, t utils.Fataler) {
+	runtime := mkRuntimeFromEngine(eng, t)
+	if c := runtime.Get(id); c != nil {
+		t.Fatal(fmt.Errorf("Container %s should not exist", id))
+	}
+}
+
+// assertHttpNotError expect the given response to not have an error.
+// Otherwise the it causes the test to fail.
+func assertHttpNotError(r *httptest.ResponseRecorder, t utils.Fataler) {
+	// Non-error http status are [200, 400)
+	if r.Code < http.StatusOK || r.Code >= http.StatusBadRequest {
+		t.Fatal(fmt.Errorf("Unexpected http error: %v", r.Code))
+	}
+}
+
+
+// assertHttpError expect the given response to have an error.
+// Otherwise the it causes the test to fail.
+func assertHttpError(r *httptest.ResponseRecorder, t utils.Fataler) {
+	// Non-error http status are [200, 400)
+	if !(r.Code < http.StatusOK || r.Code >= http.StatusBadRequest) {
+		t.Fatal(fmt.Errorf("Unexpected http success code: %v", r.Code))
+	}
+}
+
+func getContainer(eng *engine.Engine, id string, t utils.Fataler) *docker.Container {
+	runtime := mkRuntimeFromEngine(eng, t)
+	c := runtime.Get(id)
+	if c == nil  {
+		t.Fatal(fmt.Errorf("No such container: %s", id))
+	}
+	return c
+}
+
 func mkServerFromEngine(eng *engine.Engine, t utils.Fataler) *docker.Server {
 	iSrv := eng.Hack_GetGlobalVar("httpapi.server")
 	if iSrv == nil {
@@ -91,6 +194,8 @@ func NewTestEngine(t utils.Fataler) *engine.Engine {
 	job := eng.Job("initapi")
 	job.Setenv("Root", root)
 	job.SetenvBool("AutoRestart", false)
+	// TestGetEnabledCors and TestOptionsRoute require EnableCors=true
+	job.SetenvBool("EnableCors", true)
 	if err := job.Run(); err != nil {
 		t.Fatal(err)
 	}

From b666bf948d0a7c1df4b2b4ab2984347e0d8bc69a Mon Sep 17 00:00:00 2001
From: Andy Rothfusz <github@metaliveblog.com>
Date: Fri, 15 Nov 2013 18:12:35 -0800
Subject: [PATCH 128/184] Fixes #2701. Adds security section. Upstream-commit:
 d33ffe44a9f09b0e0aedf162ee17076571479003 Component: engine

---
 .../docs/sources/installation/index.rst       |   5 +-
 .../docs/sources/installation/security.rst    | 267 ++++++++++++++++++
 .../sources/use/workingwithrepository.rst     |   9 +
 3 files changed, 279 insertions(+), 2 deletions(-)
 create mode 100644 components/engine/docs/sources/installation/security.rst

diff --git a/components/engine/docs/sources/installation/index.rst b/components/engine/docs/sources/installation/index.rst
index 1a73cb7ae6..9004214181 100644
--- a/components/engine/docs/sources/installation/index.rst
+++ b/components/engine/docs/sources/installation/index.rst
@@ -19,11 +19,12 @@ Contents:
 
    ubuntulinux
    binaries
+   security
+   upgrading
+   kernel
    vagrant
    windows
    amazon
    rackspace
    archlinux
    gentoolinux
-   upgrading
-   kernel
diff --git a/components/engine/docs/sources/installation/security.rst b/components/engine/docs/sources/installation/security.rst
new file mode 100644
index 0000000000..3dc5780e85
--- /dev/null
+++ b/components/engine/docs/sources/installation/security.rst
@@ -0,0 +1,267 @@
+:title: Docker Security
+:description: Review of the Docker Daemon attack surface
+:keywords: Docker, Docker documentation, security
+
+.. _dockersecurity:
+
+Docker Security
+===============
+
+  *Adapted from* `Containers & Docker: How Secure are They? <blogsecurity>`_
+
+There are three major areas to consider when reviewing Docker security:
+
+* the intrinsic security of containers, as implemented by kernel
+  namespaces and cgroups;
+* the attack surface of the Docker daemon itself;
+* the "hardening" security features of the kernel and how they
+  interact with containers.
+
+Kernel Namespaces
+-----------------
+
+Docker containers are essentially LXC containers, and they come with
+the same security features. When you start a container with ``docker
+run``, behind the scenes Docker uses ``lxc-start`` to execute the
+Docker container. This creates a set of namespaces and control groups
+for the container. Those namespaces and control groups are not created
+by Docker itself, but by ``lxc-start``. This means that as the LXC
+userland tools evolve (and provide additional namespaces and isolation
+features), Docker will automatically make use of them.
+
+**Namespaces provide the first and most straightforward form of
+isolation**: processes running within a container cannot see, and even
+less affect, processes running in another container, or in the host
+system.
+
+**Each container also gets its own network stack**, meaning that a
+container doesn’t get a privileged access to the sockets or interfaces
+of another container. Of course, if the host system is setup
+accordingly, containers can interact with each other through their
+respective network interfaces — just like they can interact with
+external hosts. When you specify public ports for your containers or
+use :ref:`links <working_with_links_names>` then IP traffic is allowed
+between containers. They can ping each other, send/receive UDP
+packets, and establish TCP connections, but that can be restricted if
+necessary. From a network architecture point of view, all containers
+on a given Docker host are sitting on bridge interfaces. This means
+that they are just like physical machines connected through a common
+Ethernet switch; no more, no less.
+
+How mature is the code providing kernel namespaces and private
+networking?  Kernel namespaces were introduced `between kernel version
+2.6.15 and 2.6.26
+<http://lxc.sourceforge.net/index.php/about/kernel-namespaces/>`_. This
+means that since July 2008 (date of the 2.6.26 release, now 5 years
+ago), namespace code has been exercised and scrutinized on a large
+number of production systems. And there is more: the design and
+inspiration for the namespaces code are even older. Namespaces are
+actually an effort to reimplement the features of `OpenVZ
+<http://en.wikipedia.org/wiki/OpenVZ>`_ in such a way that they could
+be merged within the mainstream kernel. And OpenVZ was initially
+released in 2005, so both the design and the implementation are
+pretty mature.
+
+Control Groups
+--------------
+
+Control Groups are the other key component of Linux Containers. They
+implement resource accounting and limiting. They provide a lot of very
+useful metrics, but they also help to ensure that each container gets
+its fair share of memory, CPU, disk I/O; and, more importantly, that a
+single container cannot bring the system down by exhausting one of
+those resources.
+
+So while they do not play a role in preventing one container from
+accessing or affecting the data and processes of another container,
+they are essential to fend off some denial-of-service attacks. They
+are particularly important on multi-tenant platforms, like public and
+private PaaS, to guarantee a consistent uptime (and performance) even
+when some applications start to misbehave.
+
+Control Groups have been around for a while as well: the code was
+started in 2006, and initially merged in kernel 2.6.24.
+
+Docker Daemon Attack Surface
+----------------------------
+
+Running containers (and applications) with Docker implies running the
+Docker daemon. This daemon currently requires root privileges, and you
+should therefore be aware of some important details.
+
+First of all, **only trusted users should be allowed to control your
+Docker daemon**. This is a direct consequence of some powerful Docker
+features. Specifically, Docker allows you to share a directory between
+the Docker host and a guest container; and it allows you to do so
+without limiting the access rights of the container. This means that
+you can start a container where the ``/host`` directory will be the
+``/`` directory on your host; and the container will be able to alter
+your host filesystem without any restriction. This sounds crazy? Well,
+you have to know that **all virtualization systems allowing filesystem
+resource sharing behave the same way**. Nothing prevents you from
+sharing your root filesystem (or even your root block device) with a
+virtual machine.
+
+This has a strong security implication: if you instrument Docker from
+e.g. a web server to provision containers through an API, you should
+be even more careful than usual with parameter checking, to make sure
+that a malicious user cannot pass crafted parameters causing Docker to
+create arbitrary containers.
+
+For this reason, the REST API endpoint (used by the Docker CLI to
+communicate with the Docker daemon) changed in Docker 0.5.2, and now
+uses a UNIX socket instead of a TCP socket bound on 127.0.0.1 (the
+latter being prone to cross-site-scripting attacks if you happen to
+run Docker directly on your local machine, outside of a VM). You can
+then use traditional UNIX permission checks to limit access to the
+control socket.
+
+You can also expose the REST API over HTTP if you explicitly decide
+so. However, if you do that, being aware of the abovementioned
+security implication, you should ensure that it will be reachable
+only from a trusted network or VPN; or protected with e.g. ``stunnel``
+and client SSL certificates.
+
+Recent improvements in Linux namespaces will soon allow to run
+full-featured containers without root privileges, thanks to the new
+user namespace. This is covered in detail `here
+<http://s3hh.wordpress.com/2013/07/19/creating-and-using-containers-without-privilege/>`_. Moreover,
+this will solve the problem caused by sharing filesystems between host
+and guest, since the user namespace allows users within containers
+(including the root user) to be mapped to other users in the host
+system.
+
+The end goal for Docker is therefore to implement two additional
+security improvements:
+
+* map the root user of a container to a non-root user of the Docker
+  host, to mitigate the effects of a container-to-host privilege
+  escalation;
+* allow the Docker daemon to run without root privileges, and delegate
+  operations requiring those privileges to well-audited sub-processes,
+  each with its own (very limited) scope: virtual network setup,
+  filesystem management, etc.
+
+Finally, if you run Docker on a server, it is recommended to run
+exclusively Docker in the server, and move all other services within
+containers controlled by Docker. Of course, it is fine to keep your
+favorite admin tools (probably at least an SSH server), as well as
+existing monitoring/supervision processes (e.g. NRPE, collectd, etc).
+
+Linux Kernel Capabilities
+-------------------------
+
+By default, Docker starts containers with a very restricted set of
+capabilities. What does that mean?
+
+Capabilities turn the binary "root/non-root" dichotomy into a
+fine-grained access control system. Processes (like web servers) that
+just need to bind on a port below 1024 do not have to run as root:
+they can just be granted the ``net_bind_service`` capability
+instead. And there are many other capabilities, for almost all the
+specific areas where root privileges are usually needed.
+
+This means a lot for container security; let’s see why!
+
+Your average server (bare metal or virtual machine) needs to run a
+bunch of processes as root. Those typically include SSH, cron,
+syslogd; hardware management tools (to e.g. load modules), network
+configuration tools (to handle e.g. DHCP, WPA, or VPNs), and much
+more. A container is very different, because almost all of those tasks
+are handled by the infrastructure around the container:
+
+* SSH access will typically be managed by a single server running in
+  the Docker host;
+* ``cron``, when necessary, should run as a user process, dedicated
+  and tailored for the app that needs its scheduling service, rather
+  than as a platform-wide facility;
+* log management will also typically be handed to Docker, or by
+  third-party services like Loggly or Splunk;
+* hardware management is irrelevant, meaning that you never need to
+  run ``udevd`` or equivalent daemons within containers;
+* network management happens outside of the containers, enforcing
+  separation of concerns as much as possible, meaning that a container
+  should never need to perform ``ifconfig``, ``route``, or ip commands
+  (except when a container is specifically engineered to behave like a
+  router or firewall, of course).
+
+This means that in most cases, containers will not need "real" root
+privileges *at all*. And therefore, containers can run with a reduced
+capability set; meaning that "root" within a container has much less
+privileges than the real "root". For instance, it is possible to:
+
+* deny all "mount" operations;
+* deny access to raw sockets (to prevent packet spoofing);
+* deny access to some filesystem operations, like creating new device
+  nodes, changing the owner of files, or altering attributes
+  (including the immutable flag);
+* deny module loading;
+* and many others.
+
+This means that even if an intruder manages to escalate to root within
+a container, it will be much harder to do serious damage, or to
+escalate to the host.
+
+This won't affect regular web apps; but malicious users will find that
+the arsenal at their disposal has shrunk considerably! You can see
+`the list of dropped capabilities in the Docker code
+<https://github.com/dotcloud/docker/blob/v0.5.0/lxc_template.go#L97>`_,
+and a full list of available capabilities in `Linux manpages
+<http://man7.org/linux/man-pages/man7/capabilities.7.html>`_.
+
+Of course, you can always enable extra capabilities if you really need
+them (for instance, if you want to use a FUSE-based filesystem), but
+by default, Docker containers will be locked down to ensure maximum
+safety.
+
+Other Kernel Security Features
+------------------------------
+
+Capabilities are just one of the many security features provided by
+modern Linux kernels. It is also possible to leverage existing,
+well-known systems like TOMOYO, AppArmor, SELinux, GRSEC, etc. with
+Docker.
+
+While Docker currently only enables capabilities, it doesn't interfere
+with the other systems. This means that there are many different ways
+to harden a Docker host. Here are a few examples.
+
+* You can run a kernel with GRSEC and PAX. This will add many safety
+  checks, both at compile-time and run-time; it will also defeat many
+  exploits, thanks to techniques like address randomization. It
+  doesn’t require Docker-specific configuration, since those security
+  features apply system-wide, independently of containers.
+* If your distribution comes with security model templates for LXC
+  containers, you can use them out of the box. For instance, Ubuntu
+  comes with AppArmor templates for LXC, and those templates provide
+  an extra safety net (even though it overlaps greatly with
+  capabilities).
+* You can define your own policies using your favorite access control
+  mechanism. Since Docker containers are standard LXC containers,
+  there is nothing “magic” or specific to Docker.
+
+Just like there are many third-party tools to augment Docker
+containers with e.g. special network topologies or shared filesystems,
+you can expect to see tools to harden existing Docker containers
+without affecting Docker’s core.
+
+Conclusions
+-----------
+
+Docker containers are, by default, quite secure; especially if you
+take care of running your processes inside the containers as
+non-privileged users (i.e. non root).
+
+You can add an extra layer of safety by enabling Apparmor, SELinux,
+GRSEC, or your favorite hardening solution.
+
+Last but not least, if you see interesting security features in other
+containerization systems, you will be able to implement them as well
+with Docker, since everything is provided by the kernel anyway.
+
+For more context and especially for comparisons with VMs and other
+container systems, please also see the `original blog post
+<blogsecurity>`_.
+
+.. _blogsecurity: http://blog.docker.io/2013/08/containers-docker-how-secure-are-they/
+
diff --git a/components/engine/docs/sources/use/workingwithrepository.rst b/components/engine/docs/sources/use/workingwithrepository.rst
index 66b2928c96..5faebcc2e5 100644
--- a/components/engine/docs/sources/use/workingwithrepository.rst
+++ b/components/engine/docs/sources/use/workingwithrepository.rst
@@ -177,6 +177,15 @@ you can push and pull it like any other repository, but it will
 there will be no user name checking performed. Your registry will
 function completely independently from the Central Index.
 
+.. raw:: html
+
+   <iframe width="640" height="360"
+   src="//www.youtube.com/embed/CAewZCBT4PI?rel=0" frameborder="0"
+   allowfullscreen></iframe>
+
+.. seealso:: `Docker Blog: How to use your own registry 
+   <http://blog.docker.io/2013/07/how-to-use-your-own-registry/>`_
+
 Authentication file
 -------------------
 

From bc3e877db3b3f6b7742291daafe80f398b959e4a Mon Sep 17 00:00:00 2001
From: Sven Dowideit <SvenDowideit@home.org.au>
Date: Sat, 16 Nov 2013 20:15:04 +1000
Subject: [PATCH 129/184] expunge the word 'Resource' in reference to a
 file/dir in a CONTAINER - that way users don't wonder how its different from
 a Path Upstream-commit: 27159ce6bac4308b5fba311258fab8e852667787 Component:
 engine

---
 components/engine/api.go                           | 2 +-
 components/engine/commands.go                      | 4 ++--
 components/engine/docs/sources/commandline/cli.rst | 7 ++++++-
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index dbaa2ae7de..c4d0f79503 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -978,7 +978,7 @@ func postContainersCopy(srv *Server, version float64, w http.ResponseWriter, r *
 	}
 
 	if copyData.Resource == "" {
-		return fmt.Errorf("Resource cannot be empty")
+		return fmt.Errorf("Path cannot be empty")
 	}
 	if copyData.Resource[0] == '/' {
 		copyData.Resource = copyData.Resource[1:]
diff --git a/components/engine/commands.go b/components/engine/commands.go
index 710a311c08..1f780925ad 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1924,7 +1924,7 @@ func (cli *DockerCli) CmdRun(args ...string) error {
 }
 
 func (cli *DockerCli) CmdCp(args ...string) error {
-	cmd := Subcmd("cp", "CONTAINER:RESOURCE HOSTPATH", "Copy files/folders from the RESOURCE to the HOSTPATH")
+	cmd := Subcmd("cp", "CONTAINER:PATH HOSTPATH", "Copy files/folders from the PATH to the HOSTPATH")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -1938,7 +1938,7 @@ func (cli *DockerCli) CmdCp(args ...string) error {
 	info := strings.Split(cmd.Arg(0), ":")
 
 	if len(info) != 2 {
-		return fmt.Errorf("Error: Resource not specified")
+		return fmt.Errorf("Error: Path not specified")
 	}
 
 	copyData.Resource = info[1]
diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 37f371baad..91f92248ba 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -219,10 +219,15 @@ Full -run example
 
 ::
 
-    Usage: docker cp CONTAINER:RESOURCE HOSTPATH
+    Usage: docker cp CONTAINER:PATH HOSTPATH
 
     Copy files/folders from the containers filesystem to the host
     path.  Paths are relative to the root of the filesystem.
+    
+.. code-block:: bash
+
+    $ sudo docker cp 7bb0e258aefe:/etc/debian_version .
+    $ sudo docker cp blue_frog:/etc/hosts .
 
 .. _cli_diff:
 

From 83c673a90c3eb0a9ae66375c3e75e52b1e8f1748 Mon Sep 17 00:00:00 2001
From: Sven Dowideit <SvenDowideit@home.org.au>
Date: Sat, 16 Nov 2013 20:26:47 +1000
Subject: [PATCH 130/184] add an example of what to expect from docker diff,
 and what the 3 codes mean Upstream-commit:
 af05ab399e17c97bdea4b3ee893c47f29c0e22a5 Component: engine

---
 .../engine/docs/sources/commandline/cli.rst   | 28 +++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 37f371baad..252eda21d7 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -231,9 +231,33 @@ Full -run example
 
 ::
 
-    Usage: docker diff CONTAINER [OPTIONS]
+    Usage: docker diff CONTAINER
+ 
+    List the changed files and directories in a container's filesystem
 
-    Inspect changes on a container's filesystem
+There are 3 events that are listed in the 'diff':
+
+1. ```A``` - Add
+2. ```D``` - Delete
+3. ```C``` - Change
+
+for example:
+
+.. code-block:: bash
+
+	$ sudo docker diff 7bb0e258aefe
+
+	C /dev
+	A /dev/kmsg
+	C /etc
+	A /etc/mtab
+	A /go
+	A /go/src
+	A /go/src/github.com
+	A /go/src/github.com/dotcloud
+	A /go/src/github.com/dotcloud/docker
+	A /go/src/github.com/dotcloud/docker/.git
+	....
 
 .. _cli_events:
 

From b3d92f6b0fd1d1a237998d16fc77e49e39f6c629 Mon Sep 17 00:00:00 2001
From: Sven Dowideit <SvenDowideit@home.org.au>
Date: Sat, 16 Nov 2013 20:36:33 +1000
Subject: [PATCH 131/184] add example for docker history Upstream-commit:
 f04142c1f765b4d1afb8eb388f3ca9466c22abf7 Component: engine

---
 .../engine/docs/sources/commandline/cli.rst   | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 37f371baad..88aca1374c 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -323,6 +323,40 @@ Show events in the past from a specified time
       -notrunc=false: Don't truncate output
       -q=false: only show numeric IDs
 
+To see how the docker:latest image was built:
+
+.. code-block:: bash
+
+	$ docker history docker
+	ID                  CREATED             CREATED BY
+	docker:latest       19 hours ago        /bin/sh -c #(nop) ADD . in /go/src/github.com/dotcloud/docker
+	cf5f2467662d        2 weeks ago         /bin/sh -c #(nop) ENTRYPOINT ["hack/dind"]
+	3538fbe372bf        2 weeks ago         /bin/sh -c #(nop) WORKDIR /go/src/github.com/dotcloud/docker
+	7450f65072e5        2 weeks ago         /bin/sh -c #(nop) VOLUME /var/lib/docker
+	b79d62b97328        2 weeks ago         /bin/sh -c apt-get install -y -q lxc
+	36714852a550        2 weeks ago         /bin/sh -c apt-get install -y -q iptables
+	8c4c706df1d6        2 weeks ago         /bin/sh -c /bin/echo -e '[default]\naccess_key=$AWS_ACCESS_KEY\nsecret_key=$AWS_SECRET_KEYn' > /.s3cfg
+	b89989433c48        2 weeks ago         /bin/sh -c pip install python-magic
+	a23e640d85b5        2 weeks ago         /bin/sh -c pip install s3cmd
+	41f54fec7e79        2 weeks ago         /bin/sh -c apt-get install -y -q python-pip
+	d9bc04add907        2 weeks ago         /bin/sh -c apt-get install -y -q reprepro dpkg-sig
+	e74f4760fa70        2 weeks ago         /bin/sh -c gem install --no-rdoc --no-ri fpm
+	1e43224726eb        2 weeks ago         /bin/sh -c apt-get install -y -q ruby1.9.3 rubygems libffi-dev
+	460953ae9d7f        2 weeks ago         /bin/sh -c #(nop) ENV GOPATH=/go:/go/src/github.com/dotcloud/docker/vendor
+	8b63eb1d666b        2 weeks ago         /bin/sh -c #(nop) ENV PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/goroot/bin
+	3087f3bcedf2        2 weeks ago         /bin/sh -c #(nop) ENV GOROOT=/goroot
+	635840d198e5        2 weeks ago         /bin/sh -c cd /goroot/src && ./make.bash
+	439f4a0592ba        2 weeks ago         /bin/sh -c curl -s https://go.googlecode.com/files/go1.1.2.src.tar.gz | tar -v -C / -xz && mv /go /goroot
+	13967ed36e93        2 weeks ago         /bin/sh -c #(nop) ENV CGO_ENABLED=0
+	bf7424458437        2 weeks ago         /bin/sh -c apt-get install -y -q build-essential
+	a89ec997c3bf        2 weeks ago         /bin/sh -c apt-get install -y -q mercurial
+	b9f165c6e749        2 weeks ago         /bin/sh -c apt-get install -y -q git
+	17a64374afa7        2 weeks ago         /bin/sh -c apt-get install -y -q curl
+	d5e85dc5b1d8        2 weeks ago         /bin/sh -c apt-get update
+	13e642467c11        2 weeks ago         /bin/sh -c echo 'deb http://archive.ubuntu.com/ubuntu precise main universe' > /etc/apt/sources.list
+	ae6dde92a94e        2 weeks ago         /bin/sh -c #(nop) MAINTAINER Solomon Hykes <solomon@dotcloud.com>
+	ubuntu:12.04        6 months ago 
+
 .. _cli_images:
 
 ``images``

From dbd9984b5bbf504db52dee36e5e477ad56119159 Mon Sep 17 00:00:00 2001
From: Sven Dowideit <SvenDowideit@home.org.au>
Date: Sat, 16 Nov 2013 20:45:30 +1000
Subject: [PATCH 132/184] add some common examples for docker images, and tell
 the user what -a filters out Upstream-commit:
 152459b7272daa30ab5207b512f5319fdc4ff491 Component: engine

---
 components/engine/commands.go                 |  2 +-
 .../engine/docs/sources/commandline/cli.rst   | 44 ++++++++++++++++---
 2 files changed, 40 insertions(+), 6 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index 710a311c08..e130711dde 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1073,7 +1073,7 @@ func (cli *DockerCli) CmdPull(args ...string) error {
 func (cli *DockerCli) CmdImages(args ...string) error {
 	cmd := Subcmd("images", "[OPTIONS] [NAME]", "List images")
 	quiet := cmd.Bool("q", false, "only show numeric IDs")
-	all := cmd.Bool("a", false, "show all images")
+	all := cmd.Bool("a", false, "show all images (by default filter out the intermediate images used to build)")
 	noTrunc := cmd.Bool("notrunc", false, "Don't truncate output")
 	flViz := cmd.Bool("viz", false, "output graph in graphviz format")
 	flTree := cmd.Bool("tree", false, "output graph in tree format")
diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 37f371baad..d6ad116313 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -334,18 +334,52 @@ Show events in the past from a specified time
 
     List images
 
-      -a=false: show all images
+      -a=false: show all images (by default filter out the intermediate images used to build)
       -notrunc=false: Don't truncate output
       -q=false: only show numeric IDs
       -tree=false: output graph in tree format
       -viz=false: output graph in graphviz format
+      
+Listing the most recently created images
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: bash
+
+	$ sudo docker images | head
+	REPOSITORY                    TAG                 IMAGE ID            CREATED             SIZE
+	<none>                        <none>              77af4d6b9913        19 hours ago        30.53 MB (virtual 1.089 GB)
+	committest                    latest              b6fa739cedf5        19 hours ago        30.53 MB (virtual 1.089 GB)
+	<none>                        <none>              78a85c484f71        19 hours ago        30.53 MB (virtual 1.089 GB)
+	docker                        latest              30557a29d5ab        20 hours ago        30.53 MB (virtual 1.089 GB)
+	<none>                        <none>              0124422dd9f9        20 hours ago        30.53 MB (virtual 1.089 GB)
+	<none>                        <none>              18ad6fad3402        22 hours ago        23.68 MB (virtual 1.082 GB)
+	<none>                        <none>              f9f1e26352f0        23 hours ago        30.46 MB (virtual 1.089 GB)
+	tryout                        latest              2629d1fa0b81        23 hours ago        16.4 kB (virtual 131.5 MB)
+	<none>                        <none>              5ed6274db6ce        24 hours ago        30.44 MB (virtual 1.089 GB)
+
+Listing the full length image IDs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: bash
+
+	$ sudo docker images -notrunc | head
+	REPOSITORY                    TAG                 IMAGE ID                                                           CREATED             SIZE
+	<none>                        <none>              77af4d6b9913e693e8d0b4b294fa62ade6054e6b2f1ffb617ac955dd63fb0182   19 hours ago        30.53 MB (virtual 1.089 GB)
+	committest                    latest              b6fa739cedf5ea12a620a439402b6004d057da800f91c7524b5086a5e4749c9f   19 hours ago        30.53 MB (virtual 1.089 GB)
+	<none>                        <none>              78a85c484f71509adeaace20e72e941f6bdd2b25b4c75da8693efd9f61a37921   19 hours ago        30.53 MB (virtual 1.089 GB)
+	docker                        latest              30557a29d5abc51e5f1d5b472e79b7e296f595abcf19fe6b9199dbbc809c6ff4   20 hours ago        30.53 MB (virtual 1.089 GB)
+	<none>                        <none>              0124422dd9f9cf7ef15c0617cda3931ee68346455441d66ab8bdc5b05e9fdce5   20 hours ago        30.53 MB (virtual 1.089 GB)
+	<none>                        <none>              18ad6fad340262ac2a636efd98a6d1f0ea775ae3d45240d3418466495a19a81b   22 hours ago        23.68 MB (virtual 1.082 GB)
+	<none>                        <none>              f9f1e26352f0a3ba6a0ff68167559f64f3e21ff7ada60366e2d44a04befd1d3a   23 hours ago        30.46 MB (virtual 1.089 GB)
+	tryout                        latest              2629d1fa0b81b222fca63371ca16cbf6a0772d07759ff80e8d1369b926940074   23 hours ago        16.4 kB (virtual 131.5 MB)
+	<none>                        <none>              5ed6274db6ceb2397844896966ea239290555e74ef307030ebb01ff91b1914df   24 hours ago        30.44 MB (virtual 1.089 GB)
 
 Displaying images visually
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-::
+.. code-block:: bash
 
-    sudo docker images -viz | dot -Tpng -o docker.png
+    $ sudo docker images -viz | dot -Tpng -o docker.png
 
 .. image:: docker_images.gif
    :alt: Example inheritance graph of Docker images.
@@ -354,9 +388,9 @@ Displaying images visually
 Displaying image hierarchy
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-::
+.. code-block:: bash
 
-    sudo docker images -tree
+    $ sudo docker images -tree
 
     |─8dbd9e392a96 Size: 131.5 MB (virtual 131.5 MB) Tags: ubuntu:12.04,ubuntu:latest,ubuntu:precise
     └─27cf78414709 Size: 180.1 MB (virtual 180.1 MB)

From dbb96cce3dcbaa3d25f29e47b9d3a1ac80264cc0 Mon Sep 17 00:00:00 2001
From: Sven Dowideit <SvenDowideit@home.org.au>
Date: Sat, 16 Nov 2013 20:53:45 +1000
Subject: [PATCH 133/184] add example Upstream-commit:
 5c741ef11db8777bc7723d879624ae8281121c18 Component: engine

---
 .../engine/docs/sources/commandline/cli.rst       | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 37f371baad..7d047375da 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -435,6 +435,21 @@ might not get preserved.
 
     Display system-wide information.
 
+.. code-block:: bash
+
+	$ sudo docker info
+	Containers: 292
+	Images: 194
+	Debug mode (server): false
+	Debug mode (client): false
+	Fds: 22
+	Goroutines: 67
+	LXC Version: 0.9.0
+	EventsListeners: 115
+	Kernel Version: 3.8.0-33-generic
+	WARNING: No swap limit support
+
+
 .. _cli_insert:
 
 ``insert``

From a69dc14f583ab8c6ee6d115af4bae11523d8c4c2 Mon Sep 17 00:00:00 2001
From: Sven Dowideit <SvenDowideit@home.org.au>
Date: Sat, 16 Nov 2013 21:11:34 +1000
Subject: [PATCH 134/184] make the docker commit help more copy&pasteable
 Upstream-commit: bc74f65068b6b80b657e07f4ab2d7b115aacae75 Component: engine

---
 components/engine/commands.go                      | 2 +-
 components/engine/docs/sources/commandline/cli.rst | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index 710a311c08..18be5fc051 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1360,7 +1360,7 @@ func (cli *DockerCli) CmdCommit(args ...string) error {
 	cmd := Subcmd("commit", "[OPTIONS] CONTAINER [REPOSITORY[:TAG]]", "Create a new image from a container's changes")
 	flComment := cmd.String("m", "", "Commit message")
 	flAuthor := cmd.String("author", "", "Author (eg. \"John Hannibal Smith <hannibal@a-team.com>\"")
-	flConfig := cmd.String("run", "", "Config automatically applied when the image is run. "+`(ex: {"Cmd": ["cat", "/world"], "PortSpecs": ["22"]}')`)
+	flConfig := cmd.String("run", "", "Config automatically applied when the image is run. "+`(ex: -run='{"Cmd": ["cat", "/world"], "PortSpecs": ["22"]}')`)
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 37f371baad..7db2a309b7 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -157,7 +157,7 @@ by using the ``git://`` schema.
       -m="": Commit message
       -author="": Author (eg. "John Hannibal Smith <hannibal@a-team.com>"
       -run="": Configuration to be applied when the image is launched with `docker run`.
-               (ex: '{"Cmd": ["cat", "/world"], "PortSpecs": ["22"]}')
+               (ex: -run='{"Cmd": ["cat", "/world"], "PortSpecs": ["22"]}')
 
 Simple commit of an existing container
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -173,7 +173,7 @@ Simple commit of an existing container
 	$ docker images | head
 	REPOSITORY                        TAG                 ID                  CREATED             SIZE
 	SvenDowideit/testimage            version3            f5283438590d        16 seconds ago      204.2 MB (virtual 335.7 MB)
-	S
+	
 
 Full -run example
 .................

From 58c14de9fd95cd4647b63a9e0a0b583d603abd23 Mon Sep 17 00:00:00 2001
From: Justin Plock <jplock@users.noreply.github.com>
Date: Sat, 16 Nov 2013 11:05:38 -0500
Subject: [PATCH 135/184] Fix images not being properly tagged Upstream-commit:
 0e64b987e8cbbd6944bd0594f8173f959867f4fc Component: engine

---
 components/engine/contrib/mkimage-debootstrap.sh | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/components/engine/contrib/mkimage-debootstrap.sh b/components/engine/contrib/mkimage-debootstrap.sh
index b0a370da7d..a078801b90 100755
--- a/components/engine/contrib/mkimage-debootstrap.sh
+++ b/components/engine/contrib/mkimage-debootstrap.sh
@@ -192,7 +192,7 @@ if [ "$justTar" ]; then
 	sudo tar --numeric-owner -caf "$repo" .
 else
 	# create the image (and tag $repo:$suite)
-	sudo tar --numeric-owner -c . | $docker import - $repo $suite
+	sudo tar --numeric-owner -c . | $docker import - $repo:$suite
 	
 	# test the image
 	$docker run -i -t $repo:$suite echo success
@@ -202,25 +202,25 @@ else
 			Debian)
 				if [ "$suite" = "$debianStable" -o "$suite" = 'stable' ] && [ -r etc/debian_version ]; then
 					# tag latest
-					$docker tag $repo:$suite $repo latest
+					$docker tag $repo:$suite $repo:latest
 					
 					if [ -r etc/debian_version ]; then
 						# tag the specific debian release version (which is only reasonable to tag on debian stable)
 						ver=$(cat etc/debian_version)
-						$docker tag $repo:$suite $repo $ver
+						$docker tag $repo:$suite $repo:$ver
 					fi
 				fi
 				;;
 			Ubuntu)
 				if [ "$suite" = "$ubuntuLatestLTS" ]; then
 					# tag latest
-					$docker tag $repo:$suite $repo latest
+					$docker tag $repo:$suite $repo:latest
 				fi
 				if [ -r etc/lsb-release ]; then
 					lsbRelease="$(. etc/lsb-release && echo "$DISTRIB_RELEASE")"
 					if [ "$lsbRelease" ]; then
 						# tag specific Ubuntu version number, if available (12.04, etc.)
-						$docker tag $repo:$suite $repo $lsbRelease
+						$docker tag $repo:$suite $repo:$lsbRelease
 					fi
 				fi
 				;;

From 002c9db825851fbe4bbfae3919a6f641c243594f Mon Sep 17 00:00:00 2001
From: Frederik Loeffert <frederik@zitrusmedia.de>
Date: Sun, 17 Nov 2013 01:20:21 +0100
Subject: [PATCH 136/184] Vagrantfile modified to support
 VBoxGuestAdditions_4.3.2 Upstream-commit:
 7e580aacec10d64c2fa0811e41a35159e47fcfa4 Component: engine

---
 components/engine/Vagrantfile | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/components/engine/Vagrantfile b/components/engine/Vagrantfile
index a0bb38ca4f..6bbea51d46 100644
--- a/components/engine/Vagrantfile
+++ b/components/engine/Vagrantfile
@@ -70,7 +70,7 @@ SCRIPT
 # trigger dkms to build the virtualbox guest module install.
 $vbox_script = <<VBOX_SCRIPT + $script
 # Install the VirtualBox guest additions if they aren't already installed.
-if [ ! -d /opt/VBoxGuestAdditions-4.2.12/ ]; then
+if [ ! -d /opt/VBoxGuestAdditions-4.3.2/ ]; then
     # Update remote package metadata.  'apt-get update' is idempotent.
     apt-get update -q
 
@@ -79,9 +79,9 @@ if [ ! -d /opt/VBoxGuestAdditions-4.2.12/ ]; then
     apt-get install -q -y linux-headers-generic-lts-raring dkms
 
     echo 'Downloading VBox Guest Additions...'
-    wget -cq http://dlc.sun.com.edgesuite.net/virtualbox/4.2.12/VBoxGuestAdditions_4.2.12.iso
+    wget -cq http://dlc.sun.com.edgesuite.net/virtualbox/4.3.2/VBoxGuestAdditions_4.3.2.iso
 
-    mount -o loop,ro /home/vagrant/VBoxGuestAdditions_4.2.12.iso /mnt
+    mount -o loop,ro /home/vagrant/VBoxGuestAdditions_4.3.2.iso /mnt
     /mnt/VBoxLinuxAdditions.run --nox11
     umount /mnt
 fi

From 92d82345a33a7711fd3014d12bc544066d004fc9 Mon Sep 17 00:00:00 2001
From: Rick Bradley <rick@users.noreply.github.com>
Date: Sun, 17 Nov 2013 21:10:06 -0800
Subject: [PATCH 137/184] Tiny typo cleanup Upstream-commit:
 b76574f85512d3566bd056d516084e777788a82c Component: engine

---
 components/engine/docs/sources/use/working_with_volumes.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/docs/sources/use/working_with_volumes.rst b/components/engine/docs/sources/use/working_with_volumes.rst
index 25febad755..3a06685e54 100644
--- a/components/engine/docs/sources/use/working_with_volumes.rst
+++ b/components/engine/docs/sources/use/working_with_volumes.rst
@@ -45,7 +45,7 @@ Create a new container using existing volumes from an existing container:
 ---------------------------------------------------------------------------
 
 
-The command below creates a new container which is runnning as daemon ``-d`` and with one volume ``/var/lib/couchdb``::
+The command below creates a new container which is running as daemon ``-d`` and with one volume ``/var/lib/couchdb``::
 
   COUCH1=$(sudo docker run -d -v /var/lib/couchdb shykes/couchdb:2013-05-03)
 

From 6f7d08bf451ac36576f790557c954aab945310bf Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Sun, 17 Nov 2013 22:36:26 -0700
Subject: [PATCH 138/184] Update to go1.2rc5 Upstream-commit:
 9e1da3ec9ce8e608c17d999446882ae096b8394f Component: engine

---
 components/engine/Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/Dockerfile b/components/engine/Dockerfile
index a8b2f2e00e..559017507e 100644
--- a/components/engine/Dockerfile
+++ b/components/engine/Dockerfile
@@ -36,7 +36,7 @@ run	apt-get install -y -q mercurial
 run apt-get install -y -q build-essential libsqlite3-dev
 
 # Install Go
-run	curl -s https://go.googlecode.com/files/go1.2rc4.src.tar.gz | tar -v -C /usr/local -xz
+run	curl -s https://go.googlecode.com/files/go1.2rc5.src.tar.gz | tar -v -C /usr/local -xz
 env	PATH	/usr/local/go/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
 env	GOPATH	/go:/go/src/github.com/dotcloud/docker/vendor
 run cd /usr/local/go/src && ./make.bash && go install -ldflags '-w -linkmode external -extldflags "-static -Wl,--unresolved-symbols=ignore-in-shared-libs"' -tags netgo -a std

From ed492661bbcf2e93e8d58148c3dae9913f6d81da Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Tue, 5 Nov 2013 19:29:55 -0600
Subject: [PATCH 139/184] test: put each arg in a separate string

Each arg to docker run should be placed in a separate string.
Otherwise, when starting the command via exec.Cmd, the command is
interpreted as "echo test", which can't be found.
Upstream-commit: 30ea0bebce340dfc257b5b45835234cb921f3a48
Component: engine
---
 components/engine/integration/server_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/components/engine/integration/server_test.go b/components/engine/integration/server_test.go
index 6c61bedafb..b19c2e1a91 100644
--- a/components/engine/integration/server_test.go
+++ b/components/engine/integration/server_test.go
@@ -109,7 +109,7 @@ func TestCreateRmVolumes(t *testing.T) {
 	srv := mkServerFromEngine(eng, t)
 	defer mkRuntimeFromEngine(eng, t).Nuke()
 
-	config, hostConfig, _, err := docker.ParseRun([]string{"-v", "/srv", unitTestImageID, "echo test"}, nil)
+	config, hostConfig, _, err := docker.ParseRun([]string{"-v", "/srv", unitTestImageID, "echo", "test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -240,7 +240,7 @@ func TestRmi(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	config, hostConfig, _, err := docker.ParseRun([]string{unitTestImageID, "echo test"}, nil)
+	config, hostConfig, _, err := docker.ParseRun([]string{unitTestImageID, "echo", "test"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}

From 4527e7358654d6328968731b2590e8fc761bc4a0 Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Mon, 11 Nov 2013 21:57:29 -0600
Subject: [PATCH 140/184] test: fix TestCreateStartRestartStopStartKillRm

cat needs stdin opened, otherwise it dies immediately.
Upstream-commit: baa687bed2f1f9ee6e44c70d95baad8757ac529c
Component: engine
---
 components/engine/integration/server_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/integration/server_test.go b/components/engine/integration/server_test.go
index b19c2e1a91..8cd3e30fdf 100644
--- a/components/engine/integration/server_test.go
+++ b/components/engine/integration/server_test.go
@@ -164,7 +164,7 @@ func TestCreateStartRestartStopStartKillRm(t *testing.T) {
 	srv := mkServerFromEngine(eng, t)
 	defer mkRuntimeFromEngine(eng, t).Nuke()
 
-	config, hostConfig, _, err := docker.ParseRun([]string{unitTestImageID, "/bin/cat"}, nil)
+	config, hostConfig, _, err := docker.ParseRun([]string{"-i", unitTestImageID, "/bin/cat"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}

From b0f8db9d1bc9eb3c5ff3e21ac60cb390d0939d5d Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Wed, 6 Nov 2013 09:57:43 -0600
Subject: [PATCH 141/184] test: skip TestCreate on Fedora due to lxc utils bug

In the dind environment running on a Fedora host, the lxc utils get
confused by the /sys/fs/cgroup/cpuacct,cpu cgroup mount and lxc-start
fails trying to access the wrong cgroup directory.
Upstream-commit: 72d02ecdde2ba6f39739a0a942f2c4a057b4d45f
Component: engine
---
 components/engine/integration/container_test.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/components/engine/integration/container_test.go b/components/engine/integration/container_test.go
index 3658d9d4dc..b602488006 100644
--- a/components/engine/integration/container_test.go
+++ b/components/engine/integration/container_test.go
@@ -330,6 +330,11 @@ func TestCommitRun(t *testing.T) {
 }
 
 func TestStart(t *testing.T) {
+	_, err1 := os.Stat("/sys/fs/cgroup/cpuacct,cpu")
+	_, err2 := os.Stat("/sys/fs/cgroup/cpu,cpuacct")
+	if err1 == nil || err2 == nil {
+		t.Skip("Fixme. Setting cpu cgroup shares doesn't work in dind on a Fedora host.  The lxc utils are confused by the cpu,cpuacct mount.")
+	}
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 	container, _, _ := mkContainer(runtime, []string{"-m", "33554432", "-c", "1000", "-i", "_", "/bin/cat"}, t)

From 0c60a3c3a04a043e19532746281bc35168c6d6d1 Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Tue, 12 Nov 2013 14:16:51 -0600
Subject: [PATCH 142/184] test: 2 second timeout (not 2000) Upstream-commit:
 fe302fbfd26fc7db5d751d4bec8a0bd4ce6030a4 Component: engine

---
 components/engine/integration/commands_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/integration/commands_test.go b/components/engine/integration/commands_test.go
index ab186f4a2c..440d8e5469 100644
--- a/components/engine/integration/commands_test.go
+++ b/components/engine/integration/commands_test.go
@@ -329,7 +329,7 @@ func TestRunDisconnectTty(t *testing.T) {
 	// Client disconnect after run -i should keep stdin out in TTY mode
 	container := globalRuntime.List()[0]
 
-	setTimeout(t, "Read/Write assertion timed out", 2000*time.Second, func() {
+	setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
 		if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
 			t.Fatal(err)
 		}

From 4d58ddf15bc0e8c10493e55e64fc34e9de4440b5 Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Mon, 11 Nov 2013 21:58:40 -0600
Subject: [PATCH 143/184] fix container restart race condition

Finish container cleanup before setting the state to stopped.
Otherwise, for an application that exits quickly, a call to Restart
can allow Start to be called again before cleanup is done, resulting in
overritten data in the Container struct.
Upstream-commit: fc2f5758cf22fe5d3d46be7e4642abc0735e2c8d
Component: engine
---
 components/engine/container.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index 9dac345447..16f45cb490 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -1287,9 +1287,6 @@ func (container *Container) monitor() {
 		exitCode = container.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
 	}
 
-	// Report status back
-	container.State.setStopped(exitCode)
-
 	if container.runtime != nil && container.runtime.srv != nil {
 		container.runtime.srv.LogEvent("die", container.ID, container.runtime.repositories.ImageName(container.Image))
 	}
@@ -1302,6 +1299,9 @@ func (container *Container) monitor() {
 		container.stdin, container.stdinPipe = io.Pipe()
 	}
 
+	// Report status back
+	container.State.setStopped(exitCode)
+
 	// Release the lock
 	close(container.waitLock)
 

From 4070c845dc54becb50e60dc3da31b7270ebd08d9 Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Tue, 12 Nov 2013 09:06:54 -0600
Subject: [PATCH 144/184] don't forward SIGCHLD to container

It makes no sense to forward SIGCHLD to the container.
Upstream-commit: 440422a96346072a0a9016c4db78ff7599a702aa
Component: engine
---
 components/engine/commands.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index 710a311c08..d463a50a3d 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -549,6 +549,9 @@ func (cli *DockerCli) forwardAllSignals(cid string) chan os.Signal {
 	utils.CatchAll(sigc)
 	go func() {
 		for s := range sigc {
+			if s == syscall.SIGCHLD {
+				continue
+			}
 			if _, _, err := cli.call("POST", fmt.Sprintf("/containers/%s/kill?signal=%d", cid, s), nil); err != nil {
 				utils.Debugf("Error sending signal: %s", err)
 			}

From 6c91c910668596926226dfff514b26dfd544d07f Mon Sep 17 00:00:00 2001
From: Darren Coxall <darren@darrencoxall.com>
Date: Sun, 10 Nov 2013 21:50:34 +0000
Subject: [PATCH 145/184] More informative error message on name collisions

This is the proposed fix for #2506. It provides a more complete message
with regards to name collisions including informing of the opposing
containers ID.

I have included a test to ensure that the correct short id is displayed
to make the message easier to understand.
Upstream-commit: 3c67a2849337f3b9bd92dd389f0e02e48a36028b
Component: engine
---
 components/engine/AUTHORS                     |  1 +
 components/engine/integration/runtime_test.go | 12 ++++++++++++
 components/engine/runtime.go                  |  3 ++-
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/components/engine/AUTHORS b/components/engine/AUTHORS
index 214c87ce25..60533c1cc2 100644
--- a/components/engine/AUTHORS
+++ b/components/engine/AUTHORS
@@ -44,6 +44,7 @@ Daniel Nordberg <dnordberg@gmail.com>
 Daniel Robinson <gottagetmac@gmail.com>
 Daniel Von Fange <daniel@leancoder.com>
 Daniel YC Lin <dlin.tw@gmail.com>
+Darren Coxall <darren@darrencoxall.com>
 David Calavera <david.calavera@gmail.com>
 David Sissitka <me@dsissitka.com>
 Deni Bertovic <deni@kset.org>
diff --git a/components/engine/integration/runtime_test.go b/components/engine/integration/runtime_test.go
index fb928d8160..320a3645b0 100644
--- a/components/engine/integration/runtime_test.go
+++ b/components/engine/integration/runtime_test.go
@@ -231,6 +231,18 @@ func TestRuntimeCreate(t *testing.T) {
 		t.Errorf("Exists() returned false for a newly created container")
 	}
 
+	// Test that conflict error displays correct details
+	testContainer, _, _ := runtime.Create(
+		&docker.Config{
+			Image: GetTestImage(runtime).ID,
+			Cmd:   []string{"ls", "-al"},
+		},
+		"conflictname",
+	)
+	if _, _, err := runtime.Create(&docker.Config{Image: GetTestImage(runtime).ID, Cmd: []string{"ls", "-al"}}, testContainer.Name); err == nil || !strings.Contains(err.Error(), utils.TruncateID(testContainer.ID)) {
+		t.Fatalf("Name conflict error doesn't include the correct short id. Message was: %s", err.Error())
+	}
+
 	// Make sure create with bad parameters returns an error
 	if _, _, err = runtime.Create(&docker.Config{Image: GetTestImage(runtime).ID}, ""); err == nil {
 		t.Fatal("Builder.Create should throw an error when Cmd is missing")
diff --git a/components/engine/runtime.go b/components/engine/runtime.go
index 4559164e28..f8c15767d7 100644
--- a/components/engine/runtime.go
+++ b/components/engine/runtime.go
@@ -402,7 +402,8 @@ func (runtime *Runtime) Create(config *Config, name string) (*Container, []strin
 	// Set the enitity in the graph using the default name specified
 	if _, err := runtime.containerGraph.Set(name, id); err != nil {
 		if strings.HasSuffix(err.Error(), "name are not unique") {
-			return nil, nil, fmt.Errorf("Conflict, %s already exists.", name)
+			conflictingContainer, _ := runtime.GetByName(name)
+			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.", name, utils.TruncateID(conflictingContainer.ID), name)
 		}
 		return nil, nil, err
 	}

From e0cb0011ff8a5a370e94c37ddd3ab6c9133ceb9d Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Mon, 18 Nov 2013 11:25:13 -0800
Subject: [PATCH 146/184] gofmt_test Upstream-commit:
 ed8f75d25ca0fb46d8c06bfe74bbc386bf4e8a8f Component: engine

---
 components/engine/api_unit_tests.go         |   1 -
 components/engine/integration/api_test.go   | 313 ++++++++++----------
 components/engine/integration/auth_test.go  |   4 +-
 components/engine/integration/utils_test.go |   8 +-
 4 files changed, 158 insertions(+), 168 deletions(-)

diff --git a/components/engine/api_unit_tests.go b/components/engine/api_unit_tests.go
index 36996c6adf..82095bd8b5 100644
--- a/components/engine/api_unit_tests.go
+++ b/components/engine/api_unit_tests.go
@@ -17,4 +17,3 @@ func TestJsonContentType(t *testing.T) {
 		t.Fail()
 	}
 }
-
diff --git a/components/engine/integration/api_test.go b/components/engine/integration/api_test.go
index 0f49bf897b..a66cbe561f 100644
--- a/components/engine/integration/api_test.go
+++ b/components/engine/integration/api_test.go
@@ -17,7 +17,6 @@ import (
 	"time"
 )
 
-
 func TestGetVersion(t *testing.T) {
 	eng := NewTestEngine(t)
 	defer mkRuntimeFromEngine(eng, t).Nuke()
@@ -45,7 +44,6 @@ func TestGetVersion(t *testing.T) {
 	}
 }
 
-
 func TestGetInfo(t *testing.T) {
 	eng := NewTestEngine(t)
 	defer mkRuntimeFromEngine(eng, t).Nuke()
@@ -65,7 +63,7 @@ func TestGetInfo(t *testing.T) {
 	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 		t.Fatal(err)
 	}
-        assertHttpNotError(r, t)
+	assertHttpNotError(r, t)
 
 	infos := &docker.APIInfo{}
 	err = json.Unmarshal(r.Body.Bytes(), infos)
@@ -145,7 +143,7 @@ func TestGetImagesJSON(t *testing.T) {
 	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 		t.Fatal(err)
 	}
-        assertHttpNotError(r, t)
+	assertHttpNotError(r, t)
 
 	images := []docker.APIImages{}
 	if err := json.Unmarshal(r.Body.Bytes(), &images); err != nil {
@@ -183,8 +181,7 @@ func TestGetImagesJSON(t *testing.T) {
 	if err := docker.ServeRequest(srv, docker.APIVERSION, r2, req2); err != nil {
 		t.Fatal(err)
 	}
-        assertHttpNotError(r2, t)
-
+	assertHttpNotError(r2, t)
 
 	images2 := []docker.APIImages{}
 	if err := json.Unmarshal(r2.Body.Bytes(), &images2); err != nil {
@@ -214,10 +211,10 @@ func TestGetImagesJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r3, req3); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r3, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r3, req3); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r3, t)
 
 	images3 := []docker.APIImages{}
 	if err := json.Unmarshal(r3.Body.Bytes(), &images3); err != nil {
@@ -259,7 +256,7 @@ func TestGetImagesHistory(t *testing.T) {
 	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 		t.Fatal(err)
 	}
-        assertHttpNotError(r, t)
+	assertHttpNotError(r, t)
 
 	history := []docker.APIHistory{}
 	if err := json.Unmarshal(r.Body.Bytes(), &history); err != nil {
@@ -271,20 +268,20 @@ func TestGetImagesHistory(t *testing.T) {
 }
 
 func TestGetImagesByName(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	req, err := http.NewRequest("GET", "/images/"+unitTestImageName+"/json", nil)
 	if err != nil {
-	    t.Fatal(err)
+		t.Fatal(err)
 	}
 
 	r := httptest.NewRecorder()
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 
 	img := &docker.Image{}
 	if err := json.Unmarshal(r.Body.Bytes(), img); err != nil {
@@ -296,13 +293,13 @@ func TestGetImagesByName(t *testing.T) {
 }
 
 func TestGetContainersJSON(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	beginLen := len(srv.Containers(true, false, -1, "", ""))
 
-        containerID := createTestContainer(eng, &docker.Config{
+	containerID := createTestContainer(eng, &docker.Config{
 		Image: unitTestImageID,
 		Cmd:   []string{"echo", "test"},
 	}, t)
@@ -313,10 +310,10 @@ func TestGetContainersJSON(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	containers := []docker.APIContainers{}
 	if err := json.Unmarshal(r.Body.Bytes(), &containers); err != nil {
 		t.Fatal(err)
@@ -330,12 +327,12 @@ func TestGetContainersJSON(t *testing.T) {
 }
 
 func TestGetContainersExport(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	// Create a container and remove a file
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image: unitTestImageID,
 			Cmd:   []string{"touch", "/test"},
@@ -346,14 +343,14 @@ func TestGetContainersExport(t *testing.T) {
 
 	r := httptest.NewRecorder()
 
-	req, err := http.NewRequest("GET", "/containers/" + containerID + "/export", nil)
+	req, err := http.NewRequest("GET", "/containers/"+containerID+"/export", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 
 	if r.Code != http.StatusOK {
 		t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code)
@@ -379,29 +376,29 @@ func TestGetContainersExport(t *testing.T) {
 }
 
 func TestGetContainersChanges(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	// Create a container and remove a file
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image: unitTestImageID,
 			Cmd:   []string{"/bin/rm", "/etc/passwd"},
 		},
 		t,
 	)
-        containerRun(eng, containerID, t)
+	containerRun(eng, containerID, t)
 
 	r := httptest.NewRecorder()
 	req, err := http.NewRequest("GET", "/containers/"+containerID+"/changes", nil)
 	if err != nil {
-	    t.Fatal(err)
+		t.Fatal(err)
 	}
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	changes := []docker.Change{}
 	if err := json.Unmarshal(r.Body.Bytes(), &changes); err != nil {
 		t.Fatal(err)
@@ -421,11 +418,11 @@ func TestGetContainersChanges(t *testing.T) {
 
 func TestGetContainersTop(t *testing.T) {
 	t.Skip("Fixme. Skipping test for now. Reported error when testing using dind: 'api_test.go:527: Expected 2 processes, found 0.'")
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/sh", "-c", "cat"},
@@ -467,10 +464,10 @@ func TestGetContainersTop(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	procs := docker.APITop{}
 	if err := json.Unmarshal(r.Body.Bytes(), &procs); err != nil {
 		t.Fatal(err)
@@ -495,12 +492,12 @@ func TestGetContainersTop(t *testing.T) {
 }
 
 func TestGetContainersByName(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	// Create a container and remove a file
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image: unitTestImageID,
 			Cmd:   []string{"echo", "test"},
@@ -511,12 +508,12 @@ func TestGetContainersByName(t *testing.T) {
 	r := httptest.NewRecorder()
 	req, err := http.NewRequest("GET", "/containers/"+containerID+"/json", nil)
 	if err != nil {
-	    t.Fatal(err)
+		t.Fatal(err)
 	}
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	outContainer := &docker.Container{}
 	if err := json.Unmarshal(r.Body.Bytes(), outContainer); err != nil {
 		t.Fatal(err)
@@ -527,12 +524,12 @@ func TestGetContainersByName(t *testing.T) {
 }
 
 func TestPostCommit(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	// Create a container and remove a file
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image: unitTestImageID,
 			Cmd:   []string{"touch", "/test"},
@@ -540,7 +537,7 @@ func TestPostCommit(t *testing.T) {
 		t,
 	)
 
-        containerRun(eng, containerID, t)
+	containerRun(eng, containerID, t)
 
 	req, err := http.NewRequest("POST", "/commit?repo=testrepo&testtag=tag&container="+containerID, bytes.NewReader([]byte{}))
 	if err != nil {
@@ -548,10 +545,10 @@ func TestPostCommit(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	if r.Code != http.StatusCreated {
 		t.Fatalf("%d Created expected, received %d\n", http.StatusCreated, r.Code)
 	}
@@ -585,10 +582,10 @@ func TestPostContainersCreate(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	if r.Code != http.StatusCreated {
 		t.Fatalf("%d Created expected, received %d\n", http.StatusCreated, r.Code)
 	}
@@ -600,7 +597,7 @@ func TestPostContainersCreate(t *testing.T) {
 	containerID := apiRun.ID
 
 	containerAssertExists(eng, containerID, t)
-        containerRun(eng, containerID, t)
+	containerRun(eng, containerID, t)
 
 	if !containerFileExists(eng, containerID, "test", t) {
 		t.Fatal("Test file was not created")
@@ -608,11 +605,11 @@ func TestPostContainersCreate(t *testing.T) {
 }
 
 func TestPostContainersKill(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/cat"},
@@ -621,7 +618,7 @@ func TestPostContainersKill(t *testing.T) {
 		t,
 	)
 
-        startContainer(eng, containerID, t)
+	startContainer(eng, containerID, t)
 
 	// Give some time to the process to start
 	containerWaitTimeout(eng, containerID, t)
@@ -633,12 +630,12 @@ func TestPostContainersKill(t *testing.T) {
 	r := httptest.NewRecorder()
 	req, err := http.NewRequest("POST", "/containers/"+containerID+"/kill", bytes.NewReader([]byte{}))
 	if err != nil {
-	    t.Fatal(err)
+		t.Fatal(err)
 	}
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
@@ -648,11 +645,11 @@ func TestPostContainersKill(t *testing.T) {
 }
 
 func TestPostContainersRestart(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/top"},
@@ -661,7 +658,7 @@ func TestPostContainersRestart(t *testing.T) {
 		t,
 	)
 
-        startContainer(eng, containerID, t)
+	startContainer(eng, containerID, t)
 
 	// Give some time to the process to start
 	containerWaitTimeout(eng, containerID, t)
@@ -675,10 +672,10 @@ func TestPostContainersRestart(t *testing.T) {
 		t.Fatal(err)
 	}
 	r := httptest.NewRecorder()
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
@@ -690,7 +687,7 @@ func TestPostContainersRestart(t *testing.T) {
 		t.Fatalf("Container should be running")
 	}
 
-        containerKill(eng, containerID, t)
+	containerKill(eng, containerID, t)
 }
 
 func TestPostContainersStart(t *testing.T) {
@@ -718,10 +715,10 @@ func TestPostContainersStart(t *testing.T) {
 	req.Header.Set("Content-Type", "application/json")
 
 	r := httptest.NewRecorder()
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
@@ -743,15 +740,15 @@ func TestPostContainersStart(t *testing.T) {
 	// which causes this to return 404 even though the container exists.
 	assertHttpError(r, t)
 	containerAssertExists(eng, containerID, t)
-        containerKill(eng, containerID, t)
+	containerKill(eng, containerID, t)
 }
 
 func TestPostContainersStop(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/top"},
@@ -760,7 +757,7 @@ func TestPostContainersStop(t *testing.T) {
 		t,
 	)
 
-        startContainer(eng, containerID, t)
+	startContainer(eng, containerID, t)
 
 	// Give some time to the process to start
 	containerWaitTimeout(eng, containerID, t)
@@ -775,10 +772,10 @@ func TestPostContainersStop(t *testing.T) {
 		t.Fatal(err)
 	}
 	r := httptest.NewRecorder()
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
@@ -788,11 +785,11 @@ func TestPostContainersStop(t *testing.T) {
 }
 
 func TestPostContainersWait(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/sleep", "1"},
@@ -800,18 +797,18 @@ func TestPostContainersWait(t *testing.T) {
 		},
 		t,
 	)
-        startContainer(eng, containerID, t)
+	startContainer(eng, containerID, t)
 
 	setTimeout(t, "Wait timed out", 3*time.Second, func() {
 		r := httptest.NewRecorder()
 		req, err := http.NewRequest("POST", "/containers/"+containerID+"/wait", bytes.NewReader([]byte{}))
 		if err != nil {
-		    t.Fatal(err)
+			t.Fatal(err)
 		}
 		if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-		    t.Fatal(err)
+			t.Fatal(err)
 		}
-        assertHttpNotError(r, t)
+		assertHttpNotError(r, t)
 		apiWait := &docker.APIWait{}
 		if err := json.Unmarshal(r.Body.Bytes(), apiWait); err != nil {
 			t.Fatal(err)
@@ -827,11 +824,11 @@ func TestPostContainersWait(t *testing.T) {
 }
 
 func TestPostContainersAttach(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/cat"},
@@ -840,7 +837,7 @@ func TestPostContainersAttach(t *testing.T) {
 		t,
 	)
 	// Start the process
-        startContainer(eng, containerID, t)
+	startContainer(eng, containerID, t)
 
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
@@ -868,9 +865,9 @@ func TestPostContainersAttach(t *testing.T) {
 		}
 
 		if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-		    t.Fatal(err)
+			t.Fatal(err)
 		}
-        assertHttpNotError(r.ResponseRecorder, t)
+		assertHttpNotError(r.ResponseRecorder, t)
 	}()
 
 	// Acknowledge hijack
@@ -906,11 +903,11 @@ func TestPostContainersAttach(t *testing.T) {
 }
 
 func TestPostContainersAttachStderr(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image:     unitTestImageID,
 			Cmd:       []string{"/bin/sh", "-c", "/bin/cat >&2"},
@@ -919,7 +916,7 @@ func TestPostContainersAttachStderr(t *testing.T) {
 		t,
 	)
 	// Start the process
-        startContainer(eng, containerID, t)
+	startContainer(eng, containerID, t)
 
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
@@ -949,7 +946,7 @@ func TestPostContainersAttachStderr(t *testing.T) {
 		if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 			t.Fatal(err)
 		}
-        assertHttpNotError(r.ResponseRecorder, t)
+		assertHttpNotError(r.ResponseRecorder, t)
 	}()
 
 	// Acknowledge hijack
@@ -988,11 +985,11 @@ func TestPostContainersAttachStderr(t *testing.T) {
 // FIXME: Test deleting container with volume
 // FIXME: Test deleting volume in use by other container
 func TestDeleteContainers(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image: unitTestImageID,
 			Cmd:   []string{"touch", "/test"},
@@ -1004,10 +1001,10 @@ func TestDeleteContainers(t *testing.T) {
 		t.Fatal(err)
 	}
 	r := httptest.NewRecorder()
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r, t)
 	if r.Code != http.StatusNoContent {
 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)
 	}
@@ -1026,7 +1023,7 @@ func TestOptionsRoute(t *testing.T) {
 	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 		t.Fatal(err)
 	}
-        assertHttpNotError(r, t)
+	assertHttpNotError(r, t)
 	if r.Code != http.StatusOK {
 		t.Errorf("Expected response for OPTIONS request to be \"200\", %v found.", r.Code)
 	}
@@ -1045,7 +1042,7 @@ func TestGetEnabledCors(t *testing.T) {
 	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 		t.Fatal(err)
 	}
-        assertHttpNotError(r, t)
+	assertHttpNotError(r, t)
 	if r.Code != http.StatusOK {
 		t.Errorf("Expected response for OPTIONS request to be \"200\", %v found.", r.Code)
 	}
@@ -1066,9 +1063,9 @@ func TestGetEnabledCors(t *testing.T) {
 }
 
 func TestDeleteImages(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	initialImages, err := srv.Images(false, "")
 	if err != nil {
@@ -1093,9 +1090,9 @@ func TestDeleteImages(t *testing.T) {
 	}
 
 	r := httptest.NewRecorder()
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
-            t.Fatal(err)
-        }
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
+		t.Fatal(err)
+	}
 	if r.Code != http.StatusConflict {
 		t.Fatalf("Expected http status 409-conflict, got %v", r.Code)
 	}
@@ -1106,10 +1103,10 @@ func TestDeleteImages(t *testing.T) {
 	}
 
 	r2 := httptest.NewRecorder()
-        if err := docker.ServeRequest(srv, docker.APIVERSION, r2, req2); err != nil {
-            t.Fatal(err)
-        }
-        assertHttpNotError(r2, t)
+	if err := docker.ServeRequest(srv, docker.APIVERSION, r2, req2); err != nil {
+		t.Fatal(err)
+	}
+	assertHttpNotError(r2, t)
 	if r2.Code != http.StatusOK {
 		t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code)
 	}
@@ -1132,19 +1129,19 @@ func TestDeleteImages(t *testing.T) {
 }
 
 func TestPostContainersCopy(t *testing.T) {
-        eng := NewTestEngine(t)
-        defer mkRuntimeFromEngine(eng, t).Nuke()
-        srv := mkServerFromEngine(eng, t)
+	eng := NewTestEngine(t)
+	defer mkRuntimeFromEngine(eng, t).Nuke()
+	srv := mkServerFromEngine(eng, t)
 
 	// Create a container and remove a file
-        containerID := createTestContainer(eng,
+	containerID := createTestContainer(eng,
 		&docker.Config{
 			Image: unitTestImageID,
 			Cmd:   []string{"touch", "/test.txt"},
 		},
 		t,
 	)
-        containerRun(eng, containerID, t)
+	containerRun(eng, containerID, t)
 
 	r := httptest.NewRecorder()
 	copyData := docker.APICopy{HostPath: ".", Resource: "/test.txt"}
@@ -1162,7 +1159,7 @@ func TestPostContainersCopy(t *testing.T) {
 	if err := docker.ServeRequest(srv, docker.APIVERSION, r, req); err != nil {
 		t.Fatal(err)
 	}
-        assertHttpNotError(r, t)
+	assertHttpNotError(r, t)
 
 	if r.Code != http.StatusOK {
 		t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code)
diff --git a/components/engine/integration/auth_test.go b/components/engine/integration/auth_test.go
index dfeb9002bf..07559c01cf 100644
--- a/components/engine/integration/auth_test.go
+++ b/components/engine/integration/auth_test.go
@@ -1,9 +1,9 @@
 package docker
 
 import (
-	"github.com/dotcloud/docker/auth"
 	"crypto/rand"
 	"encoding/hex"
+	"github.com/dotcloud/docker/auth"
 	"os"
 	"strings"
 	"testing"
@@ -27,8 +27,6 @@ func TestLogin(t *testing.T) {
 	}
 }
 
-
-
 func TestCreateAccount(t *testing.T) {
 	os.Setenv("DOCKER_INDEX_URL", "https://indexstaging-docker.dotcloud.com")
 	defer os.Setenv("DOCKER_INDEX_URL", "")
diff --git a/components/engine/integration/utils_test.go b/components/engine/integration/utils_test.go
index 7a46bed16c..278924edb7 100644
--- a/components/engine/integration/utils_test.go
+++ b/components/engine/integration/utils_test.go
@@ -3,10 +3,10 @@ package docker
 import (
 	"archive/tar"
 	"bytes"
+	"fmt"
 	"github.com/dotcloud/docker"
 	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/utils"
-	"fmt"
 	"io"
 	"io/ioutil"
 	"net/http"
@@ -64,7 +64,6 @@ func startContainer(eng *engine.Engine, id string, t utils.Fataler) {
 	}
 }
 
-
 func containerRun(eng *engine.Engine, id string, t utils.Fataler) {
 	startContainer(eng, id, t)
 	containerWait(eng, id, t)
@@ -97,12 +96,10 @@ func containerAttach(eng *engine.Engine, id string, t utils.Fataler) (io.WriteCl
 	return i, o
 }
 
-
 func containerWait(eng *engine.Engine, id string, t utils.Fataler) int {
 	return getContainer(eng, id, t).Wait()
 }
 
-
 func containerWaitTimeout(eng *engine.Engine, id string, t utils.Fataler) error {
 	return getContainer(eng, id, t).WaitTimeout(500 * time.Millisecond)
 }
@@ -137,7 +134,6 @@ func assertHttpNotError(r *httptest.ResponseRecorder, t utils.Fataler) {
 	}
 }
 
-
 // assertHttpError expect the given response to have an error.
 // Otherwise the it causes the test to fail.
 func assertHttpError(r *httptest.ResponseRecorder, t utils.Fataler) {
@@ -150,7 +146,7 @@ func assertHttpError(r *httptest.ResponseRecorder, t utils.Fataler) {
 func getContainer(eng *engine.Engine, id string, t utils.Fataler) *docker.Container {
 	runtime := mkRuntimeFromEngine(eng, t)
 	c := runtime.Get(id)
-	if c == nil  {
+	if c == nil {
 		t.Fatal(fmt.Errorf("No such container: %s", id))
 	}
 	return c

From ef3400502cdcaa9709392e38d42131a203a29564 Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Tue, 12 Nov 2013 10:21:02 -0600
Subject: [PATCH 147/184] test: fix TestRmi race condition Upstream-commit:
 fef41ef7bf83ed04c7df8e0247e60c0d495eefdc Component: engine

---
 components/engine/integration/server_test.go | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/components/engine/integration/server_test.go b/components/engine/integration/server_test.go
index 8cd3e30fdf..494e23fef3 100644
--- a/components/engine/integration/server_test.go
+++ b/components/engine/integration/server_test.go
@@ -256,6 +256,10 @@ func TestRmi(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	if _, err := srv.ContainerWait(containerID); err != nil {
+		t.Fatal(err)
+	}
+
 	imageID, err := srv.ContainerCommit(containerID, "test", "", "", "", nil)
 	if err != nil {
 		t.Fatal(err)
@@ -277,6 +281,10 @@ func TestRmi(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	if _, err := srv.ContainerWait(containerID); err != nil {
+		t.Fatal(err)
+	}
+
 	_, err = srv.ContainerCommit(containerID, "test", "", "", "", nil)
 	if err != nil {
 		t.Fatal(err)

From c4cad6571f72603b5b68a7326c3db0082301265c Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Fri, 8 Nov 2013 11:08:18 -0600
Subject: [PATCH 148/184] test: remove extra args in TestExitCode

The extra blank argument isn't needed and confuses libvirt.
Upstream-commit: 4b80ec9aae2f43e831de64f3746c7838252e9203
Component: engine
---
 components/engine/integration/container_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/components/engine/integration/container_test.go b/components/engine/integration/container_test.go
index b602488006..a8c21ef1ea 100644
--- a/components/engine/integration/container_test.go
+++ b/components/engine/integration/container_test.go
@@ -568,7 +568,7 @@ func TestExitCode(t *testing.T) {
 
 	trueContainer, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
-		Cmd:   []string{"/bin/true", ""},
+		Cmd:   []string{"/bin/true"},
 	}, "")
 	if err != nil {
 		t.Fatal(err)
@@ -583,7 +583,7 @@ func TestExitCode(t *testing.T) {
 
 	falseContainer, _, err := runtime.Create(&docker.Config{
 		Image: GetTestImage(runtime).ID,
-		Cmd:   []string{"/bin/false", ""},
+		Cmd:   []string{"/bin/false"},
 	}, "")
 	if err != nil {
 		t.Fatal(err)

From 814f2e1b4e3470888282b1a67a5578d2f63b8fcf Mon Sep 17 00:00:00 2001
From: Andy Rothfusz <github@metaliveblog.com>
Date: Fri, 15 Nov 2013 16:40:13 -0800
Subject: [PATCH 149/184] Fixes #2702. Also cleans up formatting and long lines
 in volumes doc. Upstream-commit: 2ae1f29dfe6fea26d2e0ac29faa2375a5db2c2d9
 Component: engine

---
 .../engine/docs/sources/commandline/cli.rst   |  7 ++++
 .../docs/sources/use/working_with_volumes.rst | 42 +++++++++++++------
 2 files changed, 36 insertions(+), 13 deletions(-)

diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 331311ffca..d0a8d83c0c 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -845,6 +845,13 @@ id may be optionally suffixed with ``:ro`` or ``:rw`` to mount the volumes in
 read-only or read-write mode, respectively. By default, the volumes are mounted
 in the same mode (rw or ro) as the reference container.
 
+Known Issues (run -volumes-from)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+* :issue:`2702`: "lxc-start: Permission denied - failed to mount"
+  could indicate a permissions problem with AppArmor. Please see the
+  issue for a workaround.
+
 .. _cli_search:
 
 ``search``
diff --git a/components/engine/docs/sources/use/working_with_volumes.rst b/components/engine/docs/sources/use/working_with_volumes.rst
index 3a06685e54..9156e574d0 100644
--- a/components/engine/docs/sources/use/working_with_volumes.rst
+++ b/components/engine/docs/sources/use/working_with_volumes.rst
@@ -30,44 +30,60 @@ Each container can have zero or more data volumes.
 Getting Started
 ...............
 
-
-
-Using data volumes is as simple as adding a new flag: ``-v``. The parameter ``-v`` can be used more than once in order to create more volumes within the new container. The example below shows the instruction to create a container with two new volumes::
+Using data volumes is as simple as adding a new flag: ``-v``. The
+parameter ``-v`` can be used more than once in order to create more
+volumes within the new container. The example below shows the
+instruction to create a container with two new volumes::
 
   docker run -v /var/volume1 -v /var/volume2 shykes/couchdb
 
-For a Dockerfile, the VOLUME instruction will add one or more new volumes to any container created from the image::
+For a Dockerfile, the VOLUME instruction will add one or more new
+volumes to any container created from the image::
 
   VOLUME ["/var/volume1", "/var/volume2"]
 
 
-Create a new container using existing volumes from an existing container:
----------------------------------------------------------------------------
+Mount Volumes from an Existing Container:
+-----------------------------------------
 
-
-The command below creates a new container which is running as daemon ``-d`` and with one volume ``/var/lib/couchdb``::
+The command below creates a new container which is runnning as daemon
+``-d`` and with one volume ``/var/lib/couchdb``::
 
   COUCH1=$(sudo docker run -d -v /var/lib/couchdb shykes/couchdb:2013-05-03)
 
-From the container id of that previous container ``$COUCH1`` it's possible to create new container sharing the same volume using the parameter ``-volumes-from container_id``::
+From the container id of that previous container ``$COUCH1`` it's
+possible to create new container sharing the same volume using the
+parameter ``-volumes-from container_id``::
 
   COUCH2=$(sudo docker run -d -volumes-from $COUCH1 shykes/couchdb:2013-05-03)
 
 Now, the second container has the all the information from the first volume.
 
 
-Create a new container which mounts a host directory into it:
--------------------------------------------------------------
+Mount a Host Directory as a Container Volume:
+---------------------------------------------
+
+::
 
   -v=[]: Create a bind mount with: [host-dir]:[container-dir]:[rw|ro].
   If "host-dir" is missing, then docker creates a new volume.
 
-  This is not available for a Dockerfile due the portability and sharing purpose of it. The [host-dir] volumes is something    100% host dependent and will break on any other machine.
+This is not available for a Dockerfile due the portability and sharing
+purpose of it. The [host-dir] volumes is something 100% host dependent
+and will break on any other machine.
 
 For example::
 
   sudo docker run -v /var/logs:/var/host_logs:ro shykes/couchdb:2013-05-03
 
-The command above mounts the host directory ``/var/logs`` into the container with read only permissions as ``/var/host_logs``.
+The command above mounts the host directory ``/var/logs`` into the
+container with read only permissions as ``/var/host_logs``.
 
 .. versionadded:: v0.5.0
+
+Known Issues
+............
+
+* :issue:`2702`: "lxc-start: Permission denied - failed to mount"
+  could indicate a permissions problem with AppArmor. Please see the
+  issue for a workaround.

From 5a2e995ad54895f34f80b4b82b7df2208b1db54c Mon Sep 17 00:00:00 2001
From: Ryan Seto <ryanseto@yak.net>
Date: Mon, 18 Nov 2013 16:21:03 -0500
Subject: [PATCH 150/184] Simplify the upstart example in host_integration.rst

Taking some pointers from @tianon on my pull request #2685.
Upstream-commit: 76ee860ece15f8a7738c503fdd73f124f0ef1f4b
Component: engine
---
 .../docs/sources/use/host_integration.rst     | 19 ++++---------------
 1 file changed, 4 insertions(+), 15 deletions(-)

diff --git a/components/engine/docs/sources/use/host_integration.rst b/components/engine/docs/sources/use/host_integration.rst
index b51b2efcfe..bef996a71e 100644
--- a/components/engine/docs/sources/use/host_integration.rst
+++ b/components/engine/docs/sources/use/host_integration.rst
@@ -37,7 +37,7 @@ named ``/etc/init/redis.conf`` and place the following into it:
 
    description "Redis container"
    author "Me"
-   start on filesystem and started lxc-net and started docker
+   start on filesystem and started docker
    stop on runlevel [!2345]
    respawn
    script
@@ -49,23 +49,12 @@ named ``/etc/init/redis.conf`` and place the following into it:
      /usr/bin/docker start -a 0a7e070b698b
    end script
 
-Next, we have to edit the docker upstart script (``/etc/init/docker.conf``)
-so that we run docker with ``-r=false``.  In this example, we also ensure
-that docker will start running before *redis* is started.
+Next, we have to configure docker so that it's run with the option ``-r=false``.
+Run the following command:
 
 .. code-block:: bash
 
-   description "Docker daemon"
-
-   start on filesystem and started lxc-net
-   start on (starting redis)
-   stop on runlevel [!2345]
-
-   respawn
-
-   script
-   	/usr/bin/docker -d -r=false
-   end script
+   $ sudo sh -c 'echo DOCKER_OPTS="-r=false" > /etc/default/docker'
 
 
 Sample systemd Script

From 6e0c243c2e797a9bcd268dfccb8ccbd5738183e9 Mon Sep 17 00:00:00 2001
From: "Guillaume J. Charmes" <charmes.guillaume@gmail.com>
Date: Mon, 18 Nov 2013 15:35:56 -0800
Subject: [PATCH 151/184] Lintify code with confidence=1 Upstream-commit:
 5e941f1ca035bb1ec014c18d277aecaa41deba85 Component: engine

---
 components/engine/api.go             |  28 +--
 components/engine/api_params.go      | 276 +++++++++++++--------------
 components/engine/archive/archive.go |   9 +-
 components/engine/auth/auth.go       |   5 +-
 components/engine/commands.go        |   7 +-
 components/engine/graph.go           |   7 +-
 components/engine/image.go           |  49 ++---
 components/engine/runtime.go         |   2 +-
 components/engine/server.go          |  18 +-
 components/engine/utils/http.go      |  22 +--
 components/engine/utils/utils.go     |  12 +-
 11 files changed, 213 insertions(+), 222 deletions(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index dbaa2ae7de..d9c1aa3f32 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -149,13 +149,12 @@ func postContainersKill(srv *Server, version float64, w http.ResponseWriter, r *
 
 	signal := 0
 	if r != nil {
-		s := r.Form.Get("signal")
-		if s != "" {
-			if s, err := strconv.Atoi(s); err != nil {
+		if s := r.Form.Get("signal"); s != "" {
+			s, err := strconv.Atoi(s)
+			if err != nil {
 				return err
-			} else {
-				signal = s
 			}
+			signal = s
 		}
 	}
 	if err := srv.ContainerKill(name, signal); err != nil {
@@ -201,9 +200,8 @@ func getImagesJSON(srv *Server, version float64, w http.ResponseWriter, r *http.
 		}
 
 		return writeJSON(w, http.StatusOK, outs2)
-	} else {
-		return writeJSON(w, http.StatusOK, outs)
 	}
+	return writeJSON(w, http.StatusOK, outs)
 }
 
 func getImagesViz(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -316,13 +314,10 @@ func getContainersTop(srv *Server, version float64, w http.ResponseWriter, r *ht
 	if err := parseForm(r); err != nil {
 		return err
 	}
-	name := vars["name"]
-	ps_args := r.Form.Get("ps_args")
-	procsStr, err := srv.ContainerTop(name, ps_args)
+	procsStr, err := srv.ContainerTop(vars["name"], r.Form.Get("ps_args"))
 	if err != nil {
 		return err
 	}
-
 	return writeJSON(w, http.StatusOK, procsStr)
 }
 
@@ -350,13 +345,12 @@ func getContainersJSON(srv *Server, version float64, w http.ResponseWriter, r *h
 	if version < 1.5 {
 		outs2 := []APIContainersOld{}
 		for _, ctnr := range outs {
-			outs2 = append(outs2, ctnr.ToLegacy())
+			outs2 = append(outs2, *ctnr.ToLegacy())
 		}
 
 		return writeJSON(w, http.StatusOK, outs2)
-	} else {
-		return writeJSON(w, http.StatusOK, outs)
 	}
+	return writeJSON(w, http.StatusOK, outs)
 }
 
 func postImagesTag(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -640,12 +634,10 @@ func deleteImages(srv *Server, version float64, w http.ResponseWriter, r *http.R
 	if imgs != nil {
 		if len(imgs) != 0 {
 			return writeJSON(w, http.StatusOK, imgs)
-		} else {
-			return fmt.Errorf("Conflict, %s wasn't deleted", name)
 		}
-	} else {
-		w.WriteHeader(http.StatusNoContent)
+		return fmt.Errorf("Conflict, %s wasn't deleted", name)
 	}
+	w.WriteHeader(http.StatusNoContent)
 	return nil
 }
 
diff --git a/components/engine/api_params.go b/components/engine/api_params.go
index e4508542ef..d3dfa1fb01 100644
--- a/components/engine/api_params.go
+++ b/components/engine/api_params.go
@@ -2,149 +2,147 @@ package docker
 
 import "strings"
 
-type APIHistory struct {
-	ID        string   `json:"Id"`
-	Tags      []string `json:",omitempty"`
-	Created   int64
-	CreatedBy string `json:",omitempty"`
-	Size      int64
-}
-
-type APIImages struct {
-	ID          string   `json:"Id"`
-	RepoTags    []string `json:",omitempty"`
-	Created     int64
-	Size        int64
-	VirtualSize int64
-	ParentId    string `json:",omitempty"`
-}
-
-type APIImagesOld struct {
-	Repository  string `json:",omitempty"`
-	Tag         string `json:",omitempty"`
-	ID          string `json:"Id"`
-	Created     int64
-	Size        int64
-	VirtualSize int64
-}
-
-func (self *APIImages) ToLegacy() []APIImagesOld {
-
-	outs := []APIImagesOld{}
-	for _, repotag := range self.RepoTags {
-
-		components := strings.SplitN(repotag, ":", 2)
-
-		outs = append(outs, APIImagesOld{
-			ID:          self.ID,
-			Repository:  components[0],
-			Tag:         components[1],
-			Created:     self.Created,
-			Size:        self.Size,
-			VirtualSize: self.VirtualSize,
-		})
+type (
+	APIHistory struct {
+		ID        string   `json:"Id"`
+		Tags      []string `json:",omitempty"`
+		Created   int64
+		CreatedBy string `json:",omitempty"`
+		Size      int64
 	}
 
+	APIImages struct {
+		ID          string   `json:"Id"`
+		RepoTags    []string `json:",omitempty"`
+		Created     int64
+		Size        int64
+		VirtualSize int64
+		ParentId    string `json:",omitempty"`
+	}
+
+	APIImagesOld struct {
+		Repository  string `json:",omitempty"`
+		Tag         string `json:",omitempty"`
+		ID          string `json:"Id"`
+		Created     int64
+		Size        int64
+		VirtualSize int64
+	}
+
+	APIInfo struct {
+		Debug              bool
+		Containers         int
+		Images             int
+		NFd                int    `json:",omitempty"`
+		NGoroutines        int    `json:",omitempty"`
+		MemoryLimit        bool   `json:",omitempty"`
+		SwapLimit          bool   `json:",omitempty"`
+		IPv4Forwarding     bool   `json:",omitempty"`
+		LXCVersion         string `json:",omitempty"`
+		NEventsListener    int    `json:",omitempty"`
+		KernelVersion      string `json:",omitempty"`
+		IndexServerAddress string `json:",omitempty"`
+	}
+
+	APITop struct {
+		Titles    []string
+		Processes [][]string
+	}
+
+	APIRmi struct {
+		Deleted  string `json:",omitempty"`
+		Untagged string `json:",omitempty"`
+	}
+
+	APIContainers struct {
+		ID         string `json:"Id"`
+		Image      string
+		Command    string
+		Created    int64
+		Status     string
+		Ports      []APIPort
+		SizeRw     int64
+		SizeRootFs int64
+		Names      []string
+	}
+
+	APIContainersOld struct {
+		ID         string `json:"Id"`
+		Image      string
+		Command    string
+		Created    int64
+		Status     string
+		Ports      string
+		SizeRw     int64
+		SizeRootFs int64
+	}
+
+	APIID struct {
+		ID string `json:"Id"`
+	}
+
+	APIRun struct {
+		ID       string   `json:"Id"`
+		Warnings []string `json:",omitempty"`
+	}
+
+	APIPort struct {
+		PrivatePort int64
+		PublicPort  int64
+		Type        string
+		IP          string
+	}
+
+	APIVersion struct {
+		Version   string
+		GitCommit string `json:",omitempty"`
+		GoVersion string `json:",omitempty"`
+	}
+
+	APIWait struct {
+		StatusCode int
+	}
+
+	APIAuth struct {
+		Status string
+	}
+
+	APIImageConfig struct {
+		ID string `json:"Id"`
+		*Config
+	}
+
+	APICopy struct {
+		Resource string
+		HostPath string
+	}
+)
+
+func (api APIImages) ToLegacy() []APIImagesOld {
+	outs := []APIImagesOld{}
+	for _, repotag := range api.RepoTags {
+		components := strings.SplitN(repotag, ":", 2)
+		outs = append(outs, APIImagesOld{
+			ID:          api.ID,
+			Repository:  components[0],
+			Tag:         components[1],
+			Created:     api.Created,
+			Size:        api.Size,
+			VirtualSize: api.VirtualSize,
+		})
+	}
 	return outs
 }
 
-type APIInfo struct {
-	Debug              bool
-	Containers         int
-	Images             int
-	NFd                int    `json:",omitempty"`
-	NGoroutines        int    `json:",omitempty"`
-	MemoryLimit        bool   `json:",omitempty"`
-	SwapLimit          bool   `json:",omitempty"`
-	IPv4Forwarding     bool   `json:",omitempty"`
-	LXCVersion         string `json:",omitempty"`
-	NEventsListener    int    `json:",omitempty"`
-	KernelVersion      string `json:",omitempty"`
-	IndexServerAddress string `json:",omitempty"`
-}
-
-type APITop struct {
-	Titles    []string
-	Processes [][]string
-}
-
-type APIRmi struct {
-	Deleted  string `json:",omitempty"`
-	Untagged string `json:",omitempty"`
-}
-
-type APIContainers struct {
-	ID         string `json:"Id"`
-	Image      string
-	Command    string
-	Created    int64
-	Status     string
-	Ports      []APIPort
-	SizeRw     int64
-	SizeRootFs int64
-	Names      []string
-}
-
-func (self *APIContainers) ToLegacy() APIContainersOld {
-	return APIContainersOld{
-		ID:         self.ID,
-		Image:      self.Image,
-		Command:    self.Command,
-		Created:    self.Created,
-		Status:     self.Status,
-		Ports:      displayablePorts(self.Ports),
-		SizeRw:     self.SizeRw,
-		SizeRootFs: self.SizeRootFs,
+func (api APIContainers) ToLegacy() *APIContainersOld {
+	return &APIContainersOld{
+		ID:         api.ID,
+		Image:      api.Image,
+		Command:    api.Command,
+		Created:    api.Created,
+		Status:     api.Status,
+		Ports:      displayablePorts(api.Ports),
+		SizeRw:     api.SizeRw,
+		SizeRootFs: api.SizeRootFs,
 	}
 }
-
-type APIContainersOld struct {
-	ID         string `json:"Id"`
-	Image      string
-	Command    string
-	Created    int64
-	Status     string
-	Ports      string
-	SizeRw     int64
-	SizeRootFs int64
-}
-
-type APIID struct {
-	ID string `json:"Id"`
-}
-
-type APIRun struct {
-	ID       string   `json:"Id"`
-	Warnings []string `json:",omitempty"`
-}
-
-type APIPort struct {
-	PrivatePort int64
-	PublicPort  int64
-	Type        string
-	IP          string
-}
-
-type APIVersion struct {
-	Version   string
-	GitCommit string `json:",omitempty"`
-	GoVersion string `json:",omitempty"`
-}
-
-type APIWait struct {
-	StatusCode int
-}
-
-type APIAuth struct {
-	Status string
-}
-
-type APIImageConfig struct {
-	ID string `json:"Id"`
-	*Config
-}
-
-type APICopy struct {
-	Resource string
-	HostPath string
-}
diff --git a/components/engine/archive/archive.go b/components/engine/archive/archive.go
index 97deb6c7b7..f30c8904b8 100644
--- a/components/engine/archive/archive.go
+++ b/components/engine/archive/archive.go
@@ -109,16 +109,17 @@ func Untar(archive io.Reader, path string) error {
 	buf := make([]byte, 10)
 	totalN := 0
 	for totalN < 10 {
-		if n, err := archive.Read(buf[totalN:]); err != nil {
+		n, err := archive.Read(buf[totalN:])
+		if err != nil {
 			if err == io.EOF {
 				return fmt.Errorf("Tarball too short")
 			}
 			return err
-		} else {
-			totalN += n
-			utils.Debugf("[tar autodetect] n: %d", n)
 		}
+		totalN += n
+		utils.Debugf("[tar autodetect] n: %d", n)
 	}
+
 	compression := DetectCompression(buf)
 
 	utils.Debugf("Archive compression detected: %s", compression.Extension())
diff --git a/components/engine/auth/auth.go b/components/engine/auth/auth.go
index 58b5f92cab..9acd00df61 100644
--- a/components/engine/auth/auth.go
+++ b/components/engine/auth/auth.go
@@ -196,10 +196,9 @@ func Login(authConfig *AuthConfig, factory *utils.HTTPRequestFactory) (string, e
 		if loginAgainstOfficialIndex {
 			return "", fmt.Errorf("Login: Your account hasn't been activated. " +
 				"Please check your e-mail for a confirmation link.")
-		} else {
-			return "", fmt.Errorf("Login: Your account hasn't been activated. " +
-				"Please see the documentation of the registry " + serverAddress + " for instructions how to activate it.")
 		}
+		return "", fmt.Errorf("Login: Your account hasn't been activated. " +
+			"Please see the documentation of the registry " + serverAddress + " for instructions how to activate it.")
 	} else if reqStatusCode == 400 {
 		if string(reqBody) == "\"Username or email already exists\"" {
 			req, err := factory.NewRequest("GET", serverAddress+"users/", nil)
diff --git a/components/engine/commands.go b/components/engine/commands.go
index d463a50a3d..889aa72ffb 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -2073,10 +2073,9 @@ func (cli *DockerCli) stream(method, path string, in io.Reader, out io.Writer, h
 
 	if matchesContentType(resp.Header.Get("Content-Type"), "application/json") {
 		return utils.DisplayJSONMessagesStream(resp.Body, out)
-	} else {
-		if _, err := io.Copy(out, resp.Body); err != nil {
-			return err
-		}
+	}
+	if _, err := io.Copy(out, resp.Body); err != nil {
+		return err
 	}
 	return nil
 }
diff --git a/components/engine/graph.go b/components/engine/graph.go
index f10c8e1bd9..062cf7be20 100644
--- a/components/engine/graph.go
+++ b/components/engine/graph.go
@@ -220,12 +220,11 @@ func (graph *Graph) getDockerInitLayer() (string, error) {
 					if err := os.MkdirAll(path.Join(initLayer, path.Dir(pth)), 0755); err != nil {
 						return "", err
 					}
-
-					if f, err := os.OpenFile(path.Join(initLayer, pth), os.O_CREATE, 0755); err != nil {
+					f, err := os.OpenFile(path.Join(initLayer, pth), os.O_CREATE, 0755)
+					if err != nil {
 						return "", err
-					} else {
-						f.Close()
 					}
+					f.Close()
 				}
 			} else {
 				return "", err
diff --git a/components/engine/image.go b/components/engine/image.go
index c600273c1a..f4276c461d 100644
--- a/components/engine/image.go
+++ b/components/engine/image.go
@@ -54,11 +54,11 @@ func LoadImage(root string) (*Image, error) {
 			return nil, err
 		}
 	} else {
-		if size, err := strconv.Atoi(string(buf)); err != nil {
+		size, err := strconv.Atoi(string(buf))
+		if err != nil {
 			return nil, err
-		} else {
-			img.Size = int64(size)
 		}
+		img.Size = int64(size)
 	}
 
 	// Check that the filesystem layer exists
@@ -99,14 +99,14 @@ func StoreImage(img *Image, jsonData []byte, layerData archive.Archive, root str
 	// If raw json is provided, then use it
 	if jsonData != nil {
 		return ioutil.WriteFile(jsonPath(root), jsonData, 0600)
-	} else { // Otherwise, unmarshal the image
-		jsonData, err := json.Marshal(img)
-		if err != nil {
-			return err
-		}
-		if err := ioutil.WriteFile(jsonPath(root), jsonData, 0600); err != nil {
-			return err
-		}
+	}
+	// Otherwise, unmarshal the image
+	jsonData, err := json.Marshal(img)
+	if err != nil {
+		return err
+	}
+	if err := ioutil.WriteFile(jsonPath(root), jsonData, 0600); err != nil {
+		return err
 	}
 
 	return StoreSize(img, root)
@@ -115,7 +115,7 @@ func StoreImage(img *Image, jsonData []byte, layerData archive.Archive, root str
 func StoreSize(img *Image, root string) error {
 	layer := layerPath(root)
 
-	var totalSize int64 = 0
+	var totalSize int64
 	filepath.Walk(layer, func(path string, fileInfo os.FileInfo, err error) error {
 		totalSize += fileInfo.Size()
 		return nil
@@ -163,21 +163,21 @@ func MountAUFS(ro []string, rw string, target string) error {
 }
 
 // TarLayer returns a tar archive of the image's filesystem layer.
-func (image *Image) TarLayer(compression archive.Compression) (archive.Archive, error) {
-	layerPath, err := image.layer()
+func (img *Image) TarLayer(compression archive.Compression) (archive.Archive, error) {
+	layerPath, err := img.layer()
 	if err != nil {
 		return nil, err
 	}
 	return archive.Tar(layerPath, compression)
 }
 
-func (image *Image) Mount(root, rw string) error {
+func (img *Image) Mount(root, rw string) error {
 	if mounted, err := Mounted(root); err != nil {
 		return err
 	} else if mounted {
 		return fmt.Errorf("%s is already mounted", root)
 	}
-	layers, err := image.layers()
+	layers, err := img.layers()
 	if err != nil {
 		return err
 	}
@@ -194,8 +194,8 @@ func (image *Image) Mount(root, rw string) error {
 	return nil
 }
 
-func (image *Image) Changes(rw string) ([]Change, error) {
-	layers, err := image.layers()
+func (img *Image) Changes(rw string) ([]Change, error) {
+	layers, err := img.layers()
 	if err != nil {
 		return nil, err
 	}
@@ -241,8 +241,10 @@ func (img *Image) History() ([]*Image, error) {
 // FIXME: @shykes refactor this function with the new error handling
 //        (I'll do it if I have time tonight, I focus on the rest)
 func (img *Image) layers() ([]string, error) {
-	var list []string
-	var e error
+	var (
+		list []string
+		e    error
+	)
 	if err := img.WalkHistory(
 		func(img *Image) (err error) {
 			if layer, err := img.layer(); err != nil {
@@ -262,12 +264,11 @@ func (img *Image) layers() ([]string, error) {
 	}
 
 	// Inject the dockerinit layer (empty place-holder for mount-binding dockerinit)
-	if dockerinitLayer, err := img.getDockerInitLayer(); err != nil {
+	dockerinitLayer, err := img.getDockerInitLayer()
+	if err != nil {
 		return nil, err
-	} else {
-		list = append([]string{dockerinitLayer}, list...)
 	}
-	return list, nil
+	return append([]string{dockerinitLayer}, list...), nil
 }
 
 func (img *Image) WalkHistory(handler func(*Image) error) (err error) {
diff --git a/components/engine/runtime.go b/components/engine/runtime.go
index f8c15767d7..7541e1cffd 100644
--- a/components/engine/runtime.go
+++ b/components/engine/runtime.go
@@ -1,7 +1,7 @@
 package docker
 
 import (
-	_ "code.google.com/p/gosqlite/sqlite3"
+	_ "code.google.com/p/gosqlite/sqlite3" // registers sqlite
 	"container/list"
 	"database/sql"
 	"fmt"
diff --git a/components/engine/server.go b/components/engine/server.go
index 79ead96a62..e9a76f8d84 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -422,9 +422,9 @@ func (srv *Server) ImageHistory(name string) ([]APIHistory, error) {
 
 }
 
-func (srv *Server) ContainerTop(name, ps_args string) (*APITop, error) {
+func (srv *Server) ContainerTop(name, psArgs string) (*APITop, error) {
 	if container := srv.runtime.Get(name); container != nil {
-		output, err := exec.Command("lxc-ps", "--name", container.ID, "--", ps_args).CombinedOutput()
+		output, err := exec.Command("lxc-ps", "--name", container.ID, "--", psArgs).CombinedOutput()
 		if err != nil {
 			return nil, fmt.Errorf("lxc-ps: %s (%s)", err, output)
 		}
@@ -891,12 +891,13 @@ func (srv *Server) pushRepository(r *registry.Registry, out io.Writer, localName
 					out.Write(sf.FormatStatus("", "Image %s already pushed, skipping", elem.ID))
 					continue
 				}
-				if checksum, err := srv.pushImage(r, out, remoteName, elem.ID, ep, repoData.Tokens, sf); err != nil {
+				checksum, err := srv.pushImage(r, out, remoteName, elem.ID, ep, repoData.Tokens, sf)
+				if err != nil {
 					// FIXME: Continue on error?
 					return err
-				} else {
-					elem.Checksum = checksum
 				}
+				elem.Checksum = checksum
+
 				if err := pushTags(); err != nil {
 					return err
 				}
@@ -939,11 +940,12 @@ func (srv *Server) pushImage(r *registry.Registry, out io.Writer, remote, imgID,
 	defer os.RemoveAll(layerData.Name())
 
 	// Send the layer
-	if checksum, err := r.PushImageLayerRegistry(imgData.ID, utils.ProgressReader(layerData, int(layerData.Size), out, sf.FormatProgress("", "Pushing", "%8v/%v (%v)"), sf, false), ep, token, jsonRaw); err != nil {
+	checksum, err = r.PushImageLayerRegistry(imgData.ID, utils.ProgressReader(layerData, int(layerData.Size), out, sf.FormatProgress("", "Pushing", "%8v/%v (%v)"), sf, false), ep, token, jsonRaw)
+	if err != nil {
 		return "", err
-	} else {
-		imgData.Checksum = checksum
 	}
+	imgData.Checksum = checksum
+
 	out.Write(sf.FormatStatus("", ""))
 
 	// Send the checksum
diff --git a/components/engine/utils/http.go b/components/engine/utils/http.go
index 1332ce816d..5eb77d1949 100644
--- a/components/engine/utils/http.go
+++ b/components/engine/utils/http.go
@@ -81,12 +81,12 @@ func NewHTTPUserAgentDecorator(versions ...VersionInfo) HTTPRequestDecorator {
 	return ret
 }
 
-func (self *HTTPUserAgentDecorator) ChangeRequest(req *http.Request) (newReq *http.Request, err error) {
+func (h *HTTPUserAgentDecorator) ChangeRequest(req *http.Request) (newReq *http.Request, err error) {
 	if req == nil {
 		return req, nil
 	}
 
-	userAgent := appendVersions(req.UserAgent(), self.versions...)
+	userAgent := appendVersions(req.UserAgent(), h.versions...)
 	if len(userAgent) > 0 {
 		req.Header.Set("User-Agent", userAgent)
 	}
@@ -97,11 +97,11 @@ type HTTPMetaHeadersDecorator struct {
 	Headers map[string][]string
 }
 
-func (self *HTTPMetaHeadersDecorator) ChangeRequest(req *http.Request) (newReq *http.Request, err error) {
-	if self.Headers == nil {
+func (h *HTTPMetaHeadersDecorator) ChangeRequest(req *http.Request) (newReq *http.Request, err error) {
+	if h.Headers == nil {
 		return req, nil
 	}
-	for k, v := range self.Headers {
+	for k, v := range h.Headers {
 		req.Header[k] = v
 	}
 	return req, nil
@@ -114,25 +114,25 @@ type HTTPRequestFactory struct {
 }
 
 func NewHTTPRequestFactory(d ...HTTPRequestDecorator) *HTTPRequestFactory {
-	ret := new(HTTPRequestFactory)
-	ret.decorators = d
-	return ret
+	return &HTTPRequestFactory{
+		decorators: d,
+	}
 }
 
 // NewRequest() creates a new *http.Request,
 // applies all decorators in the HTTPRequestFactory on the request,
 // then applies decorators provided by d on the request.
-func (self *HTTPRequestFactory) NewRequest(method, urlStr string, body io.Reader, d ...HTTPRequestDecorator) (*http.Request, error) {
+func (h *HTTPRequestFactory) NewRequest(method, urlStr string, body io.Reader, d ...HTTPRequestDecorator) (*http.Request, error) {
 	req, err := http.NewRequest(method, urlStr, body)
 	if err != nil {
 		return nil, err
 	}
 
 	// By default, a nil factory should work.
-	if self == nil {
+	if h == nil {
 		return req, nil
 	}
-	for _, dec := range self.decorators {
+	for _, dec := range h.decorators {
 		req, err = dec.ChangeRequest(req)
 		if err != nil {
 			return nil, err
diff --git a/components/engine/utils/utils.go b/components/engine/utils/utils.go
index 5a021d99e3..5864add8e1 100644
--- a/components/engine/utils/utils.go
+++ b/components/engine/utils/utils.go
@@ -1123,7 +1123,7 @@ func (graph *DependencyGraph) GenerateTraversalMap() ([][]string, error) {
 	for len(processed) < len(graph.nodes) {
 		// Use a temporary buffer for processed nodes, otherwise
 		// nodes that depend on each other could end up in the same round.
-		tmp_processed := []*DependencyNode{}
+		tmpProcessed := []*DependencyNode{}
 		for _, node := range graph.nodes {
 			// If the node has more dependencies than what we have cleared,
 			// it won't be valid for this round.
@@ -1137,7 +1137,7 @@ func (graph *DependencyGraph) GenerateTraversalMap() ([][]string, error) {
 			// It's not been processed yet and has 0 deps. Add it!
 			// (this is a shortcut for what we're doing below)
 			if node.Degree() == 0 {
-				tmp_processed = append(tmp_processed, node)
+				tmpProcessed = append(tmpProcessed, node)
 				continue
 			}
 			// If at least one dep hasn't been processed yet, we can't
@@ -1151,17 +1151,17 @@ func (graph *DependencyGraph) GenerateTraversalMap() ([][]string, error) {
 			}
 			// All deps have already been processed. Add it!
 			if ok {
-				tmp_processed = append(tmp_processed, node)
+				tmpProcessed = append(tmpProcessed, node)
 			}
 		}
-		Debugf("Round %d: found %d available nodes", len(result), len(tmp_processed))
+		Debugf("Round %d: found %d available nodes", len(result), len(tmpProcessed))
 		// If no progress has been made this round,
 		// that means we have circular dependencies.
-		if len(tmp_processed) == 0 {
+		if len(tmpProcessed) == 0 {
 			return nil, fmt.Errorf("Could not find a solution to this dependency graph")
 		}
 		round := []string{}
-		for _, nd := range tmp_processed {
+		for _, nd := range tmpProcessed {
 			round = append(round, nd.id)
 			processed[nd] = true
 		}

From e445caadb0bc1790faa9857d04b7a74f7753b471 Mon Sep 17 00:00:00 2001
From: Ryan Seto <ryanseto@yak.net>
Date: Mon, 18 Nov 2013 21:23:00 -0500
Subject: [PATCH 152/184] Correct the quotations in the command to add the
 -r=false flag.  Thanks to @tianon for pointing this out. Upstream-commit:
 194d4b93768c49f0d76a5da8943446efbea879ca Component: engine

---
 components/engine/docs/sources/use/host_integration.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/docs/sources/use/host_integration.rst b/components/engine/docs/sources/use/host_integration.rst
index bef996a71e..4c705a1c04 100644
--- a/components/engine/docs/sources/use/host_integration.rst
+++ b/components/engine/docs/sources/use/host_integration.rst
@@ -54,7 +54,7 @@ Run the following command:
 
 .. code-block:: bash
 
-   $ sudo sh -c 'echo DOCKER_OPTS="-r=false" > /etc/default/docker'
+   $ sudo sh -c "echo DOCKER_OPTS=\"-r=false\" > /etc/default/docker"
 
 
 Sample systemd Script

From 3768669ba5f82ec0720b47dad3f2977af6cc0715 Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Mon, 18 Nov 2013 18:39:02 -0800
Subject: [PATCH 153/184] Do ont truncate ID on docker rmi Upstream-commit:
 2fe4467d73b1bfe4a64011ee9d6b6aaf8b244fa5 Component: engine

---
 components/engine/server.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index 79ead96a62..6860ea5a9b 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -1205,8 +1205,8 @@ func (srv *Server) deleteImageAndChildren(id string, imgs *[]APIRmi) error {
 		if err != nil {
 			return err
 		}
-		*imgs = append(*imgs, APIRmi{Deleted: utils.TruncateID(id)})
-		srv.LogEvent("delete", utils.TruncateID(id), "")
+		*imgs = append(*imgs, APIRmi{Deleted: id})
+		srv.LogEvent("delete", id, "")
 		return nil
 	}
 	return nil

From e1cbb6a90976eccadf0530a50491a144fb519b39 Mon Sep 17 00:00:00 2001
From: unclejack <unclejacksons@gmail.com>
Date: Sat, 19 Oct 2013 04:17:00 +0300
Subject: [PATCH 154/184] fix layer size computation: handle hard links

This change makes docker compute layer size correctly.

The old code isn't taking hard links into account. Layers could
seem like they're up to 1-1.5x larger than they really were.
Upstream-commit: ac821f2446628a9151587038f1d377f57985a452
Component: engine
---
 components/engine/image.go | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/components/engine/image.go b/components/engine/image.go
index c600273c1a..f2d1b3e7ee 100644
--- a/components/engine/image.go
+++ b/components/engine/image.go
@@ -16,6 +16,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"syscall"
 	"time"
 )
 
@@ -114,10 +115,22 @@ func StoreImage(img *Image, jsonData []byte, layerData archive.Archive, root str
 
 func StoreSize(img *Image, root string) error {
 	layer := layerPath(root)
+	data := make(map[uint64]bool)
 
 	var totalSize int64 = 0
 	filepath.Walk(layer, func(path string, fileInfo os.FileInfo, err error) error {
-		totalSize += fileInfo.Size()
+		size := fileInfo.Size()
+		if size == 0 {
+			return nil
+		}
+
+		inode := fileInfo.Sys().(*syscall.Stat_t).Ino
+		if _, entryExists := data[inode]; entryExists {
+			return nil
+		}
+		data[inode] = false
+
+		totalSize += size
 		return nil
 	})
 	img.Size = totalSize

From fa7c88b48480bbeea94a937969f254493d1bc9c9 Mon Sep 17 00:00:00 2001
From: unclejack <unclejacksons@gmail.com>
Date: Tue, 19 Nov 2013 00:13:09 +0200
Subject: [PATCH 155/184] fix container size computation: handle hard links

This change makes docker compute container size correctly.

The old code isn't taking hard links into account. Containers could
seem like they're up to 1-1.5x larger than they really were.
Upstream-commit: 78c843c8eff64da5e12725bdb111b18e51d82606
Component: engine
---
 components/engine/container.go | 34 ++++++++++++++++++++++++++++++----
 1 file changed, 30 insertions(+), 4 deletions(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index 9dac345447..0686d2f5aa 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -1559,20 +1559,46 @@ func validateID(id string) error {
 // GetSize, return real size, virtual size
 func (container *Container) GetSize() (int64, int64) {
 	var sizeRw, sizeRootfs int64
+	data := make(map[uint64]bool)
 
 	filepath.Walk(container.rwPath(), func(path string, fileInfo os.FileInfo, err error) error {
-		if fileInfo != nil {
-			sizeRw += fileInfo.Size()
+		if fileInfo == nil {
+			return nil
 		}
+		size := fileInfo.Size()
+		if size == 0 {
+			return nil
+		}
+
+		inode := fileInfo.Sys().(*syscall.Stat_t).Ino
+		if _, entryExists := data[inode]; entryExists {
+			return nil
+		}
+		data[inode] = false
+
+		sizeRw += size
 		return nil
 	})
 
+	data = make(map[uint64]bool)
 	_, err := os.Stat(container.RootfsPath())
 	if err == nil {
 		filepath.Walk(container.RootfsPath(), func(path string, fileInfo os.FileInfo, err error) error {
-			if fileInfo != nil {
-				sizeRootfs += fileInfo.Size()
+			if fileInfo == nil {
+				return nil
 			}
+			size := fileInfo.Size()
+			if size == 0 {
+				return nil
+			}
+
+			inode := fileInfo.Sys().(*syscall.Stat_t).Ino
+			if _, entryExists := data[inode]; entryExists {
+				return nil
+			}
+			data[inode] = false
+
+			sizeRootfs += size
 			return nil
 		})
 	}

From 3ec07575559224d4cf9c6ba487e4be8f2768a11c Mon Sep 17 00:00:00 2001
From: Sylvain Bellemare <sylvain.bellemare@ezeep.com>
Date: Tue, 19 Nov 2013 14:44:50 +0100
Subject: [PATCH 156/184] fixed typos, and made small improvements to the
 wording Upstream-commit: 3656db66d2f13d74e07574d229b32023bb11dc1f Component:
 engine

---
 .../engine/docs/sources/examples/running_redis_service.rst    | 2 +-
 .../engine/docs/sources/examples/running_ssh_service.rst      | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/components/engine/docs/sources/examples/running_redis_service.rst b/components/engine/docs/sources/examples/running_redis_service.rst
index 744eca7ca5..886f473ef2 100644
--- a/components/engine/docs/sources/examples/running_redis_service.rst
+++ b/components/engine/docs/sources/examples/running_redis_service.rst
@@ -82,7 +82,7 @@ of our ``redis`` container.
     DB_PORT_6379_TCP_ADDR=172.17.0.33
     DB_PORT_6379_TCP_PROTO=tcp
 
-We can see that we've got a small list of environmental varaibles prefixed with ``DB``. 
+We can see that we've got a small list of environment variables prefixed with ``DB``.
 The ``DB`` comes from the link alias specified when we launched the container. Let's use 
 the ``DB_PORT_6379_TCP_ADDR`` variable to connect to our Redis container.
 
diff --git a/components/engine/docs/sources/examples/running_ssh_service.rst b/components/engine/docs/sources/examples/running_ssh_service.rst
index 59a80fbf6e..3d0a782678 100644
--- a/components/engine/docs/sources/examples/running_ssh_service.rst
+++ b/components/engine/docs/sources/examples/running_ssh_service.rst
@@ -12,9 +12,9 @@ SSH Daemon Service
 
 **Video:**
 
-I've create a little screencast to show how to create a SSHd service
+I've created a little screencast to show how to create an SSHd service
 and connect to it. It is something like 11 minutes and not entirely
-smooth, but gives you a good idea.
+smooth, but it gives you a good idea.
 
 .. note::
    This screencast was created before Docker version 0.5.2, so the

From a9304e452b3bc59df5b8f66a1c9cc1bd1fdc3ea0 Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Tue, 19 Nov 2013 10:10:42 -0700
Subject: [PATCH 157/184] Switch sphinx man_pages generation to use
 commandline/cli instead of toctree for a more relevant/useful man page
 Upstream-commit: 1cd9529ad350f70aaf6627368bdc8d007b90b3e4 Component: engine

---
 components/engine/docs/Makefile        | 2 +-
 components/engine/docs/sources/conf.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/components/engine/docs/Makefile b/components/engine/docs/Makefile
index a97255f516..a4efbf2102 100644
--- a/components/engine/docs/Makefile
+++ b/components/engine/docs/Makefile
@@ -31,7 +31,7 @@ help:
 #	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
 #	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
 #	@echo "  text       to make text files"
-#	@echo "  man        to make manual pages"
+	@echo "  man        to make a manual page"
 #	@echo "  texinfo    to make Texinfo files"
 #	@echo "  info       to make Texinfo files and run them through makeinfo"
 #	@echo "  gettext    to make PO message catalogs"
diff --git a/components/engine/docs/sources/conf.py b/components/engine/docs/sources/conf.py
index 0ccd4a4ed5..a143e821be 100644
--- a/components/engine/docs/sources/conf.py
+++ b/components/engine/docs/sources/conf.py
@@ -235,7 +235,7 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('toctree', 'docker', u'Docker Documentation',
+    ('commandline/cli', 'docker', u'Docker Documentation',
      [u'Team Docker'], 1)
 ]
 

From 8dfcb6d8f568b78566a76ffce90ac2a7fa8d138f Mon Sep 17 00:00:00 2001
From: Ryan Seto <ryanseto@yak.net>
Date: Tue, 19 Nov 2013 12:14:39 -0500
Subject: [PATCH 158/184] Fix quote mistake. Upstream-commit:
 1da8c50deddde692c1f87aec86c20cd3c2c3fd11 Component: engine

---
 components/engine/docs/sources/use/host_integration.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/docs/sources/use/host_integration.rst b/components/engine/docs/sources/use/host_integration.rst
index 4c705a1c04..a9f9c1e753 100644
--- a/components/engine/docs/sources/use/host_integration.rst
+++ b/components/engine/docs/sources/use/host_integration.rst
@@ -54,7 +54,7 @@ Run the following command:
 
 .. code-block:: bash
 
-   $ sudo sh -c "echo DOCKER_OPTS=\"-r=false\" > /etc/default/docker"
+   $ sudo sh -c "echo 'DOCKER_OPTS=\"-r=false\"' > /etc/default/docker"
 
 
 Sample systemd Script

From e6a444ec3bb548166ce9f60c9811d45c9b04efaf Mon Sep 17 00:00:00 2001
From: Vitor Monteiro <vmrmonteiro@gmail.com>
Date: Tue, 19 Nov 2013 17:50:38 +0000
Subject: [PATCH 159/184] Change to documentation for AWS AMI request

Hi guys, it just might be me, but clicking the AMI from http://cloud-images.ubuntu.com/locator/ec2/ is broken to me. So I just did it via the normal Create Instance Wizard.

I just though some people might have the same issue.

Sorry if my markdown for links is screwed up, I went by the examples, since I'm used to the `[]()` traditional one.

Cheers.
Upstream-commit: aeb304b37c190e7fab60c0db946d1fd5d8e9e9f3
Component: engine
---
 components/engine/docs/sources/installation/amazon.rst | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/components/engine/docs/sources/installation/amazon.rst b/components/engine/docs/sources/installation/amazon.rst
index 6d92046dbf..0c36dbfc33 100644
--- a/components/engine/docs/sources/installation/amazon.rst
+++ b/components/engine/docs/sources/installation/amazon.rst
@@ -22,12 +22,10 @@ Amazon QuickStart
 
 1. **Choose an image:**
 
-   * Open http://cloud-images.ubuntu.com/locator/ec2/
-   * Enter ``amd64 precise`` in the search field (it will search as you
-     type)
-   * Pick an image by clicking on the image name. *An EBS-enabled
-     image will let you use a t1.micro instance.* Clicking on the image 
-     name will take you to your AWS Console.
+   * Launch the `Create Instance Wizard` <https://console.aws.amazon.com/ec2/v2/home?#LaunchInstanceWizard:> menu on your AWS Console
+   * Select "Community AMIs" option and serch for ``amd64 precise`` (click enter to search)
+   * If you choose a EBS enabled AMI you will be able to launch a `t1.micro` instance (more info on `pricing` <http://aws.amazon.com/en/ec2/pricing/> )
+   * When you click select you'll be taken to the instance setup, and you're one click away from having your Ubuntu VM up and running.
 
 2. **Tell CloudInit to install Docker:**
 

From d8912e66aae3e5f26fca6cc5e3044773e9f6af7e Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Tue, 19 Nov 2013 11:02:10 -0800
Subject: [PATCH 160/184] speedup docker ps Upstream-commit:
 145c2008ae3bbd8bca6e11bac93c6c0098a3ba42 Component: engine

---
 components/engine/server.go | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index 79ead96a62..feda5088cd 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -471,6 +471,12 @@ func (srv *Server) Containers(all, size bool, n int, since, before string) []API
 	var displayed int
 	out := []APIContainers{}
 
+	names := map[string][]string{}
+	srv.runtime.containerGraph.Walk("/", func(p string, e *gograph.Entity) error {
+		names[e.ID()] = append(names[e.ID()], p)
+		return nil
+	}, -1)
+
 	for _, container := range srv.runtime.List() {
 		if !container.State.Running && !all && n == -1 && since == "" && before == "" {
 			continue
@@ -491,25 +497,17 @@ func (srv *Server) Containers(all, size bool, n int, since, before string) []API
 			break
 		}
 		displayed++
-		c := createAPIContainer(container, size, srv.runtime)
+		c := createAPIContainer(names[container.ID], container, size, srv.runtime)
 		out = append(out, c)
 	}
 	return out
 }
 
-func createAPIContainer(container *Container, size bool, runtime *Runtime) APIContainers {
+func createAPIContainer(names []string, container *Container, size bool, runtime *Runtime) APIContainers {
 	c := APIContainers{
 		ID: container.ID,
 	}
-	names := []string{}
-	runtime.containerGraph.Walk("/", func(p string, e *gograph.Entity) error {
-		if e.ID() == container.ID {
-			names = append(names, p)
-		}
-		return nil
-	}, -1)
 	c.Names = names
-
 	c.Image = runtime.repositories.ImageName(container.Image)
 	c.Command = fmt.Sprintf("%s %s", container.Path, strings.Join(container.Args, " "))
 	c.Created = container.Created.Unix()

From 791d32523ffdd7311a9d36e39d47d71e2b3773ed Mon Sep 17 00:00:00 2001
From: Andy Rothfusz <github@metaliveblog.com>
Date: Fri, 15 Nov 2013 16:11:05 -0800
Subject: [PATCH 161/184] Fix #2342. Harmonize information about ADD.
 Cross-link build info. Upstream-commit:
 4f9f83d6c6e71f826489f04e497f4a384c49a2c1 Component: engine

---
 .../engine/docs/sources/commandline/cli.rst   | 65 ++++++++++++++-----
 .../engine/docs/sources/use/builder.rst       | 52 ++++++++++++---
 2 files changed, 91 insertions(+), 26 deletions(-)

diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index d0a8d83c0c..8068b881ce 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -88,31 +88,65 @@ Examples:
 
     Usage: docker build [OPTIONS] PATH | URL | -
     Build a new container image from the source code at PATH
-      -t="": Repository name (and optionally a tag) to be applied to the resulting image in case of success.
+      -t="": Repository name (and optionally a tag) to be applied 
+             to the resulting image in case of success.
       -q=false: Suppress verbose build output.
       -no-cache: Do not use the cache when building the image.
       -rm: Remove intermediate containers after a successful build
-    When a single Dockerfile is given as URL, then no context is set. When a git repository is set as URL, the repository is used as context
+
+The files at PATH or URL are called the "context" of the build. The
+build process may refer to any of the files in the context, for
+example when using an :ref:`ADD <dockerfile_add>` instruction.  When a
+single ``Dockerfile`` is given as URL, then no context is set.  When a
+git repository is set as URL, then the repository is used as the
+context
 
 .. _cli_build_examples:
 
+.. seealso:: :ref:`dockerbuilder`.
+
 Examples:
 ~~~~~~~~~
 
 .. code-block:: bash
 
     sudo docker build .
+    Uploading context 10240 bytes
+    Step 1 : FROM busybox
+    Pulling repository busybox
+     ---> e9aa60c60128MB/2.284 MB (100%) endpoint: https://cdn-registry-1.docker.io/v1/
+    Step 2 : RUN ls -lh /
+     ---> Running in 9c9e81692ae9
+    total 24
+    drwxr-xr-x    2 root     root        4.0K Mar 12  2013 bin
+    drwxr-xr-x    5 root     root        4.0K Oct 19 00:19 dev
+    drwxr-xr-x    2 root     root        4.0K Oct 19 00:19 etc
+    drwxr-xr-x    2 root     root        4.0K Nov 15 23:34 lib
+    lrwxrwxrwx    1 root     root           3 Mar 12  2013 lib64 -> lib
+    dr-xr-xr-x  116 root     root           0 Nov 15 23:34 proc
+    lrwxrwxrwx    1 root     root           3 Mar 12  2013 sbin -> bin
+    dr-xr-xr-x   13 root     root           0 Nov 15 23:34 sys
+    drwxr-xr-x    2 root     root        4.0K Mar 12  2013 tmp
+    drwxr-xr-x    2 root     root        4.0K Nov 15 23:34 usr
+     ---> b35f4035db3f
+    Step 3 : CMD echo Hello World
+     ---> Running in 02071fceb21b
+     ---> f52f38b7823e
+    Successfully built f52f38b7823e
 
-This will read the ``Dockerfile`` from the current directory. It will
-also send any other files and directories found in the current
-directory to the ``docker`` daemon.
+This example specifies that the PATH is ``.``, and so all the files in
+the local directory get tar'd and sent to the Docker daemon.  The PATH
+specifies where to find the files for the "context" of the build on
+the Docker daemon. Remember that the daemon could be running on a
+remote machine and that no parsing of the Dockerfile happens at the
+client side (where you're running ``docker build``). That means that
+*all* the files at PATH get sent, not just the ones listed to
+:ref:`ADD <dockerfile_add>` in the ``Dockerfile``.
+
+The transfer of context from the local machine to the Docker daemon is
+what the ``docker`` client means when you see the "Uploading context"
+message.
 
-The contents of this directory would be used by ``ADD`` commands found
-within the ``Dockerfile``.  This will send a lot of data to the
-``docker`` daemon if the current directory contains a lot of data.  If
-the absolute path is provided instead of ``.`` then only the files and
-directories required by the ADD commands from the ``Dockerfile`` will be
-added to the context and transferred to the ``docker`` daemon.
 
 .. code-block:: bash
 
@@ -129,16 +163,15 @@ tag will be ``2.0``
 
 This will read a ``Dockerfile`` from *stdin* without context. Due to
 the lack of a context, no contents of any local directory will be sent
-to the ``docker`` daemon.  ``ADD`` doesn't work when running in this
-mode because the absence of the context provides no source files to
-copy to the container.
+to the ``docker`` daemon.  Since there is no context, a Dockerfile
+``ADD`` only works if it refers to a remote URL.
 
 .. code-block:: bash
 
     sudo docker build github.com/creack/docker-firefox
 
-This will clone the Github repository and use it as context. The
-``Dockerfile`` at the root of the repository is used as
+This will clone the Github repository and use the cloned repository as
+context. The ``Dockerfile`` at the root of the repository is used as
 ``Dockerfile``.  Note that you can specify an arbitrary git repository
 by using the ``git://`` schema.
 
diff --git a/components/engine/docs/sources/use/builder.rst b/components/engine/docs/sources/use/builder.rst
index b8dd95bad0..2035c276dd 100644
--- a/components/engine/docs/sources/use/builder.rst
+++ b/components/engine/docs/sources/use/builder.rst
@@ -15,27 +15,39 @@ commit them along the way, giving you a final image.
 
 .. contents:: Table of Contents
 
+.. _dockerfile_usage:
+
 1. Usage
 ========
 
-To build an image from a source repository, create a description file
-called ``Dockerfile`` at the root of your repository. This file will
-describe the steps to assemble the image.
+To :ref:`build <cli_build>` an image from a source repository, create
+a description file called ``Dockerfile`` at the root of your
+repository. This file will describe the steps to assemble the image.
 
 Then call ``docker build`` with the path of your source repository as
-argument:
+argument (for example, ``.``):
 
     ``sudo docker build .``
 
+The path to the source repository defines where to find the *context*
+of the build. The build is run by the Docker daemon, not by the CLI,
+so the whole context must be transferred to the daemon. The Docker CLI
+reports "Uploading context" when the context is sent to the daemon.
+
 You can specify a repository and tag at which to save the new image if the
 build succeeds:
 
     ``sudo docker build -t shykes/myapp .``
 
-Docker will run your steps one-by-one, committing the result if necessary,
-before finally outputting the ID of your new image.
+The Docker daemon will run your steps one-by-one, committing the
+result if necessary, before finally outputting the ID of your new
+image. The Docker daemon will automatically clean up the context you
+sent.
 
-When you're done with your build, you're ready to look into :ref:`image_push`.
+When you're done with your build, you're ready to look into
+:ref:`image_push`.
+
+.. _dockerfile_format:
 
 2. Format
 =========
@@ -63,12 +75,16 @@ allows statements like:
     # Comment
     RUN echo 'we are running some # of cool things'
 
+.. _dockerfile_instructions:
+
 3. Instructions
 ===============
 
 Here is the set of instructions you can use in a ``Dockerfile`` for
 building images.
 
+.. _dockerfile_from:
+
 3.1 FROM
 --------
 
@@ -94,6 +110,8 @@ output by the commit before each new ``FROM`` command.
 If no ``tag`` is given to the ``FROM`` instruction, ``latest`` is
 assumed. If the used tag does not exist, an error will be returned.
 
+.. _dockerfile_maintainer:
+
 3.2 MAINTAINER
 --------------
 
@@ -102,6 +120,8 @@ assumed. If the used tag does not exist, an error will be returned.
 The ``MAINTAINER`` instruction allows you to set the *Author* field of
 the generated images.
 
+.. _dockerfile_run:
+
 3.3 RUN
 -------
 
@@ -124,7 +144,7 @@ Known Issues (RUN)
   ``rm`` a file, for example. The issue describes a workaround.
 * :issue:`2424` Locale will not be set automatically.
 
-
+.. _dockerfile_cmd:
 
 3.4 CMD
 -------
@@ -169,7 +189,7 @@ array:
 
 If you would like your container to run the same executable every
 time, then you should consider using ``ENTRYPOINT`` in combination
-with ``CMD``. See :ref:`entrypoint_def`.
+with ``CMD``. See :ref:`dockerfile_entrypoint`.
 
 If the user specifies arguments to ``docker run`` then they will
 override the default specified in CMD.
@@ -179,6 +199,8 @@ override the default specified in CMD.
     command and commits the result; ``CMD`` does not execute anything at
     build time, but specifies the intended command for the image.
 
+.. _dockerfile_expose:
+
 3.5 EXPOSE
 ----------
 
@@ -189,6 +211,8 @@ functionally equivalent to running ``docker commit -run '{"PortSpecs":
 ["<port>", "<port2>"]}'`` outside the builder. Refer to
 :ref:`port_redirection` for detailed information.
 
+.. _dockerfile_env:
+
 3.6 ENV
 -------
 
@@ -203,6 +227,8 @@ with ``<key>=<value>``
     The environment variables will persist when a container is run
     from the resulting image.
 
+.. _dockerfile_add:
+
 3.7 ADD
 -------
 
@@ -263,7 +289,7 @@ The copy obeys the following rules:
 * If ``<dest>`` doesn't exist, it is created along with all missing
   directories in its path.
 
-.. _entrypoint_def:
+.. _dockerfile_entrypoint:
 
 3.8 ENTRYPOINT
 --------------
@@ -312,6 +338,7 @@ this optional but default, you could use a CMD:
     CMD ["-l", "-"]
     ENTRYPOINT ["/usr/bin/wc"]
 
+.. _dockerfile_volume:
 
 3.9 VOLUME
 ----------
@@ -322,6 +349,8 @@ The ``VOLUME`` instruction will create a mount point with the specified name and
 as holding externally mounted volumes from native host or other containers. For more information/examples 
 and mounting instructions via docker client, refer to :ref:`volume_def` documentation. 
 
+.. _dockerfile_user:
+
 3.10 USER
 ---------
 
@@ -330,6 +359,8 @@ and mounting instructions via docker client, refer to :ref:`volume_def` document
 The ``USER`` instruction sets the username or UID to use when running
 the image.
 
+.. _dockerfile_workdir:
+
 3.11 WORKDIR
 ------------
 
@@ -338,6 +369,7 @@ the image.
 The ``WORKDIR`` instruction sets the working directory in which
 the command given by ``CMD`` is executed.
 
+.. _dockerfile_examples:
 
 4. Dockerfile Examples
 ======================

From dcb211eeb01b556b6b33c24899891649bd7c5ae0 Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Mon, 18 Nov 2013 17:05:05 -0800
Subject: [PATCH 162/184] improve tests on the engine Upstream-commit:
 8e5ab5bfca2a7077f4e85096808c8f309cf692df Component: engine

---
 components/engine/engine/engine_test.go       | 55 +++++++++++
 components/engine/engine/env_test.go          | 94 +++++++++++++++++++
 .../engine/{utils.go => helpers_test.go}      |  4 -
 components/engine/engine/job.go               |  6 +-
 4 files changed, 154 insertions(+), 5 deletions(-)
 create mode 100644 components/engine/engine/engine_test.go
 rename components/engine/engine/{utils.go => helpers_test.go} (92%)

diff --git a/components/engine/engine/engine_test.go b/components/engine/engine/engine_test.go
new file mode 100644
index 0000000000..fdc0b0ec7f
--- /dev/null
+++ b/components/engine/engine/engine_test.go
@@ -0,0 +1,55 @@
+package engine
+
+import (
+	"testing"
+)
+
+func TestRegister(t *testing.T) {
+	if err := Register("dummy1", nil); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := Register("dummy1", nil); err == nil {
+		t.Fatalf("Expecting error, got none")
+	}
+
+	eng := newTestEngine(t)
+
+	//Should fail because globan handlers are copied
+	//at the engine creation
+	if err := eng.Register("dummy1", nil); err == nil {
+		t.Fatalf("Expecting error, got none")
+	}
+
+	if err := eng.Register("dummy2", nil); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := eng.Register("dummy2", nil); err == nil {
+		t.Fatalf("Expecting error, got none")
+	}
+}
+
+func TestJob(t *testing.T) {
+	eng := newTestEngine(t)
+	job1 := eng.Job("dummy1", "--level=awesome")
+
+	if job1.handler != nil {
+		t.Fatalf("job1.handler should be empty")
+	}
+
+	h := func(j *Job) string {
+		return j.Name
+	}
+
+	eng.Register("dummy2", h)
+	job2 := eng.Job("dummy2", "--level=awesome")
+
+	if job2.handler == nil {
+		t.Fatalf("job2.handler shouldn't be nil")
+	}
+
+	if job2.handler(job2) != job2.Name {
+		t.Fatalf("handler dummy2 was not found in job2")
+	}
+}
diff --git a/components/engine/engine/env_test.go b/components/engine/engine/env_test.go
index 3acbddad77..343da31cec 100644
--- a/components/engine/engine/env_test.go
+++ b/components/engine/engine/env_test.go
@@ -23,7 +23,101 @@ func TestSetenv(t *testing.T) {
 	if val := job.Getenv("foo"); val != "bar" {
 		t.Fatalf("Getenv returns incorrect value: %s", val)
 	}
+
+	job.Setenv("bar", "")
+	if val := job.Getenv("bar"); val != "" {
+		t.Fatalf("Getenv returns incorrect value: %s", val)
+	}
 	if val := job.Getenv("nonexistent"); val != "" {
 		t.Fatalf("Getenv returns incorrect value: %s", val)
 	}
 }
+
+func TestSetenvBool(t *testing.T) {
+	job := mkJob(t, "dummy")
+	job.SetenvBool("foo", true)
+	if val := job.GetenvBool("foo"); !val {
+		t.Fatalf("GetenvBool returns incorrect value: %b", val)
+	}
+
+	job.SetenvBool("bar", false)
+	if val := job.GetenvBool("bar"); val {
+		t.Fatalf("GetenvBool returns incorrect value: %b", val)
+	}
+
+	if val := job.GetenvBool("nonexistent"); val {
+		t.Fatalf("GetenvBool returns incorrect value: %b", val)
+	}
+}
+
+func TestSetenvInt(t *testing.T) {
+	job := mkJob(t, "dummy")
+
+	job.SetenvInt("foo", -42)
+	if val := job.GetenvInt("foo"); val != -42 {
+		t.Fatalf("GetenvInt returns incorrect value: %d", val)
+	}
+
+	job.SetenvInt("bar", 42)
+	if val := job.GetenvInt("bar"); val != 42 {
+		t.Fatalf("GetenvInt returns incorrect value: %d", val)
+	}
+	if val := job.GetenvInt("nonexistent"); val != -1 {
+		t.Fatalf("GetenvInt returns incorrect value: %d", val)
+	}
+}
+
+func TestSetenvList(t *testing.T) {
+	job := mkJob(t, "dummy")
+
+	job.SetenvList("foo", []string{"bar"})
+	if val := job.GetenvList("foo"); len(val) != 1 || val[0] != "bar" {
+		t.Fatalf("GetenvList returns incorrect value: %v", val)
+	}
+
+	job.SetenvList("bar", nil)
+	if val := job.GetenvList("bar"); val != nil {
+		t.Fatalf("GetenvList returns incorrect value: %v", val)
+	}
+	if val := job.GetenvList("nonexistent"); val != nil {
+		t.Fatalf("GetenvList returns incorrect value: %v", val)
+	}
+}
+
+func TestImportEnv(t *testing.T) {
+	type dummy struct {
+		DummyInt         int
+		DummyStringArray []string
+	}
+
+	job := mkJob(t, "dummy")
+	if err := job.ImportEnv(&dummy{42, []string{"foo", "bar"}}); err != nil {
+		t.Fatal(err)
+	}
+
+	dmy := dummy{}
+	if err := job.ExportEnv(&dmy); err != nil {
+		t.Fatal(err)
+	}
+
+	if dmy.DummyInt != 42 {
+		t.Fatalf("Expected 42, got %d", dmy.DummyInt)
+	}
+
+	if len(dmy.DummyStringArray) != 2 || dmy.DummyStringArray[0] != "foo" || dmy.DummyStringArray[1] != "bar" {
+		t.Fatalf("Expected {foo, bar}, got %v", dmy.DummyStringArray)
+	}
+
+}
+
+func TestEnviron(t *testing.T) {
+	job := mkJob(t, "dummy")
+	job.Setenv("foo", "bar")
+	val, exists := job.Environ()["foo"]
+	if !exists {
+		t.Fatalf("foo not found in the environ")
+	}
+	if val != "bar" {
+		t.Fatalf("bar not found in the environ")
+	}
+}
diff --git a/components/engine/engine/utils.go b/components/engine/engine/helpers_test.go
similarity index 92%
rename from components/engine/engine/utils.go
rename to components/engine/engine/helpers_test.go
index 33b1269aca..5b1c0baf60 100644
--- a/components/engine/engine/utils.go
+++ b/components/engine/engine/helpers_test.go
@@ -11,10 +11,6 @@ import (
 
 var globalTestID string
 
-func init() {
-	Register("dummy", func(job *Job) string { return "" })
-}
-
 func newTestEngine(t *testing.T) *Engine {
 	// Use the caller function name as a prefix.
 	// This helps trace temp directories back to their test.
diff --git a/components/engine/engine/job.go b/components/engine/engine/job.go
index 3ccaa8d1a0..365c94e06b 100644
--- a/components/engine/engine/job.go
+++ b/components/engine/engine/job.go
@@ -205,8 +205,12 @@ func (job *Job) SetenvInt(key string, value int64) {
 	job.Setenv(key, fmt.Sprintf("%d", value))
 }
 
+// Returns nil if key not found
 func (job *Job) GetenvList(key string) []string {
 	sval := job.Getenv(key)
+	if sval == "" {
+		return nil
+	}
 	l := make([]string, 0, 1)
 	if err := json.Unmarshal([]byte(sval), &l); err != nil {
 		l = append(l, sval)
@@ -234,7 +238,7 @@ func (job *Job) Setenv(key, value string) {
 // DecodeEnv decodes `src` as a json dictionary, and adds
 // each decoded key-value pair to the environment.
 //
-// If `text` cannot be decoded as a json dictionary, an error
+// If `src` cannot be decoded as a json dictionary, an error
 // is returned.
 func (job *Job) DecodeEnv(src io.Reader) error {
 	m := make(map[string]interface{})

From 220d98907136a8d52fd29ddd38003831dc2af73b Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Fri, 8 Nov 2013 08:40:46 -0600
Subject: [PATCH 163/184] simplify the runtime Register reconnect logic

Refactor the Register code a little bit to make it easier to comprehend.
Upstream-commit: 3cbec951772b9849c0ba679a5988b54384d05ce1
Component: engine
---
 components/engine/runtime.go | 27 ++++++++++-----------------
 1 file changed, 10 insertions(+), 17 deletions(-)

diff --git a/components/engine/runtime.go b/components/engine/runtime.go
index 4559164e28..7e386a20ff 100644
--- a/components/engine/runtime.go
+++ b/components/engine/runtime.go
@@ -118,9 +118,6 @@ func (runtime *Runtime) Register(container *Container) error {
 		return err
 	}
 
-	// init the wait lock
-	container.waitLock = make(chan struct{})
-
 	container.runtime = runtime
 
 	// Attach to stdout and stderr
@@ -136,10 +133,6 @@ func (runtime *Runtime) Register(container *Container) error {
 	runtime.containers.PushBack(container)
 	runtime.idIndex.Add(container.ID)
 
-	// When we actually restart, Start() do the monitoring.
-	// However, when we simply 'reattach', we have to restart a monitor
-	nomonitor := false
-
 	// 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
@@ -157,7 +150,6 @@ func (runtime *Runtime) Register(container *Container) error {
 				if err := container.Start(); err != nil {
 					return err
 				}
-				nomonitor = true
 			} else {
 				utils.Debugf("Marking as stopped")
 				container.State.setStopped(-127)
@@ -165,16 +157,17 @@ func (runtime *Runtime) Register(container *Container) error {
 					return err
 				}
 			}
-		}
-	}
+		} else {
+			utils.Debugf("Reconnecting to container %v", container.ID)
 
-	// If the container is not running or just has been flagged not running
-	// then close the wait lock chan (will be reset upon start)
-	if !container.State.Running {
-		close(container.waitLock)
-	} else if !nomonitor {
-		container.allocateNetwork()
-		go container.monitor()
+			if err := container.allocateNetwork(); err != nil {
+				return err
+			}
+
+			container.waitLock = make(chan struct{})
+
+			go container.monitor()
+		}
 	}
 	return nil
 }

From 4af17f4fede3b48ae9c590b8377ffd9ca62db371 Mon Sep 17 00:00:00 2001
From: Tianon Gravi <admwiggin@gmail.com>
Date: Tue, 19 Nov 2013 12:41:29 -0800
Subject: [PATCH 164/184] rename file to remove testing flags from docker
 binary Upstream-commit: 66beafa9f3ee72c26773158c7102cb727613ac65 Component:
 engine

---
 components/engine/{api_unit_tests.go => api_unit_test.go} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename components/engine/{api_unit_tests.go => api_unit_test.go} (100%)

diff --git a/components/engine/api_unit_tests.go b/components/engine/api_unit_test.go
similarity index 100%
rename from components/engine/api_unit_tests.go
rename to components/engine/api_unit_test.go

From 00e4f0c411859c85b209ff862a481b08077029bd Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Tue, 19 Nov 2013 18:28:50 -0800
Subject: [PATCH 165/184] don't import emport empty hostconfig Upstream-commit:
 0169cf15dd272f0403909a9be64fd1b575396ffc Component: engine

---
 components/engine/api.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index d9c1aa3f32..93322fd8aa 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -647,9 +647,6 @@ func postContainersStart(srv *Server, version float64, w http.ResponseWriter, r
 	}
 	name := vars["name"]
 	job := srv.Eng.Job("start", name)
-	if err := job.ImportEnv(HostConfig{}); err != nil {
-		return fmt.Errorf("Couldn't initialize host configuration")
-	}
 	// allow a nil body for backwards compatibility
 	if r.Body != nil {
 		if matchesContentType(r.Header.Get("Content-Type"), "application/json") {

From 56750f8076cf3e0a5ead21c903e150861d6cb862 Mon Sep 17 00:00:00 2001
From: Michael Crosby <crosby.michael@gmail.com>
Date: Tue, 19 Nov 2013 19:25:54 -0800
Subject: [PATCH 166/184] Pip python deps to a specific version
 Upstream-commit: 2cccbbdadd8ee7e28824c244e48acebfca96d78a Component: engine

---
 components/engine/Dockerfile | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/components/engine/Dockerfile b/components/engine/Dockerfile
index 559017507e..4414a735dd 100644
--- a/components/engine/Dockerfile
+++ b/components/engine/Dockerfile
@@ -46,10 +46,9 @@ run	apt-get install -y -q ruby1.9.3 rubygems libffi-dev
 run	gem install --no-rdoc --no-ri fpm
 run	apt-get install -y -q reprepro dpkg-sig
 
-# Install s3cmd 1.0.1 (earlier versions don't support env variables in the config)
 run	apt-get install -y -q python-pip
-run	pip install s3cmd
-run	pip install python-magic
+run	pip install s3cmd==1.1.0-beta3
+run	pip install python-magic==0.4.6
 run	/bin/echo -e '[default]\naccess_key=$AWS_ACCESS_KEY\nsecret_key=$AWS_SECRET_KEY\n' > /.s3cfg
 
 # Runtime dependencies

From 390195822fe784687ce03cb2ecb6f1e60c8be585 Mon Sep 17 00:00:00 2001
From: "Frederick F. Kautz IV" <fkautz@alumni.cmu.edu>
Date: Mon, 2 Sep 2013 09:06:17 -0700
Subject: [PATCH 167/184] Offline Image Transfers #1155 Upstream-commit:
 7eaa59f626fa9e9b3bf61d3d7eff0fb70b3d011a Component: engine

---
 components/engine/api.go                      |  19 +++
 components/engine/commands.go                 |  38 +++++
 .../engine/docs/sources/commandline/cli.rst   |  22 +++
 components/engine/server.go                   | 149 ++++++++++++++++++
 4 files changed, 228 insertions(+)

diff --git a/components/engine/api.go b/components/engine/api.go
index 93322fd8aa..cf46ee316e 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -534,6 +534,23 @@ func postImagesPush(srv *Server, version float64, w http.ResponseWriter, r *http
 	return nil
 }
 
+func getImagesGet(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
+	name := vars["name"]
+	err := srv.ImageExport(name, w)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func postImagesLoad(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
+	err := srv.ImageLoad(r.Body)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 func postContainersCreate(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
 	if err := parseForm(r); err != nil {
 		return nil
@@ -1036,6 +1053,7 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			"/images/json":                    getImagesJSON,
 			"/images/viz":                     getImagesViz,
 			"/images/search":                  getImagesSearch,
+			"/images/{name:.*}/get":           getImagesGet,
 			"/images/{name:.*}/history":       getImagesHistory,
 			"/images/{name:.*}/json":          getImagesByName,
 			"/containers/ps":                  getContainersJSON,
@@ -1052,6 +1070,7 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			"/build":                        postBuild,
 			"/images/create":                postImagesCreate,
 			"/images/{name:.*}/insert":      postImagesInsert,
+			"/images/load":                  postImagesLoad,
 			"/images/{name:.*}/push":        postImagesPush,
 			"/images/{name:.*}/tag":         postImagesTag,
 			"/containers/create":            postContainersCreate,
diff --git a/components/engine/commands.go b/components/engine/commands.go
index 889aa72ffb..736334e40b 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -92,6 +92,7 @@ func (cli *DockerCli) CmdHelp(args ...string) error {
 		{"insert", "Insert a file in an image"},
 		{"inspect", "Return low-level information on a container"},
 		{"kill", "Kill a running container"},
+		{"load", "Load an image from a tar archive"},
 		{"login", "Register or Login to the docker registry server"},
 		{"logs", "Fetch the logs of a container"},
 		{"port", "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT"},
@@ -102,6 +103,7 @@ func (cli *DockerCli) CmdHelp(args ...string) error {
 		{"rm", "Remove one or more containers"},
 		{"rmi", "Remove one or more images"},
 		{"run", "Run a command in a new container"},
+		{"save", "Save an image to a tar archive"},
 		{"search", "Search for an image in the docker index"},
 		{"start", "Start a stopped container"},
 		{"stop", "Stop a running container"},
@@ -1961,6 +1963,42 @@ func (cli *DockerCli) CmdCp(args ...string) error {
 	return nil
 }
 
+func (cli *DockerCli) CmdSave(args ...string) error {
+	cmd := Subcmd("save", "IMAGE DESTINATION", "Save an image to a tar archive")
+	if err := cmd.Parse(args); err != nil {
+		cmd.Usage()
+		return nil
+	}
+
+	if cmd.NArg() != 1 {
+		cmd.Usage()
+		return nil
+	}
+
+	image := cmd.Arg(0)
+
+	if err := cli.stream("GET", "/images/"+image+"/get", nil, cli.out, nil); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cli *DockerCli) CmdLoad(args ...string) error {
+	cmd := Subcmd("load", "SOURCE", "Load an image from a tar archive")
+
+	if cmd.NArg() != 0 {
+		cmd.Usage()
+		return nil
+	}
+
+	err := cli.stream("POST", "/images/load", cli.in, cli.out, nil)
+	if err != nil {
+		fmt.Println("Send failed", err)
+	}
+
+	return nil
+}
+
 func (cli *DockerCli) call(method, path string, data interface{}) ([]byte, int, error) {
 	var params io.Reader
 	if data != nil {
diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index d0a8d83c0c..2adfe48f90 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -559,6 +559,17 @@ Known Issues (kill)
 * :issue:`197` indicates that ``docker kill`` may leave directories
   behind and make it difficult to remove the container.
 
+.. _cli_load:
+
+``load``
+--------
+
+::
+    Usage: docker load < repository.tar
+
+    Loads a tarred repository from the standard input stream.
+    Restores both images and tags.
+
 .. _cli_login:
 
 ``login``
@@ -852,6 +863,17 @@ Known Issues (run -volumes-from)
   could indicate a permissions problem with AppArmor. Please see the
   issue for a workaround.
 
+.. _cli_save:
+
+``save``
+
+::
+
+    Usage: docker save image > repository.tar
+
+    Streams a tarred repository to the standard output stream.
+    Contains all parent layers, and all tags + versions.
+
 .. _cli_search:
 
 ``search``
diff --git a/components/engine/server.go b/components/engine/server.go
index e9a76f8d84..ac6401b2da 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -197,6 +197,155 @@ func (srv *Server) ContainerExport(name string, out io.Writer) error {
 	return fmt.Errorf("No such container: %s", name)
 }
 
+// ImageExport exports all images with the given tag. All versions
+// containing the same tag are exported. The resulting output is an
+// uncompressed tar ball.
+// name is the set of tags to export.
+// out is the writer where the images are written to.
+func (srv *Server) ImageExport(name string, out io.Writer) error {
+	// get image json
+	tempdir, err := ioutil.TempDir("", "docker-export-")
+	if err != nil {
+		utils.Debugf("save", name, "")
+		return err
+	}
+	utils.Debugf("Serializing %s", name)
+
+	rootRepo := srv.runtime.repositories.Repositories[name]
+	for _, rootImage := range rootRepo {
+		image, _ := srv.ImageInspect(rootImage)
+		for i := image; i != nil; {
+			// temporary directory
+			tmpImageDir := path.Join(tempdir, i.ID)
+			os.Mkdir(tmpImageDir, os.ModeDir)
+
+			// serialize json
+			b, err := json.Marshal(i)
+			if err != nil {
+				utils.Debugf("%s", err)
+				os.RemoveAll(tempdir)
+				return err
+			}
+			ioutil.WriteFile(path.Join(tmpImageDir, "json"), b, os.ModeAppend)
+
+			// serialize filesystem
+			fs, err := Tar(path.Join(srv.runtime.graph.Root, i.ID, "layer"), Uncompressed)
+			if err != nil {
+				utils.Debugf("%s", err)
+				os.RemoveAll(tempdir)
+				return err
+			}
+			fsTar, err := os.Create(path.Join(tmpImageDir, "layer.tar"))
+			if err != nil {
+				os.RemoveAll(tempdir)
+				utils.Debugf("%s", err)
+				return err
+			}
+			_, err = io.Copy(fsTar, fs)
+			if err != nil {
+				utils.Debugf("%s", err)
+				os.RemoveAll(tempdir)
+				return err
+			}
+			fsTar.Close()
+
+			// find parent
+			if i.Parent != "" {
+				i, err = srv.ImageInspect(i.Parent)
+				if err != nil {
+					utils.Debugf("%s", err)
+					os.RemoveAll(tempdir)
+					return err
+				}
+			} else {
+				i = nil
+			}
+		}
+	}
+
+	// write repositories
+	rootRepoMap := map[string]Repository{}
+	rootRepoMap[name] = rootRepo
+	rootRepoJson, _ := json.Marshal(rootRepoMap)
+
+	ioutil.WriteFile(path.Join(tempdir, "repositories"), rootRepoJson, os.ModeAppend)
+
+	fs, err := Tar(tempdir, Uncompressed)
+	if err != nil {
+		os.RemoveAll(tempdir)
+		return err
+	}
+	if _, err := io.Copy(out, fs); err != nil {
+		os.RemoveAll(tempdir)
+		return err
+	}
+	os.RemoveAll(tempdir)
+	return nil
+}
+
+// Loads a set of images into the repository. This is the complementary of ImageExport.
+// The input stream is an uncompressed tar ball containing images and metadata.
+func (srv *Server) ImageLoad(in io.Reader) error {
+	tmpImageDir, _ := ioutil.TempDir("", "docker-import-")
+	repoTarFile := path.Join(tmpImageDir, "repo.tar")
+	repoDir := path.Join(tmpImageDir, "repo")
+	tarFile, _ := os.Create(repoTarFile)
+	io.Copy(tarFile, in)
+	tarFile.Close()
+	repoFile, _ := os.Open(repoTarFile)
+	os.Mkdir(repoDir, os.ModeDir)
+	Untar(repoFile, repoDir)
+	repositoriesJson, _ := ioutil.ReadFile(path.Join(tmpImageDir, "repo", "repositories"))
+	repositories := map[string]Repository{}
+	json.Unmarshal(repositoriesJson, &repositories)
+
+	for imageName, tagMap := range repositories {
+		for tag, address := range tagMap {
+			err := srv.recursiveLoad(address, tmpImageDir)
+			if err != nil {
+				utils.Debugf("Error loading repository")
+			}
+			srv.runtime.repositories.Set(imageName, tag, address, true)
+		}
+	}
+	os.RemoveAll(tmpImageDir)
+	return nil
+}
+
+func (srv *Server) recursiveLoad(address, tmpImageDir string) error {
+	_, err := srv.ImageInspect(address)
+	utils.Debugf("Attempting to load %s", "address")
+	if err != nil {
+		utils.Debugf("Loading %s", address)
+		imageJson, err := ioutil.ReadFile(path.Join(tmpImageDir, "repo", address, "json"))
+		if err != nil {
+			return err
+			utils.Debugf("Error reading json", err)
+		}
+		layer, err := os.Open(path.Join(tmpImageDir, "repo", address, "layer.tar"))
+		if err != nil {
+			utils.Debugf("Error reading embedded tar", err)
+			return err
+		}
+		img, err := NewImgJSON(imageJson)
+		if err != nil {
+			utils.Debugf("Error unmarshalling json", err)
+			return err
+		}
+		if img.Parent != "" {
+			if !srv.runtime.graph.Exists(img.Parent) {
+				srv.recursiveLoad(img.Parent, tmpImageDir)
+			}
+		}
+		err = srv.runtime.graph.Register(imageJson, layer, img)
+		if err != nil {
+			utils.Debugf("Error registering image")
+		}
+	}
+	utils.Debugf("Completed processing %s", address)
+	return nil
+}
+
 func (srv *Server) ImagesSearch(term string) ([]registry.SearchResult, error) {
 	r, err := registry.NewRegistry(srv.runtime.config.Root, nil, srv.HTTPRequestFactory(nil))
 	if err != nil {

From bac700fc36af068f46da93512c59f92629c89f91 Mon Sep 17 00:00:00 2001
From: "Frederick F. Kautz IV" <fkautz@alumni.cmu.edu>
Date: Fri, 11 Oct 2013 22:11:49 -0700
Subject: [PATCH 168/184] Adding version info, switching to defer for cleanup
 Upstream-commit: 61a8020e51ac6de9bc777098a04e05a185c2cd32 Component: engine

---
 components/engine/server.go | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index ac6401b2da..564ae7c0fb 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -218,12 +218,15 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 			// temporary directory
 			tmpImageDir := path.Join(tempdir, i.ID)
 			os.Mkdir(tmpImageDir, os.ModeDir)
+			defer os.RemoveAll(tempdir)
+			var version = "0.7"
+			var versionBuf = []byte(version)
+			ioutil.WriteFile(path.Join(tmpImageDir, "VERSION"), versionBuf, os.ModeAppend)
 
 			// serialize json
 			b, err := json.Marshal(i)
 			if err != nil {
 				utils.Debugf("%s", err)
-				os.RemoveAll(tempdir)
 				return err
 			}
 			ioutil.WriteFile(path.Join(tmpImageDir, "json"), b, os.ModeAppend)
@@ -232,19 +235,16 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 			fs, err := Tar(path.Join(srv.runtime.graph.Root, i.ID, "layer"), Uncompressed)
 			if err != nil {
 				utils.Debugf("%s", err)
-				os.RemoveAll(tempdir)
 				return err
 			}
 			fsTar, err := os.Create(path.Join(tmpImageDir, "layer.tar"))
 			if err != nil {
-				os.RemoveAll(tempdir)
 				utils.Debugf("%s", err)
 				return err
 			}
 			_, err = io.Copy(fsTar, fs)
 			if err != nil {
 				utils.Debugf("%s", err)
-				os.RemoveAll(tempdir)
 				return err
 			}
 			fsTar.Close()
@@ -254,7 +254,6 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 				i, err = srv.ImageInspect(i.Parent)
 				if err != nil {
 					utils.Debugf("%s", err)
-					os.RemoveAll(tempdir)
 					return err
 				}
 			} else {
@@ -271,15 +270,13 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 	ioutil.WriteFile(path.Join(tempdir, "repositories"), rootRepoJson, os.ModeAppend)
 
 	fs, err := Tar(tempdir, Uncompressed)
+	defer os.RemoveAll(tempdir)
 	if err != nil {
-		os.RemoveAll(tempdir)
 		return err
 	}
 	if _, err := io.Copy(out, fs); err != nil {
-		os.RemoveAll(tempdir)
 		return err
 	}
-	os.RemoveAll(tempdir)
 	return nil
 }
 
@@ -287,6 +284,7 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 // The input stream is an uncompressed tar ball containing images and metadata.
 func (srv *Server) ImageLoad(in io.Reader) error {
 	tmpImageDir, _ := ioutil.TempDir("", "docker-import-")
+	defer os.RemoveAll(tmpImageDir)
 	repoTarFile := path.Join(tmpImageDir, "repo.tar")
 	repoDir := path.Join(tmpImageDir, "repo")
 	tarFile, _ := os.Create(repoTarFile)
@@ -308,7 +306,6 @@ func (srv *Server) ImageLoad(in io.Reader) error {
 			srv.runtime.repositories.Set(imageName, tag, address, true)
 		}
 	}
-	os.RemoveAll(tmpImageDir)
 	return nil
 }
 

From 9f3f2484044f3c7e3d22f041b0551667e5d127ef Mon Sep 17 00:00:00 2001
From: "Frederick F. Kautz IV" <fkautz@alumni.cmu.edu>
Date: Sat, 2 Nov 2013 01:18:55 -0700
Subject: [PATCH 169/184] Adding spaces to fix docs build Upstream-commit:
 bf504f2afab679922e92b8bb5fe28957f5f6bf02 Component: engine

---
 components/engine/docs/sources/commandline/cli.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/engine/docs/sources/commandline/cli.rst b/components/engine/docs/sources/commandline/cli.rst
index 2adfe48f90..c25b890faf 100644
--- a/components/engine/docs/sources/commandline/cli.rst
+++ b/components/engine/docs/sources/commandline/cli.rst
@@ -565,6 +565,7 @@ Known Issues (kill)
 --------
 
 ::
+
     Usage: docker load < repository.tar
 
     Loads a tarred repository from the standard input stream.

From 623a7ac7d40b232f20cbc5f2546a2b237ef00ebc Mon Sep 17 00:00:00 2001
From: "Frederick F. Kautz IV" <fkautz@alumni.cmu.edu>
Date: Mon, 4 Nov 2013 17:43:57 -0800
Subject: [PATCH 170/184] Setting offline package version to 1.0
 Upstream-commit: 6014db4a7e8d76580edf995bc974a55dace0c8ba Component: engine

---
 components/engine/server.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index 564ae7c0fb..a457550387 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -219,7 +219,7 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 			tmpImageDir := path.Join(tempdir, i.ID)
 			os.Mkdir(tmpImageDir, os.ModeDir)
 			defer os.RemoveAll(tempdir)
-			var version = "0.7"
+			var version = "1.0"
 			var versionBuf = []byte(version)
 			ioutil.WriteFile(path.Join(tmpImageDir, "VERSION"), versionBuf, os.ModeAppend)
 

From 5b716c3df7cff1777194aaae38ec1aa2b5f91851 Mon Sep 17 00:00:00 2001
From: "Frederick F. Kautz IV" <fkautz@alumni.cmu.edu>
Date: Wed, 13 Nov 2013 23:41:42 +0000
Subject: [PATCH 171/184] Fixing build Upstream-commit:
 844c13bce6429087e2763038136e6485da425741 Component: engine

---
 components/engine/server.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index a457550387..46d27b2ae8 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -232,7 +232,7 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 			ioutil.WriteFile(path.Join(tmpImageDir, "json"), b, os.ModeAppend)
 
 			// serialize filesystem
-			fs, err := Tar(path.Join(srv.runtime.graph.Root, i.ID, "layer"), Uncompressed)
+			fs, err := archive.Tar(path.Join(srv.runtime.graph.Root, i.ID, "layer"), archive.Uncompressed)
 			if err != nil {
 				utils.Debugf("%s", err)
 				return err
@@ -269,7 +269,7 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 
 	ioutil.WriteFile(path.Join(tempdir, "repositories"), rootRepoJson, os.ModeAppend)
 
-	fs, err := Tar(tempdir, Uncompressed)
+	fs, err := archive.Tar(tempdir, archive.Uncompressed)
 	defer os.RemoveAll(tempdir)
 	if err != nil {
 		return err
@@ -292,7 +292,7 @@ func (srv *Server) ImageLoad(in io.Reader) error {
 	tarFile.Close()
 	repoFile, _ := os.Open(repoTarFile)
 	os.Mkdir(repoDir, os.ModeDir)
-	Untar(repoFile, repoDir)
+	archive.Untar(repoFile, repoDir)
 	repositoriesJson, _ := ioutil.ReadFile(path.Join(tmpImageDir, "repo", "repositories"))
 	repositories := map[string]Repository{}
 	json.Unmarshal(repositoriesJson, &repositories)

From b7d4ec1f01110ef94615181167d2607e4624db7e Mon Sep 17 00:00:00 2001
From: "Frederick F. Kautz IV" <fkautz@alumni.cmu.edu>
Date: Thu, 14 Nov 2013 01:05:37 +0000
Subject: [PATCH 172/184] Adding content type to images/(name)/get
 Upstream-commit: 1211065c8d81fcc480ddea5d377982cab871d472 Component: engine

---
 components/engine/api.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/components/engine/api.go b/components/engine/api.go
index cf46ee316e..74388d805b 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -536,6 +536,9 @@ func postImagesPush(srv *Server, version float64, w http.ResponseWriter, r *http
 
 func getImagesGet(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
 	name := vars["name"]
+	if version > 1.0 {
+		w.Header().Set("Content-Type", "application/x-tar")
+	}
 	err := srv.ImageExport(name, w)
 	if err != nil {
 		return err

From 46ebe14722544366a1667b1e46c27aacb9d001ca Mon Sep 17 00:00:00 2001
From: "Frederick F. Kautz IV" <fkautz@alumni.cmu.edu>
Date: Thu, 14 Nov 2013 01:05:46 +0000
Subject: [PATCH 173/184] Adding 1.7 documentation Upstream-commit:
 383f95bba1fef213473725fdf6193be0de5b73fd Component: engine

---
 .../sources/api/docker_remote_api_v1.7.rst    | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/components/engine/docs/sources/api/docker_remote_api_v1.7.rst b/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
index 13aa5df71b..251b162250 100644
--- a/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
+++ b/components/engine/docs/sources/api/docker_remote_api_v1.7.rst
@@ -1171,6 +1171,53 @@ Monitor Docker's events
         :statuscode 200: no error
         :statuscode 500: server error
 
+Get a tarball containing all images and tags in a repository
+************************************************************
+
+.. http:get:: /images/(name)/get
+
+  Get a tarball containing all images and metadata for the repository specified by ``name``.
+
+  **Example request**
+
+  .. sourcecode:: http
+  
+           GET /images/ubuntu/get
+
+       **Example response**:
+
+       .. sourcecode:: http
+
+          HTTP/1.1 200 OK
+    Content-Type: application/x-tar
+
+    Binary data stream
+        :statuscode 200: no error
+        :statuscode 500: server error
+
+Load a tarball with a set of images and tags into docker
+********************************************************
+
+.. http:post:: /images/load
+
+  Load a set of images and tags into the docker repository.
+
+  **Example request**
+
+  .. sourcecode:: http
+
+           POST /images/load
+
+         Tarball in body
+
+       **Example response**:
+
+       .. sourcecode:: http
+
+          HTTP/1.1 200 OK
+
+        :statuscode 200: no error
+        :statuscode 500: server error
 
 3. Going further
 ================

From 3f60be4255f0465b2584844783aecf89f187ff6d Mon Sep 17 00:00:00 2001
From: Michael Crosby <crosby.michael@gmail.com>
Date: Mon, 18 Nov 2013 11:48:55 -0800
Subject: [PATCH 174/184] Fix error checks for offline transfer and remove
 unneeded debug output Upstream-commit:
 0ef6fed5c7b7b1ab4084ecc99880ffc6a7c8eaca Component: engine

---
 components/engine/server.go | 100 ++++++++++++++++++++++++------------
 1 file changed, 66 insertions(+), 34 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index 46d27b2ae8..8b34c024df 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -206,7 +206,6 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 	// get image json
 	tempdir, err := ioutil.TempDir("", "docker-export-")
 	if err != nil {
-		utils.Debugf("save", name, "")
 		return err
 	}
 	utils.Debugf("Serializing %s", name)
@@ -217,34 +216,38 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 		for i := image; i != nil; {
 			// temporary directory
 			tmpImageDir := path.Join(tempdir, i.ID)
-			os.Mkdir(tmpImageDir, os.ModeDir)
+			if err := os.Mkdir(tmpImageDir, os.ModeDir); err != nil {
+				return err
+			}
 			defer os.RemoveAll(tempdir)
+
 			var version = "1.0"
 			var versionBuf = []byte(version)
-			ioutil.WriteFile(path.Join(tmpImageDir, "VERSION"), versionBuf, os.ModeAppend)
+
+			if err := ioutil.WriteFile(path.Join(tmpImageDir, "VERSION"), versionBuf, os.ModeAppend); err != nil {
+				return err
+			}
 
 			// serialize json
 			b, err := json.Marshal(i)
 			if err != nil {
-				utils.Debugf("%s", err)
 				return err
 			}
-			ioutil.WriteFile(path.Join(tmpImageDir, "json"), b, os.ModeAppend)
+			if err := ioutil.WriteFile(path.Join(tmpImageDir, "json"), b, os.ModeAppend); err != nil {
+				return err
+			}
 
 			// serialize filesystem
 			fs, err := archive.Tar(path.Join(srv.runtime.graph.Root, i.ID, "layer"), archive.Uncompressed)
 			if err != nil {
-				utils.Debugf("%s", err)
 				return err
 			}
+
 			fsTar, err := os.Create(path.Join(tmpImageDir, "layer.tar"))
 			if err != nil {
-				utils.Debugf("%s", err)
 				return err
 			}
-			_, err = io.Copy(fsTar, fs)
-			if err != nil {
-				utils.Debugf("%s", err)
+			if _, err = io.Copy(fsTar, fs); err != nil {
 				return err
 			}
 			fsTar.Close()
@@ -253,7 +256,6 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 			if i.Parent != "" {
 				i, err = srv.ImageInspect(i.Parent)
 				if err != nil {
-					utils.Debugf("%s", err)
 					return err
 				}
 			} else {
@@ -267,13 +269,16 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 	rootRepoMap[name] = rootRepo
 	rootRepoJson, _ := json.Marshal(rootRepoMap)
 
-	ioutil.WriteFile(path.Join(tempdir, "repositories"), rootRepoJson, os.ModeAppend)
+	if err := ioutil.WriteFile(path.Join(tempdir, "repositories"), rootRepoJson, os.ModeAppend); err != nil {
+		return err
+	}
 
 	fs, err := archive.Tar(tempdir, archive.Uncompressed)
-	defer os.RemoveAll(tempdir)
 	if err != nil {
 		return err
 	}
+	defer os.RemoveAll(tempdir)
+
 	if _, err := io.Copy(out, fs); err != nil {
 		return err
 	}
@@ -283,42 +288,68 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 // Loads a set of images into the repository. This is the complementary of ImageExport.
 // The input stream is an uncompressed tar ball containing images and metadata.
 func (srv *Server) ImageLoad(in io.Reader) error {
-	tmpImageDir, _ := ioutil.TempDir("", "docker-import-")
+	tmpImageDir, err := ioutil.TempDir("", "docker-import-")
+	if err != nil {
+		return err
+	}
 	defer os.RemoveAll(tmpImageDir)
-	repoTarFile := path.Join(tmpImageDir, "repo.tar")
-	repoDir := path.Join(tmpImageDir, "repo")
-	tarFile, _ := os.Create(repoTarFile)
-	io.Copy(tarFile, in)
+
+	var (
+		repoTarFile = path.Join(tmpImageDir, "repo.tar")
+		repoDir     = path.Join(tmpImageDir, "repo")
+	)
+
+	tarFile, err := os.Create(repoTarFile)
+	if err != nil {
+		return err
+	}
+	if _, err := io.Copy(tarFile, in); err != nil {
+		return err
+	}
 	tarFile.Close()
-	repoFile, _ := os.Open(repoTarFile)
-	os.Mkdir(repoDir, os.ModeDir)
-	archive.Untar(repoFile, repoDir)
-	repositoriesJson, _ := ioutil.ReadFile(path.Join(tmpImageDir, "repo", "repositories"))
+
+	repoFile, err := os.Open(repoTarFile)
+	if err != nil {
+		return err
+	}
+	if err := os.Mkdir(repoDir, os.ModeDir); err != nil {
+		return err
+	}
+	if err := archive.Untar(repoFile, repoDir); err != nil {
+		return err
+	}
+	repositoriesJson, err := ioutil.ReadFile(path.Join(tmpImageDir, "repo", "repositories"))
+	if err != nil {
+		return err
+	}
 	repositories := map[string]Repository{}
-	json.Unmarshal(repositoriesJson, &repositories)
+	if err := json.Unmarshal(repositoriesJson, &repositories); err != nil {
+		return err
+	}
 
 	for imageName, tagMap := range repositories {
 		for tag, address := range tagMap {
-			err := srv.recursiveLoad(address, tmpImageDir)
-			if err != nil {
-				utils.Debugf("Error loading repository")
+			if err := srv.recursiveLoad(address, tmpImageDir); err != nil {
+				return err
+			}
+			if err := srv.runtime.repositories.Set(imageName, tag, address, true); err != nil {
+				return err
 			}
-			srv.runtime.repositories.Set(imageName, tag, address, true)
 		}
 	}
 	return nil
 }
 
 func (srv *Server) recursiveLoad(address, tmpImageDir string) error {
-	_, err := srv.ImageInspect(address)
-	utils.Debugf("Attempting to load %s", "address")
-	if err != nil {
+	if _, err := srv.ImageInspect(address); err != nil {
 		utils.Debugf("Loading %s", address)
+
 		imageJson, err := ioutil.ReadFile(path.Join(tmpImageDir, "repo", address, "json"))
 		if err != nil {
 			return err
 			utils.Debugf("Error reading json", err)
 		}
+
 		layer, err := os.Open(path.Join(tmpImageDir, "repo", address, "layer.tar"))
 		if err != nil {
 			utils.Debugf("Error reading embedded tar", err)
@@ -331,12 +362,13 @@ func (srv *Server) recursiveLoad(address, tmpImageDir string) error {
 		}
 		if img.Parent != "" {
 			if !srv.runtime.graph.Exists(img.Parent) {
-				srv.recursiveLoad(img.Parent, tmpImageDir)
+				if err := srv.recursiveLoad(img.Parent, tmpImageDir); err != nil {
+					return err
+				}
 			}
 		}
-		err = srv.runtime.graph.Register(imageJson, layer, img)
-		if err != nil {
-			utils.Debugf("Error registering image")
+		if err := srv.runtime.graph.Register(imageJson, layer, img); err != nil {
+			return err
 		}
 	}
 	utils.Debugf("Completed processing %s", address)

From 92e4e393e605b4296bd1e336f83234a0c24169bd Mon Sep 17 00:00:00 2001
From: Michael Crosby <crosby.michael@gmail.com>
Date: Mon, 18 Nov 2013 12:34:34 -0800
Subject: [PATCH 175/184] Add typo in remove all. Ensure tmpDir is removed
 Upstream-commit: 9de45904980dba224e8ab133f12cfc53835e2dd4 Component: engine

---
 components/engine/server.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index 8b34c024df..de6520c24f 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -208,6 +208,8 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 	if err != nil {
 		return err
 	}
+	defer os.RemoveAll(tempdir)
+
 	utils.Debugf("Serializing %s", name)
 
 	rootRepo := srv.runtime.repositories.Repositories[name]
@@ -219,7 +221,7 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 			if err := os.Mkdir(tmpImageDir, os.ModeDir); err != nil {
 				return err
 			}
-			defer os.RemoveAll(tempdir)
+			defer os.RemoveAll(tmpImageDir)
 
 			var version = "1.0"
 			var versionBuf = []byte(version)
@@ -277,7 +279,6 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 	if err != nil {
 		return err
 	}
-	defer os.RemoveAll(tempdir)
 
 	if _, err := io.Copy(out, fs); err != nil {
 		return err

From 5763c9619e8d87cf061126bfa903c799d2ad5dc7 Mon Sep 17 00:00:00 2001
From: Josh Poimboeuf <jpoimboe@redhat.com>
Date: Wed, 20 Nov 2013 11:27:43 -0600
Subject: [PATCH 176/184] resize pty after starting

Since ptyMaster is created during container start (startPty), it should
resized after starting, not before.
Upstream-commit: 171d681724443cf69f669dcaf4887f5d99894b25
Component: engine
---
 components/engine/commands.go | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index 736334e40b..0539be9006 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -575,6 +575,7 @@ func (cli *DockerCli) CmdStart(args ...string) error {
 	}
 
 	var cErr chan error
+	var tty bool
 	if *attach || *openStdin {
 		if cmd.NArg() > 1 {
 			return fmt.Errorf("Impossible to start and attach multiple containers at once.")
@@ -591,17 +592,13 @@ func (cli *DockerCli) CmdStart(args ...string) error {
 			return err
 		}
 
+		tty = container.Config.Tty
+
 		if !container.Config.Tty {
 			sigc := cli.forwardAllSignals(cmd.Arg(0))
 			defer utils.StopCatch(sigc)
 		}
 
-		if container.Config.Tty && cli.isTerminal {
-			if err := cli.monitorTtySize(cmd.Arg(0)); err != nil {
-				return err
-			}
-		}
-
 		var in io.ReadCloser
 
 		v := url.Values{}
@@ -639,7 +636,13 @@ func (cli *DockerCli) CmdStart(args ...string) error {
 		}
 		return encounteredError
 	}
+
 	if *openStdin || *attach {
+		if tty && cli.isTerminal {
+			if err := cli.monitorTtySize(cmd.Arg(0)); err != nil {
+				utils.Errorf("Error monitoring TTY size: %s\n", err)
+			}
+		}
 		return <-cErr
 	}
 	return nil

From 10c7f8443261d7f2358bb38ef0f6c61505e02d41 Mon Sep 17 00:00:00 2001
From: Michael Crosby <crosby.michael@gmail.com>
Date: Wed, 20 Nov 2013 17:28:19 -0800
Subject: [PATCH 177/184] Allow images to be saved and loaded by id and
 repository Upstream-commit: fd7ab143bf1ecfbf20df90edd876f73dc28c264d
 Component: engine

---
 components/engine/api.go      |  12 +--
 components/engine/commands.go |  13 ++-
 components/engine/server.go   | 163 +++++++++++++++++++++-------------
 3 files changed, 108 insertions(+), 80 deletions(-)

diff --git a/components/engine/api.go b/components/engine/api.go
index 3bbcdfd43d..1104b787b8 100644
--- a/components/engine/api.go
+++ b/components/engine/api.go
@@ -539,19 +539,11 @@ func getImagesGet(srv *Server, version float64, w http.ResponseWriter, r *http.R
 	if version > 1.0 {
 		w.Header().Set("Content-Type", "application/x-tar")
 	}
-	err := srv.ImageExport(name, w)
-	if err != nil {
-		return err
-	}
-	return nil
+	return srv.ImageExport(name, w)
 }
 
 func postImagesLoad(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	err := srv.ImageLoad(r.Body)
-	if err != nil {
-		return err
-	}
-	return nil
+	return srv.ImageLoad(r.Body)
 }
 
 func postContainersCreate(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
diff --git a/components/engine/commands.go b/components/engine/commands.go
index 752ed82906..3b56f74e5d 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1969,8 +1969,7 @@ func (cli *DockerCli) CmdCp(args ...string) error {
 func (cli *DockerCli) CmdSave(args ...string) error {
 	cmd := Subcmd("save", "IMAGE DESTINATION", "Save an image to a tar archive")
 	if err := cmd.Parse(args); err != nil {
-		cmd.Usage()
-		return nil
+		return err
 	}
 
 	if cmd.NArg() != 1 {
@@ -1979,7 +1978,6 @@ func (cli *DockerCli) CmdSave(args ...string) error {
 	}
 
 	image := cmd.Arg(0)
-
 	if err := cli.stream("GET", "/images/"+image+"/get", nil, cli.out, nil); err != nil {
 		return err
 	}
@@ -1988,17 +1986,18 @@ func (cli *DockerCli) CmdSave(args ...string) error {
 
 func (cli *DockerCli) CmdLoad(args ...string) error {
 	cmd := Subcmd("load", "SOURCE", "Load an image from a tar archive")
+	if err := cmd.Parse(args); err != nil {
+		return err
+	}
 
 	if cmd.NArg() != 0 {
 		cmd.Usage()
 		return nil
 	}
 
-	err := cli.stream("POST", "/images/load", cli.in, cli.out, nil)
-	if err != nil {
-		fmt.Println("Send failed", err)
+	if err := cli.stream("POST", "/images/load", cli.in, cli.out, nil); err != nil {
+		return err
 	}
-
 	return nil
 }
 
diff --git a/components/engine/server.go b/components/engine/server.go
index 4cc808bb52..39c6dfdc6d 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -212,67 +212,38 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 
 	utils.Debugf("Serializing %s", name)
 
-	rootRepo := srv.runtime.repositories.Repositories[name]
-	for _, rootImage := range rootRepo {
-		image, _ := srv.ImageInspect(rootImage)
-		for i := image; i != nil; {
-			// temporary directory
-			tmpImageDir := path.Join(tempdir, i.ID)
-			if err := os.Mkdir(tmpImageDir, os.ModeDir); err != nil {
-				return err
-			}
-			defer os.RemoveAll(tmpImageDir)
-
-			var version = "1.0"
-			var versionBuf = []byte(version)
-
-			if err := ioutil.WriteFile(path.Join(tmpImageDir, "VERSION"), versionBuf, os.ModeAppend); err != nil {
-				return err
-			}
-
-			// serialize json
-			b, err := json.Marshal(i)
-			if err != nil {
-				return err
-			}
-			if err := ioutil.WriteFile(path.Join(tmpImageDir, "json"), b, os.ModeAppend); err != nil {
-				return err
-			}
-
-			// serialize filesystem
-			fs, err := archive.Tar(path.Join(srv.runtime.graph.Root, i.ID, "layer"), archive.Uncompressed)
+	rootRepo, err := srv.runtime.repositories.Get(name)
+	if err != nil {
+		return err
+	}
+	if rootRepo != nil {
+		for _, id := range rootRepo {
+			image, err := srv.ImageInspect(id)
 			if err != nil {
 				return err
 			}
 
-			fsTar, err := os.Create(path.Join(tmpImageDir, "layer.tar"))
-			if err != nil {
+			if err := srv.exportImage(image, tempdir); err != nil {
 				return err
 			}
-			if _, err = io.Copy(fsTar, fs); err != nil {
-				return err
-			}
-			fsTar.Close()
-
-			// find parent
-			if i.Parent != "" {
-				i, err = srv.ImageInspect(i.Parent)
-				if err != nil {
-					return err
-				}
-			} else {
-				i = nil
-			}
 		}
-	}
 
-	// write repositories
-	rootRepoMap := map[string]Repository{}
-	rootRepoMap[name] = rootRepo
-	rootRepoJson, _ := json.Marshal(rootRepoMap)
+		// write repositories
+		rootRepoMap := map[string]Repository{}
+		rootRepoMap[name] = rootRepo
+		rootRepoJson, _ := json.Marshal(rootRepoMap)
 
-	if err := ioutil.WriteFile(path.Join(tempdir, "repositories"), rootRepoJson, os.ModeAppend); err != nil {
-		return err
+		if err := ioutil.WriteFile(path.Join(tempdir, "repositories"), rootRepoJson, os.ModeAppend); err != nil {
+			return err
+		}
+	} else {
+		image, err := srv.ImageInspect(name)
+		if err != nil {
+			return err
+		}
+		if err := srv.exportImage(image, tempdir); err != nil {
+			return err
+		}
 	}
 
 	fs, err := archive.Tar(tempdir, archive.Uncompressed)
@@ -286,6 +257,58 @@ func (srv *Server) ImageExport(name string, out io.Writer) error {
 	return nil
 }
 
+func (srv *Server) exportImage(image *Image, tempdir string) error {
+	for i := image; i != nil; {
+		// temporary directory
+		tmpImageDir := path.Join(tempdir, i.ID)
+		if err := os.Mkdir(tmpImageDir, os.ModeDir); err != nil {
+			return err
+		}
+
+		var version = "1.0"
+		var versionBuf = []byte(version)
+
+		if err := ioutil.WriteFile(path.Join(tmpImageDir, "VERSION"), versionBuf, os.ModeAppend); err != nil {
+			return err
+		}
+
+		// serialize json
+		b, err := json.Marshal(i)
+		if err != nil {
+			return err
+		}
+		if err := ioutil.WriteFile(path.Join(tmpImageDir, "json"), b, os.ModeAppend); err != nil {
+			return err
+		}
+
+		// serialize filesystem
+		fs, err := archive.Tar(path.Join(srv.runtime.graph.Root, i.ID, "layer"), archive.Uncompressed)
+		if err != nil {
+			return err
+		}
+
+		fsTar, err := os.Create(path.Join(tmpImageDir, "layer.tar"))
+		if err != nil {
+			return err
+		}
+		if _, err = io.Copy(fsTar, fs); err != nil {
+			return err
+		}
+		fsTar.Close()
+
+		// find parent
+		if i.Parent != "" {
+			i, err = srv.ImageInspect(i.Parent)
+			if err != nil {
+				return err
+			}
+		} else {
+			i = nil
+		}
+	}
+	return nil
+}
+
 // Loads a set of images into the repository. This is the complementary of ImageExport.
 // The input stream is an uncompressed tar ball containing images and metadata.
 func (srv *Server) ImageLoad(in io.Reader) error {
@@ -319,25 +342,38 @@ func (srv *Server) ImageLoad(in io.Reader) error {
 	if err := archive.Untar(repoFile, repoDir); err != nil {
 		return err
 	}
-	repositoriesJson, err := ioutil.ReadFile(path.Join(tmpImageDir, "repo", "repositories"))
+
+	dirs, err := ioutil.ReadDir(repoDir)
 	if err != nil {
 		return err
 	}
-	repositories := map[string]Repository{}
-	if err := json.Unmarshal(repositoriesJson, &repositories); err != nil {
-		return err
-	}
 
-	for imageName, tagMap := range repositories {
-		for tag, address := range tagMap {
-			if err := srv.recursiveLoad(address, tmpImageDir); err != nil {
-				return err
-			}
-			if err := srv.runtime.repositories.Set(imageName, tag, address, true); err != nil {
+	for _, d := range dirs {
+		if d.IsDir() {
+			if err := srv.recursiveLoad(d.Name(), tmpImageDir); err != nil {
 				return err
 			}
 		}
 	}
+
+	repositoriesJson, err := ioutil.ReadFile(path.Join(tmpImageDir, "repo", "repositories"))
+	if err == nil {
+		repositories := map[string]Repository{}
+		if err := json.Unmarshal(repositoriesJson, &repositories); err != nil {
+			return err
+		}
+
+		for imageName, tagMap := range repositories {
+			for tag, address := range tagMap {
+				if err := srv.runtime.repositories.Set(imageName, tag, address, true); err != nil {
+					return err
+				}
+			}
+		}
+	} else if !os.IsNotExist(err) {
+		return err
+	}
+
 	return nil
 }
 
@@ -373,6 +409,7 @@ func (srv *Server) recursiveLoad(address, tmpImageDir string) error {
 		}
 	}
 	utils.Debugf("Completed processing %s", address)
+
 	return nil
 }
 

From 7a482f2a8ca38748855246da1f8db299200d50c5 Mon Sep 17 00:00:00 2001
From: Paul Nasrat <pnasrat@gmail.com>
Date: Thu, 21 Nov 2013 08:06:02 -0500
Subject: [PATCH 178/184] Lock state before we modify.

When we start a container we lock state, we should do the same in stop.

Detected via -race.
Upstream-commit: d7e2fc898284fe29ed43f7b28eae56e7e052e854
Component: engine
---
 components/engine/container.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/components/engine/container.go b/components/engine/container.go
index 16f45cb490..d6b73f57cb 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -1300,7 +1300,9 @@ func (container *Container) monitor() {
 	}
 
 	// Report status back
+	container.State.Lock()
 	container.State.setStopped(exitCode)
+	container.State.Unlock()
 
 	// Release the lock
 	close(container.waitLock)

From 06096928cc0cbe271562193745852f931e0ec7a7 Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Wed, 20 Nov 2013 17:41:25 -0800
Subject: [PATCH 179/184] Return status exit status 2 on usage, move parserun
 into commands.go, display usage on stderr Upstream-commit:
 75a7f4d90cde0295bcfb7213004abce8d4779b75 Component: engine

---
 components/engine/commands.go  | 288 ++++++++++++++++++++++++++++-----
 components/engine/container.go | 213 ------------------------
 2 files changed, 252 insertions(+), 249 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index a551d598c9..3473053e0d 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -22,6 +22,7 @@ import (
 	"net/url"
 	"os"
 	"os/signal"
+	"path"
 	"path/filepath"
 	"reflect"
 	"regexp"
@@ -119,7 +120,7 @@ func (cli *DockerCli) CmdHelp(args ...string) error {
 }
 
 func (cli *DockerCli) CmdInsert(args ...string) error {
-	cmd := Subcmd("insert", "IMAGE URL PATH", "Insert a file from URL in the IMAGE at PATH")
+	cmd := cli.Subcmd("insert", "IMAGE URL PATH", "Insert a file from URL in the IMAGE at PATH")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -161,7 +162,7 @@ func MkBuildContext(dockerfile string, files [][2]string) (archive.Archive, erro
 }
 
 func (cli *DockerCli) CmdBuild(args ...string) error {
-	cmd := Subcmd("build", "[OPTIONS] PATH | URL | -", "Build a new container image from the source code at PATH")
+	cmd := cli.Subcmd("build", "[OPTIONS] PATH | URL | -", "Build a new container image from the source code at PATH")
 	tag := cmd.String("t", "", "Repository name (and optionally a tag) to be applied to the resulting image in case of success")
 	suppressOutput := cmd.Bool("q", false, "Suppress verbose build output")
 	noCache := cmd.Bool("no-cache", false, "Do not use cache when building the image")
@@ -259,7 +260,7 @@ func (cli *DockerCli) CmdBuild(args ...string) error {
 
 // 'docker login': login / register a user to registry service.
 func (cli *DockerCli) CmdLogin(args ...string) error {
-	cmd := Subcmd("login", "[OPTIONS] [SERVER]", "Register or Login to a docker registry server, if no server is specified \""+auth.IndexServerAddress()+"\" is the default.")
+	cmd := cli.Subcmd("login", "[OPTIONS] [SERVER]", "Register or Login to a docker registry server, if no server is specified \""+auth.IndexServerAddress()+"\" is the default.")
 
 	var username, password, email string
 
@@ -367,7 +368,7 @@ func (cli *DockerCli) CmdLogin(args ...string) error {
 
 // 'docker wait': block until a container stops
 func (cli *DockerCli) CmdWait(args ...string) error {
-	cmd := Subcmd("wait", "CONTAINER [CONTAINER...]", "Block until a container stops, then print its exit code.")
+	cmd := cli.Subcmd("wait", "CONTAINER [CONTAINER...]", "Block until a container stops, then print its exit code.")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -390,7 +391,7 @@ func (cli *DockerCli) CmdWait(args ...string) error {
 
 // 'docker version': show version information
 func (cli *DockerCli) CmdVersion(args ...string) error {
-	cmd := Subcmd("version", "", "Show the docker version information.")
+	cmd := cli.Subcmd("version", "", "Show the docker version information.")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -441,7 +442,7 @@ func (cli *DockerCli) CmdVersion(args ...string) error {
 
 // 'docker info': display system-wide information.
 func (cli *DockerCli) CmdInfo(args ...string) error {
-	cmd := Subcmd("info", "", "Display system-wide information")
+	cmd := cli.Subcmd("info", "", "Display system-wide information")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -493,7 +494,7 @@ func (cli *DockerCli) CmdInfo(args ...string) error {
 }
 
 func (cli *DockerCli) CmdStop(args ...string) error {
-	cmd := Subcmd("stop", "[OPTIONS] CONTAINER [CONTAINER...]", "Stop a running container (Send SIGTERM, and then SIGKILL after grace period)")
+	cmd := cli.Subcmd("stop", "[OPTIONS] CONTAINER [CONTAINER...]", "Stop a running container (Send SIGTERM, and then SIGKILL after grace period)")
 	nSeconds := cmd.Int("t", 10, "Number of seconds to wait for the container to stop before killing it.")
 	if err := cmd.Parse(args); err != nil {
 		return nil
@@ -520,7 +521,7 @@ func (cli *DockerCli) CmdStop(args ...string) error {
 }
 
 func (cli *DockerCli) CmdRestart(args ...string) error {
-	cmd := Subcmd("restart", "[OPTIONS] CONTAINER [CONTAINER...]", "Restart a running container")
+	cmd := cli.Subcmd("restart", "[OPTIONS] CONTAINER [CONTAINER...]", "Restart a running container")
 	nSeconds := cmd.Int("t", 10, "Number of seconds to try to stop for before killing the container. Once killed it will then be restarted. Default=10")
 	if err := cmd.Parse(args); err != nil {
 		return nil
@@ -563,7 +564,7 @@ func (cli *DockerCli) forwardAllSignals(cid string) chan os.Signal {
 }
 
 func (cli *DockerCli) CmdStart(args ...string) error {
-	cmd := Subcmd("start", "CONTAINER [CONTAINER...]", "Restart a stopped container")
+	cmd := cli.Subcmd("start", "CONTAINER [CONTAINER...]", "Restart a stopped container")
 	attach := cmd.Bool("a", false, "Attach container's stdout/stderr and forward all signals to the process")
 	openStdin := cmd.Bool("i", false, "Attach container's stdin")
 	if err := cmd.Parse(args); err != nil {
@@ -649,7 +650,7 @@ func (cli *DockerCli) CmdStart(args ...string) error {
 }
 
 func (cli *DockerCli) CmdInspect(args ...string) error {
-	cmd := Subcmd("inspect", "CONTAINER|IMAGE [CONTAINER|IMAGE...]", "Return low-level information on a container/image")
+	cmd := cli.Subcmd("inspect", "CONTAINER|IMAGE [CONTAINER|IMAGE...]", "Return low-level information on a container/image")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -700,7 +701,7 @@ func (cli *DockerCli) CmdInspect(args ...string) error {
 }
 
 func (cli *DockerCli) CmdTop(args ...string) error {
-	cmd := Subcmd("top", "CONTAINER [ps OPTIONS]", "Lookup the running processes of a container")
+	cmd := cli.Subcmd("top", "CONTAINER [ps OPTIONS]", "Lookup the running processes of a container")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -732,7 +733,7 @@ func (cli *DockerCli) CmdTop(args ...string) error {
 }
 
 func (cli *DockerCli) CmdPort(args ...string) error {
-	cmd := Subcmd("port", "CONTAINER PRIVATE_PORT", "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT")
+	cmd := cli.Subcmd("port", "CONTAINER PRIVATE_PORT", "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -774,7 +775,7 @@ func (cli *DockerCli) CmdPort(args ...string) error {
 
 // 'docker rmi IMAGE' removes all images with the name IMAGE
 func (cli *DockerCli) CmdRmi(args ...string) error {
-	cmd := Subcmd("rmi", "IMAGE [IMAGE...]", "Remove one or more images")
+	cmd := cli.Subcmd("rmi", "IMAGE [IMAGE...]", "Remove one or more images")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -810,7 +811,7 @@ func (cli *DockerCli) CmdRmi(args ...string) error {
 }
 
 func (cli *DockerCli) CmdHistory(args ...string) error {
-	cmd := Subcmd("history", "[OPTIONS] IMAGE", "Show the history of an image")
+	cmd := cli.Subcmd("history", "[OPTIONS] IMAGE", "Show the history of an image")
 	quiet := cmd.Bool("q", false, "only show numeric IDs")
 	noTrunc := cmd.Bool("notrunc", false, "Don't truncate output")
 
@@ -867,7 +868,7 @@ func (cli *DockerCli) CmdHistory(args ...string) error {
 }
 
 func (cli *DockerCli) CmdRm(args ...string) error {
-	cmd := Subcmd("rm", "[OPTIONS] CONTAINER [CONTAINER...]", "Remove one or more containers")
+	cmd := cli.Subcmd("rm", "[OPTIONS] CONTAINER [CONTAINER...]", "Remove one or more containers")
 	v := cmd.Bool("v", false, "Remove the volumes associated to the container")
 	link := cmd.Bool("link", false, "Remove the specified link and not the underlying container")
 
@@ -901,7 +902,7 @@ func (cli *DockerCli) CmdRm(args ...string) error {
 
 // 'docker kill NAME' kills a running container
 func (cli *DockerCli) CmdKill(args ...string) error {
-	cmd := Subcmd("kill", "CONTAINER [CONTAINER...]", "Kill a running container (send SIGKILL)")
+	cmd := cli.Subcmd("kill", "CONTAINER [CONTAINER...]", "Kill a running container (send SIGKILL)")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -923,7 +924,7 @@ func (cli *DockerCli) CmdKill(args ...string) error {
 }
 
 func (cli *DockerCli) CmdImport(args ...string) error {
-	cmd := Subcmd("import", "URL|- [REPOSITORY[:TAG]]", "Create a new filesystem image from the contents of a tarball(.tar, .tar.gz, .tgz, .bzip, .tar.xz, .txz).")
+	cmd := cli.Subcmd("import", "URL|- [REPOSITORY[:TAG]]", "Create a new filesystem image from the contents of a tarball(.tar, .tar.gz, .tgz, .bzip, .tar.xz, .txz).")
 
 	if err := cmd.Parse(args); err != nil {
 		return nil
@@ -957,7 +958,7 @@ func (cli *DockerCli) CmdImport(args ...string) error {
 }
 
 func (cli *DockerCli) CmdPush(args ...string) error {
-	cmd := Subcmd("push", "NAME", "Push an image or a repository to the registry")
+	cmd := cli.Subcmd("push", "NAME", "Push an image or a repository to the registry")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -1019,7 +1020,7 @@ func (cli *DockerCli) CmdPush(args ...string) error {
 }
 
 func (cli *DockerCli) CmdPull(args ...string) error {
-	cmd := Subcmd("pull", "NAME", "Pull an image or a repository from the registry")
+	cmd := cli.Subcmd("pull", "NAME", "Pull an image or a repository from the registry")
 	tag := cmd.String("t", "", "Download tagged image in repository")
 	if err := cmd.Parse(args); err != nil {
 		return nil
@@ -1079,7 +1080,7 @@ func (cli *DockerCli) CmdPull(args ...string) error {
 }
 
 func (cli *DockerCli) CmdImages(args ...string) error {
-	cmd := Subcmd("images", "[OPTIONS] [NAME]", "List images")
+	cmd := cli.Subcmd("images", "[OPTIONS] [NAME]", "List images")
 	quiet := cmd.Bool("q", false, "only show numeric IDs")
 	all := cmd.Bool("a", false, "show all images (by default filter out the intermediate images used to build)")
 	noTrunc := cmd.Bool("notrunc", false, "Don't truncate output")
@@ -1276,7 +1277,7 @@ func displayablePorts(ports []APIPort) string {
 }
 
 func (cli *DockerCli) CmdPs(args ...string) error {
-	cmd := Subcmd("ps", "[OPTIONS]", "List containers")
+	cmd := cli.Subcmd("ps", "[OPTIONS]", "List containers")
 	quiet := cmd.Bool("q", false, "Only display numeric IDs")
 	size := cmd.Bool("s", false, "Display sizes")
 	all := cmd.Bool("a", false, "Show all containers. Only running containers are shown by default.")
@@ -1365,7 +1366,7 @@ func (cli *DockerCli) CmdPs(args ...string) error {
 }
 
 func (cli *DockerCli) CmdCommit(args ...string) error {
-	cmd := Subcmd("commit", "[OPTIONS] CONTAINER [REPOSITORY[:TAG]]", "Create a new image from a container's changes")
+	cmd := cli.Subcmd("commit", "[OPTIONS] CONTAINER [REPOSITORY[:TAG]]", "Create a new image from a container's changes")
 	flComment := cmd.String("m", "", "Commit message")
 	flAuthor := cmd.String("author", "", "Author (eg. \"John Hannibal Smith <hannibal@a-team.com>\"")
 	flConfig := cmd.String("run", "", "Config automatically applied when the image is run. "+`(ex: {"Cmd": ["cat", "/world"], "PortSpecs": ["22"]}')`)
@@ -1417,7 +1418,7 @@ func (cli *DockerCli) CmdCommit(args ...string) error {
 }
 
 func (cli *DockerCli) CmdEvents(args ...string) error {
-	cmd := Subcmd("events", "[OPTIONS]", "Get real time events from the server")
+	cmd := cli.Subcmd("events", "[OPTIONS]", "Get real time events from the server")
 	since := cmd.String("since", "", "Show previously created events and then stream.")
 	if err := cmd.Parse(args); err != nil {
 		return nil
@@ -1450,7 +1451,7 @@ func (cli *DockerCli) CmdEvents(args ...string) error {
 }
 
 func (cli *DockerCli) CmdExport(args ...string) error {
-	cmd := Subcmd("export", "CONTAINER", "Export the contents of a filesystem as a tar archive")
+	cmd := cli.Subcmd("export", "CONTAINER", "Export the contents of a filesystem as a tar archive")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -1467,7 +1468,7 @@ func (cli *DockerCli) CmdExport(args ...string) error {
 }
 
 func (cli *DockerCli) CmdDiff(args ...string) error {
-	cmd := Subcmd("diff", "CONTAINER", "Inspect changes on a container's filesystem")
+	cmd := cli.Subcmd("diff", "CONTAINER", "Inspect changes on a container's filesystem")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -1493,7 +1494,7 @@ func (cli *DockerCli) CmdDiff(args ...string) error {
 }
 
 func (cli *DockerCli) CmdLogs(args ...string) error {
-	cmd := Subcmd("logs", "CONTAINER", "Fetch the logs of a container")
+	cmd := cli.Subcmd("logs", "CONTAINER", "Fetch the logs of a container")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -1520,7 +1521,7 @@ func (cli *DockerCli) CmdLogs(args ...string) error {
 }
 
 func (cli *DockerCli) CmdAttach(args ...string) error {
-	cmd := Subcmd("attach", "[OPTIONS] CONTAINER", "Attach to a running container")
+	cmd := cli.Subcmd("attach", "[OPTIONS] CONTAINER", "Attach to a running container")
 	noStdin := cmd.Bool("nostdin", false, "Do not attach stdin")
 	proxy := cmd.Bool("sig-proxy", true, "Proxify all received signal to the process (even in non-tty mode)")
 	if err := cmd.Parse(args); err != nil {
@@ -1575,7 +1576,7 @@ func (cli *DockerCli) CmdAttach(args ...string) error {
 }
 
 func (cli *DockerCli) CmdSearch(args ...string) error {
-	cmd := Subcmd("search", "TERM", "Search the docker index for images")
+	cmd := cli.Subcmd("search", "TERM", "Search the docker index for images")
 	noTrunc := cmd.Bool("notrunc", false, "Don't truncate output")
 	trusted := cmd.Bool("trusted", false, "Only show trusted builds")
 	stars := cmd.Int("stars", 0, "Only displays with at least xxx stars")
@@ -1687,7 +1688,7 @@ func (opts PathOpts) Set(val string) error {
 }
 
 func (cli *DockerCli) CmdTag(args ...string) error {
-	cmd := Subcmd("tag", "[OPTIONS] IMAGE REPOSITORY[:TAG]", "Tag an image into a repository")
+	cmd := cli.Subcmd("tag", "[OPTIONS] IMAGE REPOSITORY[:TAG]", "Tag an image into a repository")
 	force := cmd.Bool("f", false, "Force")
 	if err := cmd.Parse(args); err != nil {
 		return nil
@@ -1720,8 +1721,223 @@ func (cli *DockerCli) CmdTag(args ...string) error {
 	return nil
 }
 
+//FIXME Only used in tests
+func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig, *flag.FlagSet, error) {
+	cmd := flag.NewFlagSet("run", flag.ContinueOnError)
+	cmd.SetOutput(ioutil.Discard)
+	cmd.Usage = nil
+	return parseRun(cmd, args, capabilities)
+}
+
+func parseRun(cmd *flag.FlagSet, args []string, capabilities *Capabilities) (*Config, *HostConfig, *flag.FlagSet, error) {
+
+	flHostname := cmd.String("h", "", "Container host name")
+	flWorkingDir := cmd.String("w", "", "Working directory inside the container")
+	flUser := cmd.String("u", "", "Username or UID")
+	flDetach := cmd.Bool("d", false, "Detached mode: Run container in the background, print new container id")
+	flAttach := NewAttachOpts()
+	cmd.Var(flAttach, "a", "Attach to stdin, stdout or stderr.")
+	flStdin := cmd.Bool("i", false, "Keep stdin open even if not attached")
+	flTty := cmd.Bool("t", false, "Allocate a pseudo-tty")
+	flMemoryString := cmd.String("m", "", "Memory limit (format: <number><optional unit>, where unit = b, k, m or g)")
+	flContainerIDFile := cmd.String("cidfile", "", "Write the container ID to the file")
+	flNetwork := cmd.Bool("n", true, "Enable networking for this container")
+	flPrivileged := cmd.Bool("privileged", false, "Give extended privileges to this container")
+	flAutoRemove := cmd.Bool("rm", false, "Automatically remove the container when it exits (incompatible with -d)")
+	cmd.Bool("sig-proxy", true, "Proxify all received signal to the process (even in non-tty mode)")
+	cmd.String("name", "", "Assign a name to the container")
+	flPublishAll := cmd.Bool("P", false, "Publish all exposed ports to the host interfaces")
+
+	if capabilities != nil && *flMemoryString != "" && !capabilities.MemoryLimit {
+		//fmt.Fprintf(stdout, "WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.\n")
+		*flMemoryString = ""
+	}
+
+	flCpuShares := cmd.Int64("c", 0, "CPU shares (relative weight)")
+
+	var flPublish utils.ListOpts
+	cmd.Var(&flPublish, "p", "Publish a container's port to the host (use 'docker port' to see the actual mapping)")
+
+	var flExpose utils.ListOpts
+	cmd.Var(&flExpose, "expose", "Expose a port from the container without publishing it to your host")
+
+	var flEnv utils.ListOpts
+	cmd.Var(&flEnv, "e", "Set environment variables")
+
+	var flDns utils.ListOpts
+	cmd.Var(&flDns, "dns", "Set custom dns servers")
+
+	flVolumes := NewPathOpts()
+	cmd.Var(flVolumes, "v", "Bind mount a volume (e.g. from the host: -v /host:/container, from docker: -v /container)")
+
+	var flVolumesFrom utils.ListOpts
+	cmd.Var(&flVolumesFrom, "volumes-from", "Mount volumes from the specified container(s)")
+
+	flEntrypoint := cmd.String("entrypoint", "", "Overwrite the default entrypoint of the image")
+
+	var flLxcOpts utils.ListOpts
+	cmd.Var(&flLxcOpts, "lxc-conf", "Add custom lxc options -lxc-conf=\"lxc.cgroup.cpuset.cpus = 0,1\"")
+
+	var flLinks utils.ListOpts
+	cmd.Var(&flLinks, "link", "Add link to another container (name:alias)")
+
+	if err := cmd.Parse(args); err != nil {
+		return nil, nil, cmd, err
+	}
+	if *flDetach && len(flAttach) > 0 {
+		return nil, nil, cmd, ErrConflictAttachDetach
+	}
+	if *flWorkingDir != "" && !path.IsAbs(*flWorkingDir) {
+		return nil, nil, cmd, ErrInvalidWorikingDirectory
+	}
+	if *flDetach && *flAutoRemove {
+		return nil, nil, cmd, ErrConflictDetachAutoRemove
+	}
+
+	// If neither -d or -a are set, attach to everything by default
+	if len(flAttach) == 0 && !*flDetach {
+		if !*flDetach {
+			flAttach.Set("stdout")
+			flAttach.Set("stderr")
+			if *flStdin {
+				flAttach.Set("stdin")
+			}
+		}
+	}
+
+	envs := []string{}
+
+	for _, env := range flEnv {
+		arr := strings.Split(env, "=")
+		if len(arr) > 1 {
+			envs = append(envs, env)
+		} else {
+			v := os.Getenv(env)
+			envs = append(envs, env+"="+v)
+		}
+	}
+
+	var flMemory int64
+
+	if *flMemoryString != "" {
+		parsedMemory, err := utils.RAMInBytes(*flMemoryString)
+
+		if err != nil {
+			return nil, nil, cmd, err
+		}
+
+		flMemory = parsedMemory
+	}
+
+	var binds []string
+
+	// add any bind targets to the list of container volumes
+	for bind := range flVolumes {
+		arr := strings.Split(bind, ":")
+		if len(arr) > 1 {
+			if arr[0] == "/" {
+				return nil, nil, cmd, fmt.Errorf("Invalid bind mount: source can't be '/'")
+			}
+			dstDir := arr[1]
+			flVolumes[dstDir] = struct{}{}
+			binds = append(binds, bind)
+			delete(flVolumes, bind)
+		}
+	}
+
+	parsedArgs := cmd.Args()
+	runCmd := []string{}
+	entrypoint := []string{}
+	image := ""
+	if len(parsedArgs) >= 1 {
+		image = cmd.Arg(0)
+	}
+	if len(parsedArgs) > 1 {
+		runCmd = parsedArgs[1:]
+	}
+	if *flEntrypoint != "" {
+		entrypoint = []string{*flEntrypoint}
+	}
+
+	var lxcConf []KeyValuePair
+	lxcConf, err := parseLxcConfOpts(flLxcOpts)
+	if err != nil {
+		return nil, nil, cmd, err
+	}
+
+	hostname := *flHostname
+	domainname := ""
+
+	parts := strings.SplitN(hostname, ".", 2)
+	if len(parts) > 1 {
+		hostname = parts[0]
+		domainname = parts[1]
+	}
+
+	ports, portBindings, err := parsePortSpecs(flPublish)
+	if err != nil {
+		return nil, nil, cmd, err
+	}
+
+	// Merge in exposed ports to the map of published ports
+	for _, e := range flExpose {
+		if strings.Contains(e, ":") {
+			return nil, nil, cmd, fmt.Errorf("Invalid port format for -expose: %s", e)
+		}
+		p := NewPort(splitProtoPort(e))
+		if _, exists := ports[p]; !exists {
+			ports[p] = struct{}{}
+		}
+	}
+
+	config := &Config{
+		Hostname:        hostname,
+		Domainname:      domainname,
+		PortSpecs:       nil, // Deprecated
+		ExposedPorts:    ports,
+		User:            *flUser,
+		Tty:             *flTty,
+		NetworkDisabled: !*flNetwork,
+		OpenStdin:       *flStdin,
+		Memory:          flMemory,
+		CpuShares:       *flCpuShares,
+		AttachStdin:     flAttach.Get("stdin"),
+		AttachStdout:    flAttach.Get("stdout"),
+		AttachStderr:    flAttach.Get("stderr"),
+		Env:             envs,
+		Cmd:             runCmd,
+		Dns:             flDns,
+		Image:           image,
+		Volumes:         flVolumes,
+		VolumesFrom:     strings.Join(flVolumesFrom, ","),
+		Entrypoint:      entrypoint,
+		WorkingDir:      *flWorkingDir,
+	}
+
+	hostConfig := &HostConfig{
+		Binds:           binds,
+		ContainerIDFile: *flContainerIDFile,
+		LxcConf:         lxcConf,
+		Privileged:      *flPrivileged,
+		PortBindings:    portBindings,
+		Links:           flLinks,
+		PublishAllPorts: *flPublishAll,
+	}
+
+	if capabilities != nil && flMemory > 0 && !capabilities.SwapLimit {
+		//fmt.Fprintf(stdout, "WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.\n")
+		config.MemorySwap = -1
+	}
+
+	// When allocating stdin in attached mode, close stdin at client disconnect
+	if config.OpenStdin && config.AttachStdin {
+		config.StdinOnce = true
+	}
+	return config, hostConfig, cmd, nil
+}
+
 func (cli *DockerCli) CmdRun(args ...string) error {
-	config, hostConfig, cmd, err := ParseRun(args, nil)
+	config, hostConfig, cmd, err := parseRun(cli.Subcmd("run", "[OPTIONS] IMAGE [COMMAND] [ARG...]", "Run a command in a new container"), args, nil)
 	if err != nil {
 		return err
 	}
@@ -1932,7 +2148,7 @@ func (cli *DockerCli) CmdRun(args ...string) error {
 }
 
 func (cli *DockerCli) CmdCp(args ...string) error {
-	cmd := Subcmd("cp", "CONTAINER:PATH HOSTPATH", "Copy files/folders from the PATH to the HOSTPATH")
+	cmd := cli.Subcmd("cp", "CONTAINER:PATH HOSTPATH", "Copy files/folders from the PATH to the HOSTPATH")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -1967,7 +2183,7 @@ func (cli *DockerCli) CmdCp(args ...string) error {
 }
 
 func (cli *DockerCli) CmdSave(args ...string) error {
-	cmd := Subcmd("save", "IMAGE DESTINATION", "Save an image to a tar archive")
+	cmd := cli.Subcmd("save", "IMAGE DESTINATION", "Save an image to a tar archive")
 	if err := cmd.Parse(args); err != nil {
 		return err
 	}
@@ -1985,7 +2201,7 @@ func (cli *DockerCli) CmdSave(args ...string) error {
 }
 
 func (cli *DockerCli) CmdLoad(args ...string) error {
-	cmd := Subcmd("load", "SOURCE", "Load an image from a tar archive")
+	cmd := cli.Subcmd("load", "SOURCE", "Load an image from a tar archive")
 	if err := cmd.Parse(args); err != nil {
 		return err
 	}
@@ -2251,12 +2467,12 @@ func (cli *DockerCli) monitorTtySize(id string) error {
 	return nil
 }
 
-func Subcmd(name, signature, description string) *flag.FlagSet {
+func (cli *DockerCli) Subcmd(name, signature, description string) *flag.FlagSet {
 	flags := flag.NewFlagSet(name, flag.ContinueOnError)
 	flags.Usage = func() {
-		// FIXME: use custom stdout or return error
-		fmt.Fprintf(os.Stdout, "\nUsage: docker %s %s\n\n%s\n\n", name, signature, description)
+		fmt.Fprintf(cli.err, "\nUsage: docker %s %s\n\n%s\n\n", name, signature, description)
 		flags.PrintDefaults()
+		os.Exit(2)
 	}
 	return flags
 }
diff --git a/components/engine/container.go b/components/engine/container.go
index d6b73f57cb..a363d0095d 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
-	"flag"
 	"fmt"
 	"github.com/dotcloud/docker/archive"
 	"github.com/dotcloud/docker/term"
@@ -156,218 +155,6 @@ func NewPort(proto, port string) Port {
 	return Port(fmt.Sprintf("%s/%s", port, proto))
 }
 
-func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig, *flag.FlagSet, error) {
-	cmd := Subcmd("run", "[OPTIONS] IMAGE [COMMAND] [ARG...]", "Run a command in a new container")
-	if os.Getenv("TEST") != "" {
-		cmd.SetOutput(ioutil.Discard)
-		cmd.Usage = nil
-	}
-
-	flHostname := cmd.String("h", "", "Container host name")
-	flWorkingDir := cmd.String("w", "", "Working directory inside the container")
-	flUser := cmd.String("u", "", "Username or UID")
-	flDetach := cmd.Bool("d", false, "Detached mode: Run container in the background, print new container id")
-	flAttach := NewAttachOpts()
-	cmd.Var(flAttach, "a", "Attach to stdin, stdout or stderr.")
-	flStdin := cmd.Bool("i", false, "Keep stdin open even if not attached")
-	flTty := cmd.Bool("t", false, "Allocate a pseudo-tty")
-	flMemoryString := cmd.String("m", "", "Memory limit (format: <number><optional unit>, where unit = b, k, m or g)")
-	flContainerIDFile := cmd.String("cidfile", "", "Write the container ID to the file")
-	flNetwork := cmd.Bool("n", true, "Enable networking for this container")
-	flPrivileged := cmd.Bool("privileged", false, "Give extended privileges to this container")
-	flAutoRemove := cmd.Bool("rm", false, "Automatically remove the container when it exits (incompatible with -d)")
-	cmd.Bool("sig-proxy", true, "Proxify all received signal to the process (even in non-tty mode)")
-	cmd.String("name", "", "Assign a name to the container")
-	flPublishAll := cmd.Bool("P", false, "Publish all exposed ports to the host interfaces")
-
-	if capabilities != nil && *flMemoryString != "" && !capabilities.MemoryLimit {
-		//fmt.Fprintf(stdout, "WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.\n")
-		*flMemoryString = ""
-	}
-
-	flCpuShares := cmd.Int64("c", 0, "CPU shares (relative weight)")
-
-	var flPublish utils.ListOpts
-	cmd.Var(&flPublish, "p", "Publish a container's port to the host (use 'docker port' to see the actual mapping)")
-
-	var flExpose utils.ListOpts
-	cmd.Var(&flExpose, "expose", "Expose a port from the container without publishing it to your host")
-
-	var flEnv utils.ListOpts
-	cmd.Var(&flEnv, "e", "Set environment variables")
-
-	var flDns utils.ListOpts
-	cmd.Var(&flDns, "dns", "Set custom dns servers")
-
-	flVolumes := NewPathOpts()
-	cmd.Var(flVolumes, "v", "Bind mount a volume (e.g. from the host: -v /host:/container, from docker: -v /container)")
-
-	var flVolumesFrom utils.ListOpts
-	cmd.Var(&flVolumesFrom, "volumes-from", "Mount volumes from the specified container(s)")
-
-	flEntrypoint := cmd.String("entrypoint", "", "Overwrite the default entrypoint of the image")
-
-	var flLxcOpts utils.ListOpts
-	cmd.Var(&flLxcOpts, "lxc-conf", "Add custom lxc options -lxc-conf=\"lxc.cgroup.cpuset.cpus = 0,1\"")
-
-	var flLinks utils.ListOpts
-	cmd.Var(&flLinks, "link", "Add link to another container (name:alias)")
-
-	if err := cmd.Parse(args); err != nil {
-		return nil, nil, cmd, err
-	}
-	if *flDetach && len(flAttach) > 0 {
-		return nil, nil, cmd, ErrConflictAttachDetach
-	}
-	if *flWorkingDir != "" && !path.IsAbs(*flWorkingDir) {
-		return nil, nil, cmd, ErrInvalidWorikingDirectory
-	}
-	if *flDetach && *flAutoRemove {
-		return nil, nil, cmd, ErrConflictDetachAutoRemove
-	}
-
-	// If neither -d or -a are set, attach to everything by default
-	if len(flAttach) == 0 && !*flDetach {
-		if !*flDetach {
-			flAttach.Set("stdout")
-			flAttach.Set("stderr")
-			if *flStdin {
-				flAttach.Set("stdin")
-			}
-		}
-	}
-
-	envs := []string{}
-
-	for _, env := range flEnv {
-		arr := strings.Split(env, "=")
-		if len(arr) > 1 {
-			envs = append(envs, env)
-		} else {
-			v := os.Getenv(env)
-			envs = append(envs, env+"="+v)
-		}
-	}
-
-	var flMemory int64
-
-	if *flMemoryString != "" {
-		parsedMemory, err := utils.RAMInBytes(*flMemoryString)
-
-		if err != nil {
-			return nil, nil, cmd, err
-		}
-
-		flMemory = parsedMemory
-	}
-
-	var binds []string
-
-	// add any bind targets to the list of container volumes
-	for bind := range flVolumes {
-		arr := strings.Split(bind, ":")
-		if len(arr) > 1 {
-			if arr[0] == "/" {
-				return nil, nil, cmd, fmt.Errorf("Invalid bind mount: source can't be '/'")
-			}
-			dstDir := arr[1]
-			flVolumes[dstDir] = struct{}{}
-			binds = append(binds, bind)
-			delete(flVolumes, bind)
-		}
-	}
-
-	parsedArgs := cmd.Args()
-	runCmd := []string{}
-	entrypoint := []string{}
-	image := ""
-	if len(parsedArgs) >= 1 {
-		image = cmd.Arg(0)
-	}
-	if len(parsedArgs) > 1 {
-		runCmd = parsedArgs[1:]
-	}
-	if *flEntrypoint != "" {
-		entrypoint = []string{*flEntrypoint}
-	}
-
-	var lxcConf []KeyValuePair
-	lxcConf, err := parseLxcConfOpts(flLxcOpts)
-	if err != nil {
-		return nil, nil, cmd, err
-	}
-
-	hostname := *flHostname
-	domainname := ""
-
-	parts := strings.SplitN(hostname, ".", 2)
-	if len(parts) > 1 {
-		hostname = parts[0]
-		domainname = parts[1]
-	}
-
-	ports, portBindings, err := parsePortSpecs(flPublish)
-	if err != nil {
-		return nil, nil, cmd, err
-	}
-
-	// Merge in exposed ports to the map of published ports
-	for _, e := range flExpose {
-		if strings.Contains(e, ":") {
-			return nil, nil, cmd, fmt.Errorf("Invalid port format for -expose: %s", e)
-		}
-		p := NewPort(splitProtoPort(e))
-		if _, exists := ports[p]; !exists {
-			ports[p] = struct{}{}
-		}
-	}
-
-	config := &Config{
-		Hostname:        hostname,
-		Domainname:      domainname,
-		PortSpecs:       nil, // Deprecated
-		ExposedPorts:    ports,
-		User:            *flUser,
-		Tty:             *flTty,
-		NetworkDisabled: !*flNetwork,
-		OpenStdin:       *flStdin,
-		Memory:          flMemory,
-		CpuShares:       *flCpuShares,
-		AttachStdin:     flAttach.Get("stdin"),
-		AttachStdout:    flAttach.Get("stdout"),
-		AttachStderr:    flAttach.Get("stderr"),
-		Env:             envs,
-		Cmd:             runCmd,
-		Dns:             flDns,
-		Image:           image,
-		Volumes:         flVolumes,
-		VolumesFrom:     strings.Join(flVolumesFrom, ","),
-		Entrypoint:      entrypoint,
-		WorkingDir:      *flWorkingDir,
-	}
-
-	hostConfig := &HostConfig{
-		Binds:           binds,
-		ContainerIDFile: *flContainerIDFile,
-		LxcConf:         lxcConf,
-		Privileged:      *flPrivileged,
-		PortBindings:    portBindings,
-		Links:           flLinks,
-		PublishAllPorts: *flPublishAll,
-	}
-
-	if capabilities != nil && flMemory > 0 && !capabilities.SwapLimit {
-		//fmt.Fprintf(stdout, "WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.\n")
-		config.MemorySwap = -1
-	}
-
-	// When allocating stdin in attached mode, close stdin at client disconnect
-	if config.OpenStdin && config.AttachStdin {
-		config.StdinOnce = true
-	}
-	return config, hostConfig, cmd, nil
-}
-
 type PortMapping map[string]string // Deprecated
 
 type NetworkSettings struct {

From 9dfa0ceb9cd94be64a8ef32913781093ee2b3f09 Mon Sep 17 00:00:00 2001
From: Michael Crosby <crosby.michael@gmail.com>
Date: Thu, 21 Nov 2013 12:11:25 -0800
Subject: [PATCH 180/184] Revert "Lock state before we modify."

This reverts commit d7e2fc898284fe29ed43f7b28eae56e7e052e854.
Upstream-commit: cb70eedfdad40538983f9610322262ce84e284a0
Component: engine
---
 components/engine/container.go | 2 --
 1 file changed, 2 deletions(-)

diff --git a/components/engine/container.go b/components/engine/container.go
index d6b73f57cb..16f45cb490 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -1300,9 +1300,7 @@ func (container *Container) monitor() {
 	}
 
 	// Report status back
-	container.State.Lock()
 	container.State.setStopped(exitCode)
-	container.State.Unlock()
 
 	// Release the lock
 	close(container.waitLock)

From 63c337d32681e8ccbff65f3f4958f906e368aa2d Mon Sep 17 00:00:00 2001
From: Gabe Rosenhouse <gabe@missionst.com>
Date: Thu, 21 Nov 2013 12:45:01 -0800
Subject: [PATCH 181/184] Fix title on doc page for
 remote_api_client_libraries.rst Upstream-commit:
 362e9d6b3c7049d44c016ee72fe255b76ec80c5a Component: engine

---
 .../engine/docs/sources/api/remote_api_client_libraries.rst     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/engine/docs/sources/api/remote_api_client_libraries.rst b/components/engine/docs/sources/api/remote_api_client_libraries.rst
index f00ab1c2b5..45ce8ff9d1 100644
--- a/components/engine/docs/sources/api/remote_api_client_libraries.rst
+++ b/components/engine/docs/sources/api/remote_api_client_libraries.rst
@@ -1,4 +1,4 @@
-:title: Registry API
+:title: Remote API Client Libraries
 :description: Various client libraries available to use with the Docker remote API
 :keywords: API, Docker, index, registry, REST, documentation, clients, Python, Ruby, Javascript, Erlang, Go
 

From f8ba7a65e33f5def13372b26e60f5845a118e733 Mon Sep 17 00:00:00 2001
From: Paul Morie <pmorie@gmail.com>
Date: Thu, 21 Nov 2013 17:29:03 -0500
Subject: [PATCH 182/184] Fix typo in pullImage Upstream-commit:
 3f17844b6ec3edb981653ca237d085909d5be671 Component: engine

---
 components/engine/server.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/components/engine/server.go b/components/engine/server.go
index 39c6dfdc6d..c859997a7a 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -759,7 +759,7 @@ func (srv *Server) pullImage(r *registry.Registry, out io.Writer, imgID, endpoin
 	if err != nil {
 		return err
 	}
-	out.Write(sf.FormatProgress(utils.TruncateID(imgID), "Pulling", "dependend layers"))
+	out.Write(sf.FormatProgress(utils.TruncateID(imgID), "Pulling", "dependent layers"))
 	// FIXME: Try to stream the images?
 	// FIXME: Launch the getRemoteImage() in goroutines
 
@@ -776,13 +776,13 @@ func (srv *Server) pullImage(r *registry.Registry, out io.Writer, imgID, endpoin
 			out.Write(sf.FormatProgress(utils.TruncateID(id), "Pulling", "metadata"))
 			imgJSON, imgSize, err := r.GetRemoteImageJSON(id, endpoint, token)
 			if err != nil {
-				out.Write(sf.FormatProgress(utils.TruncateID(id), "Error", "pulling dependend layers"))
+				out.Write(sf.FormatProgress(utils.TruncateID(id), "Error", "pulling dependent layers"))
 				// FIXME: Keep going in case of error?
 				return err
 			}
 			img, err := NewImgJSON(imgJSON)
 			if err != nil {
-				out.Write(sf.FormatProgress(utils.TruncateID(id), "Error", "pulling dependend layers"))
+				out.Write(sf.FormatProgress(utils.TruncateID(id), "Error", "pulling dependent layers"))
 				return fmt.Errorf("Failed to parse json: %s", err)
 			}
 
@@ -790,12 +790,12 @@ func (srv *Server) pullImage(r *registry.Registry, out io.Writer, imgID, endpoin
 			out.Write(sf.FormatProgress(utils.TruncateID(id), "Pulling", "fs layer"))
 			layer, err := r.GetRemoteImageLayer(img.ID, endpoint, token)
 			if err != nil {
-				out.Write(sf.FormatProgress(utils.TruncateID(id), "Error", "pulling dependend layers"))
+				out.Write(sf.FormatProgress(utils.TruncateID(id), "Error", "pulling dependent layers"))
 				return err
 			}
 			defer layer.Close()
 			if err := srv.runtime.graph.Register(imgJSON, utils.ProgressReader(layer, imgSize, out, sf.FormatProgress(utils.TruncateID(id), "Downloading", "%8v/%v (%v)"), sf, false), img); err != nil {
-				out.Write(sf.FormatProgress(utils.TruncateID(id), "Error", "downloading dependend layers"))
+				out.Write(sf.FormatProgress(utils.TruncateID(id), "Error", "downloading dependent layers"))
 				return err
 			}
 		}

From 915356af08846afdfd5544b5edaac2290d5cf49d Mon Sep 17 00:00:00 2001
From: "Guillaume J. Charmes" <charmes.guillaume@gmail.com>
Date: Thu, 21 Nov 2013 12:21:03 -0800
Subject: [PATCH 183/184] Refactor State to be 100% thread safe
 Upstream-commit: 33e70864a2c4321bf6968d6d521c159a1b72b220 Component: engine

---
 components/engine/commands.go                 |  4 +-
 components/engine/container.go                | 53 +++++++------
 .../engine/integration/commands_test.go       | 16 ++--
 .../engine/integration/container_test.go      | 76 +++++++++----------
 components/engine/integration/runtime_test.go | 18 ++---
 components/engine/integration/utils_test.go   |  2 +-
 components/engine/links.go                    |  2 +-
 components/engine/runtime.go                  | 12 +--
 components/engine/server.go                   |  8 +-
 components/engine/state.go                    | 43 ++++++++++-
 10 files changed, 139 insertions(+), 95 deletions(-)

diff --git a/components/engine/commands.go b/components/engine/commands.go
index a551d598c9..51e4c5f01c 100644
--- a/components/engine/commands.go
+++ b/components/engine/commands.go
@@ -1542,7 +1542,7 @@ func (cli *DockerCli) CmdAttach(args ...string) error {
 		return err
 	}
 
-	if !container.State.Running {
+	if !container.State.IsRunning() {
 		return fmt.Errorf("Impossible to attach to a stopped container, start it first")
 	}
 
@@ -2301,7 +2301,7 @@ func getExitCode(cli *DockerCli, containerId string) (bool, int, error) {
 	if err := json.Unmarshal(body, c); err != nil {
 		return false, -1, err
 	}
-	return c.State.Running, c.State.ExitCode, nil
+	return c.State.IsRunning(), c.State.GetExitCode(), nil
 }
 
 func NewDockerCli(in io.ReadCloser, out, err io.Writer, proto, addr string) *DockerCli {
diff --git a/components/engine/container.go b/components/engine/container.go
index 16f45cb490..744fabee20 100644
--- a/components/engine/container.go
+++ b/components/engine/container.go
@@ -20,11 +20,14 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 )
 
 type Container struct {
+	sync.Mutex
+
 	root string
 
 	ID string
@@ -700,9 +703,10 @@ func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, s
 }
 
 func (container *Container) Start() (err error) {
-	container.State.Lock()
-	defer container.State.Unlock()
-	if container.State.Running {
+	container.Lock()
+	defer container.Unlock()
+
+	if container.State.IsRunning() {
 		return fmt.Errorf("The container %s is already running.", container.ID)
 	}
 	defer func() {
@@ -1031,7 +1035,7 @@ func (container *Container) Start() (err error) {
 	}
 	// FIXME: save state on disk *first*, then converge
 	// this way disk state is used as a journal, eg. we can restore after crash etc.
-	container.State.setRunning(container.cmd.Process.Pid)
+	container.State.SetRunning(container.cmd.Process.Pid)
 
 	// Init the lock
 	container.waitLock = make(chan struct{})
@@ -1039,14 +1043,14 @@ func (container *Container) Start() (err error) {
 	container.ToDisk()
 	go container.monitor()
 
-	defer utils.Debugf("Container running: %v", container.State.Running)
+	defer utils.Debugf("Container running: %v", container.State.IsRunning())
 	// We wait for the container to be fully running.
 	// Timeout after 5 seconds. In case of broken pipe, just retry.
 	// Note: The container can run and finish correctly before
 	//       the end of this loop
 	for now := time.Now(); time.Since(now) < 5*time.Second; {
 		// If the container dies while waiting for it, just return
-		if !container.State.Running {
+		if !container.State.IsRunning() {
 			return nil
 		}
 		output, err := exec.Command("lxc-info", "-s", "-n", container.ID).CombinedOutput()
@@ -1063,11 +1067,11 @@ func (container *Container) Start() (err error) {
 		if strings.Contains(string(output), "RUNNING") {
 			return nil
 		}
-		utils.Debugf("Waiting for the container to start (running: %v): %s", container.State.Running, bytes.TrimSpace(output))
+		utils.Debugf("Waiting for the container to start (running: %v): %s", container.State.IsRunning(), bytes.TrimSpace(output))
 		time.Sleep(50 * time.Millisecond)
 	}
 
-	if container.State.Running {
+	if container.State.IsRunning() {
 		return ErrContainerStartTimeout
 	}
 	return ErrContainerStart
@@ -1148,11 +1152,12 @@ func (container *Container) allocateNetwork() error {
 		return nil
 	}
 
-	var iface *NetworkInterface
-	var err error
-	if container.State.Ghost {
-		manager := container.runtime.networkManager
-		if manager.disabled {
+	var (
+		iface *NetworkInterface
+		err   error
+	)
+	if container.State.IsGhost() {
+		if manager := container.runtime.networkManager; manager.disabled {
 			iface = &NetworkInterface{disabled: true}
 		} else {
 			iface = &NetworkInterface{
@@ -1188,10 +1193,12 @@ func (container *Container) allocateNetwork() error {
 		}
 	}
 
-	portSpecs := make(map[Port]struct{})
-	bindings := make(map[Port][]PortBinding)
+	var (
+		portSpecs = make(map[Port]struct{})
+		bindings  = make(map[Port][]PortBinding)
+	)
 
-	if !container.State.Ghost {
+	if !container.State.IsGhost() {
 		if container.Config.ExposedPorts != nil {
 			portSpecs = container.Config.ExposedPorts
 		}
@@ -1300,7 +1307,7 @@ func (container *Container) monitor() {
 	}
 
 	// Report status back
-	container.State.setStopped(exitCode)
+	container.State.SetStopped(exitCode)
 
 	// Release the lock
 	close(container.waitLock)
@@ -1350,10 +1357,10 @@ func (container *Container) cleanup() {
 }
 
 func (container *Container) kill(sig int) error {
-	container.State.Lock()
-	defer container.State.Unlock()
+	container.Lock()
+	defer container.Unlock()
 
-	if !container.State.Running {
+	if !container.State.IsRunning() {
 		return nil
 	}
 
@@ -1366,7 +1373,7 @@ func (container *Container) kill(sig int) error {
 }
 
 func (container *Container) Kill() error {
-	if !container.State.Running {
+	if !container.State.IsRunning() {
 		return nil
 	}
 
@@ -1391,7 +1398,7 @@ func (container *Container) Kill() error {
 }
 
 func (container *Container) Stop(seconds int) error {
-	if !container.State.Running {
+	if !container.State.IsRunning() {
 		return nil
 	}
 
@@ -1425,7 +1432,7 @@ func (container *Container) Restart(seconds int) error {
 // Wait blocks until the container stops running, then returns its exit code.
 func (container *Container) Wait() int {
 	<-container.waitLock
-	return container.State.ExitCode
+	return container.State.GetExitCode()
 }
 
 func (container *Container) Resize(h, w int) error {
diff --git a/components/engine/integration/commands_test.go b/components/engine/integration/commands_test.go
index 440d8e5469..6f9cf973da 100644
--- a/components/engine/integration/commands_test.go
+++ b/components/engine/integration/commands_test.go
@@ -289,7 +289,7 @@ func TestRunDisconnect(t *testing.T) {
 	setTimeout(t, "Waiting for /bin/cat to exit timed out", 2*time.Second, func() {
 		container := globalRuntime.List()[0]
 		container.Wait()
-		if container.State.Running {
+		if container.State.IsRunning() {
 			t.Fatalf("/bin/cat is still running after closing stdin")
 		}
 	})
@@ -319,7 +319,7 @@ func TestRunDisconnectTty(t *testing.T) {
 		for {
 			// Client disconnect after run -i should keep stdin out in TTY mode
 			l := globalRuntime.List()
-			if len(l) == 1 && l[0].State.Running {
+			if len(l) == 1 && l[0].State.IsRunning() {
 				break
 			}
 			time.Sleep(10 * time.Millisecond)
@@ -345,7 +345,7 @@ func TestRunDisconnectTty(t *testing.T) {
 
 	// Give some time to monitor to do his thing
 	container.WaitTimeout(500 * time.Millisecond)
-	if !container.State.Running {
+	if !container.State.IsRunning() {
 		t.Fatalf("/bin/cat should  still be running after closing stdin (tty mode)")
 	}
 }
@@ -454,7 +454,7 @@ func TestRunDetach(t *testing.T) {
 	})
 
 	time.Sleep(500 * time.Millisecond)
-	if !container.State.Running {
+	if !container.State.IsRunning() {
 		t.Fatal("The detached container should be still running")
 	}
 
@@ -534,7 +534,7 @@ func TestAttachDetach(t *testing.T) {
 	})
 
 	time.Sleep(500 * time.Millisecond)
-	if !container.State.Running {
+	if !container.State.IsRunning() {
 		t.Fatal("The detached container should be still running")
 	}
 
@@ -596,7 +596,7 @@ func TestAttachDetachTruncatedID(t *testing.T) {
 	})
 
 	time.Sleep(500 * time.Millisecond)
-	if !container.State.Running {
+	if !container.State.IsRunning() {
 		t.Fatal("The detached container should be still running")
 	}
 
@@ -629,7 +629,7 @@ func TestAttachDisconnect(t *testing.T) {
 	setTimeout(t, "Waiting for the container to be started timed out", 10*time.Second, func() {
 		for {
 			l := globalRuntime.List()
-			if len(l) == 1 && l[0].State.Running {
+			if len(l) == 1 && l[0].State.IsRunning() {
 				break
 			}
 			time.Sleep(10 * time.Millisecond)
@@ -665,7 +665,7 @@ func TestAttachDisconnect(t *testing.T) {
 	// We closed stdin, expect /bin/cat to still be running
 	// Wait a little bit to make sure container.monitor() did his thing
 	err := container.WaitTimeout(500 * time.Millisecond)
-	if err == nil || !container.State.Running {
+	if err == nil || !container.State.IsRunning() {
 		t.Fatalf("/bin/cat is not running after closing stdin")
 	}
 
diff --git a/components/engine/integration/container_test.go b/components/engine/integration/container_test.go
index a8c21ef1ea..e23e3b4985 100644
--- a/components/engine/integration/container_test.go
+++ b/components/engine/integration/container_test.go
@@ -224,13 +224,13 @@ func TestCommitAutoRun(t *testing.T) {
 	container1, _, _ := mkContainer(runtime, []string{"_", "/bin/sh", "-c", "echo hello > /world"}, t)
 	defer runtime.Destroy(container1)
 
-	if container1.State.Running {
+	if container1.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	if err := container1.Run(); err != nil {
 		t.Fatal(err)
 	}
-	if container1.State.Running {
+	if container1.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 
@@ -280,13 +280,13 @@ func TestCommitRun(t *testing.T) {
 	container1, _, _ := mkContainer(runtime, []string{"_", "/bin/sh", "-c", "echo hello > /world"}, t)
 	defer runtime.Destroy(container1)
 
-	if container1.State.Running {
+	if container1.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	if err := container1.Run(); err != nil {
 		t.Fatal(err)
 	}
-	if container1.State.Running {
+	if container1.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 
@@ -352,7 +352,7 @@ func TestStart(t *testing.T) {
 	// Give some time to the process to start
 	container.WaitTimeout(500 * time.Millisecond)
 
-	if !container.State.Running {
+	if !container.State.IsRunning() {
 		t.Errorf("Container should be running")
 	}
 	if err := container.Start(); err == nil {
@@ -370,13 +370,13 @@ func TestRun(t *testing.T) {
 	container, _, _ := mkContainer(runtime, []string{"_", "ls", "-al"}, t)
 	defer runtime.Destroy(container)
 
-	if container.State.Running {
+	if container.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	if err := container.Run(); err != nil {
 		t.Fatal(err)
 	}
-	if container.State.Running {
+	if container.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 }
@@ -400,7 +400,7 @@ func TestOutput(t *testing.T) {
 		t.Fatal(err)
 	}
 	if string(output) != "foobar" {
-		t.Error(string(output))
+		t.Fatalf("%s != %s", string(output), "foobar")
 	}
 }
 
@@ -421,8 +421,8 @@ func TestContainerNetwork(t *testing.T) {
 	if err := container.Run(); err != nil {
 		t.Fatal(err)
 	}
-	if container.State.ExitCode != 0 {
-		t.Errorf("Unexpected ping 127.0.0.1 exit code %d (expected 0)", container.State.ExitCode)
+	if code := container.State.GetExitCode(); code != 0 {
+		t.Fatalf("Unexpected ping 127.0.0.1 exit code %d (expected 0)", code)
 	}
 }
 
@@ -446,7 +446,7 @@ func TestKillDifferentUser(t *testing.T) {
 	// there is a side effect I'm not seeing.
 	// defer container.stdin.Close()
 
-	if container.State.Running {
+	if container.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	if err := container.Start(); err != nil {
@@ -454,7 +454,7 @@ func TestKillDifferentUser(t *testing.T) {
 	}
 
 	setTimeout(t, "Waiting for the container to be started timed out", 2*time.Second, func() {
-		for !container.State.Running {
+		for !container.State.IsRunning() {
 			time.Sleep(10 * time.Millisecond)
 		}
 	})
@@ -471,11 +471,11 @@ func TestKillDifferentUser(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if container.State.Running {
+	if container.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	container.Wait()
-	if container.State.Running {
+	if container.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	// Try stopping twice
@@ -533,7 +533,7 @@ func TestKill(t *testing.T) {
 	}
 	defer runtime.Destroy(container)
 
-	if container.State.Running {
+	if container.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	if err := container.Start(); err != nil {
@@ -543,17 +543,17 @@ func TestKill(t *testing.T) {
 	// Give some time to lxc to spawn the process
 	container.WaitTimeout(500 * time.Millisecond)
 
-	if !container.State.Running {
+	if !container.State.IsRunning() {
 		t.Errorf("Container should be running")
 	}
 	if err := container.Kill(); err != nil {
 		t.Fatal(err)
 	}
-	if container.State.Running {
+	if container.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	container.Wait()
-	if container.State.Running {
+	if container.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	// Try stopping twice
@@ -577,8 +577,8 @@ func TestExitCode(t *testing.T) {
 	if err := trueContainer.Run(); err != nil {
 		t.Fatal(err)
 	}
-	if trueContainer.State.ExitCode != 0 {
-		t.Errorf("Unexpected exit code %d (expected 0)", trueContainer.State.ExitCode)
+	if code := trueContainer.State.GetExitCode(); code != 0 {
+		t.Fatalf("Unexpected exit code %d (expected 0)", code)
 	}
 
 	falseContainer, _, err := runtime.Create(&docker.Config{
@@ -592,8 +592,8 @@ func TestExitCode(t *testing.T) {
 	if err := falseContainer.Run(); err != nil {
 		t.Fatal(err)
 	}
-	if falseContainer.State.ExitCode != 1 {
-		t.Errorf("Unexpected exit code %d (expected 1)", falseContainer.State.ExitCode)
+	if code := falseContainer.State.GetExitCode(); code != 1 {
+		t.Fatalf("Unexpected exit code %d (expected 1)", code)
 	}
 }
 
@@ -741,7 +741,7 @@ func TestUser(t *testing.T) {
 	}
 	defer runtime.Destroy(container)
 	output, err = container.Output()
-	if err != nil || container.State.ExitCode != 0 {
+	if code := container.State.GetExitCode(); err != nil || code != 0 {
 		t.Fatal(err)
 	}
 	if !strings.Contains(string(output), "uid=0(root) gid=0(root)") {
@@ -757,12 +757,12 @@ func TestUser(t *testing.T) {
 	},
 		"",
 	)
-	if err != nil || container.State.ExitCode != 0 {
+	if code := container.State.GetExitCode(); err != nil || code != 0 {
 		t.Fatal(err)
 	}
 	defer runtime.Destroy(container)
 	output, err = container.Output()
-	if err != nil || container.State.ExitCode != 0 {
+	if code := container.State.GetExitCode(); err != nil || code != 0 {
 		t.Fatal(err)
 	}
 	if !strings.Contains(string(output), "uid=0(root) gid=0(root)") {
@@ -785,8 +785,8 @@ func TestUser(t *testing.T) {
 	output, err = container.Output()
 	if err != nil {
 		t.Fatal(err)
-	} else if container.State.ExitCode != 0 {
-		t.Fatalf("Container exit code is invalid: %d\nOutput:\n%s\n", container.State.ExitCode, output)
+	} else if code := container.State.GetExitCode(); code != 0 {
+		t.Fatalf("Container exit code is invalid: %d\nOutput:\n%s\n", code, output)
 	}
 	if !strings.Contains(string(output), "uid=1(daemon) gid=1(daemon)") {
 		t.Error(string(output))
@@ -806,7 +806,7 @@ func TestUser(t *testing.T) {
 	}
 	defer runtime.Destroy(container)
 	output, err = container.Output()
-	if err != nil || container.State.ExitCode != 0 {
+	if code := container.State.GetExitCode(); err != nil || code != 0 {
 		t.Fatal(err)
 	}
 	if !strings.Contains(string(output), "uid=1(daemon) gid=1(daemon)") {
@@ -827,7 +827,7 @@ func TestUser(t *testing.T) {
 	}
 	defer runtime.Destroy(container)
 	output, err = container.Output()
-	if container.State.ExitCode == 0 {
+	if container.State.GetExitCode() == 0 {
 		t.Fatal("Starting container with wrong uid should fail but it passed.")
 	}
 }
@@ -871,10 +871,10 @@ func TestMultipleContainers(t *testing.T) {
 	container2.WaitTimeout(250 * time.Millisecond)
 
 	// If we are here, both containers should be running
-	if !container1.State.Running {
+	if !container1.State.IsRunning() {
 		t.Fatal("Container not running")
 	}
-	if !container2.State.Running {
+	if !container2.State.IsRunning() {
 		t.Fatal("Container not running")
 	}
 
@@ -1176,13 +1176,13 @@ func TestCopyVolumeUidGid(t *testing.T) {
 	container1, _, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello && touch /hello/test.txt && chown daemon.daemon /hello"}, t)
 	defer r.Destroy(container1)
 
-	if container1.State.Running {
+	if container1.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	if err := container1.Run(); err != nil {
 		t.Fatal(err)
 	}
-	if container1.State.Running {
+	if container1.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 
@@ -1210,13 +1210,13 @@ func TestCopyVolumeContent(t *testing.T) {
 	container1, _, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello/local && echo hello > /hello/local/world"}, t)
 	defer r.Destroy(container1)
 
-	if container1.State.Running {
+	if container1.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 	if err := container1.Run(); err != nil {
 		t.Fatal(err)
 	}
-	if container1.State.Running {
+	if container1.State.IsRunning() {
 		t.Errorf("Container shouldn't be running")
 	}
 
@@ -1666,17 +1666,17 @@ func TestRestartGhost(t *testing.T) {
 		},
 		"",
 	)
-
 	if err != nil {
 		t.Fatal(err)
 	}
+
 	if err := container.Kill(); err != nil {
 		t.Fatal(err)
 	}
 
-	container.State.Ghost = true
-	_, err = container.Output()
+	container.State.SetGhost(true)
 
+	_, err = container.Output()
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/components/engine/integration/runtime_test.go b/components/engine/integration/runtime_test.go
index 320a3645b0..69559f332b 100644
--- a/components/engine/integration/runtime_test.go
+++ b/components/engine/integration/runtime_test.go
@@ -419,7 +419,7 @@ func startEchoServerContainer(t *testing.T, proto string) (*docker.Runtime, *doc
 	}
 
 	setTimeout(t, "Waiting for the container to be started timed out", 2*time.Second, func() {
-		for !container.State.Running {
+		for !container.State.IsRunning() {
 			time.Sleep(10 * time.Millisecond)
 		}
 	})
@@ -533,7 +533,7 @@ func TestRestore(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if !container2.State.Running {
+	if !container2.State.IsRunning() {
 		t.Fatalf("Container %v should appear as running but isn't", container2.ID)
 	}
 
@@ -543,7 +543,7 @@ func TestRestore(t *testing.T) {
 	if err := container2.WaitTimeout(2 * time.Second); err != nil {
 		t.Fatal(err)
 	}
-	container2.State.Running = true
+	container2.State.SetRunning(42)
 	container2.ToDisk()
 
 	if len(runtime1.List()) != 2 {
@@ -553,7 +553,7 @@ func TestRestore(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if !container2.State.Running {
+	if !container2.State.IsRunning() {
 		t.Fatalf("Container %v should appear as running but isn't", container2.ID)
 	}
 
@@ -577,7 +577,7 @@ func TestRestore(t *testing.T) {
 	}
 	runningCount := 0
 	for _, c := range runtime2.List() {
-		if c.State.Running {
+		if c.State.IsRunning() {
 			t.Errorf("Running container found: %v (%v)", c.ID, c.Path)
 			runningCount++
 		}
@@ -592,7 +592,7 @@ func TestRestore(t *testing.T) {
 	if err := container3.Run(); err != nil {
 		t.Fatal(err)
 	}
-	container2.State.Running = false
+	container2.State.SetStopped(0)
 }
 
 func TestReloadContainerLinks(t *testing.T) {
@@ -638,11 +638,11 @@ func TestReloadContainerLinks(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if !container2.State.Running {
+	if !container2.State.IsRunning() {
 		t.Fatalf("Container %v should appear as running but isn't", container2.ID)
 	}
 
-	if !container1.State.Running {
+	if !container1.State.IsRunning() {
 		t.Fatalf("Container %s should appear as running but isn't", container1.ID)
 	}
 
@@ -669,7 +669,7 @@ func TestReloadContainerLinks(t *testing.T) {
 	}
 	runningCount := 0
 	for _, c := range runtime2.List() {
-		if c.State.Running {
+		if c.State.IsRunning() {
 			runningCount++
 		}
 	}
diff --git a/components/engine/integration/utils_test.go b/components/engine/integration/utils_test.go
index 278924edb7..1f47c45382 100644
--- a/components/engine/integration/utils_test.go
+++ b/components/engine/integration/utils_test.go
@@ -111,7 +111,7 @@ func containerKill(eng *engine.Engine, id string, t utils.Fataler) {
 }
 
 func containerRunning(eng *engine.Engine, id string, t utils.Fataler) bool {
-	return getContainer(eng, id, t).State.Running
+	return getContainer(eng, id, t).State.IsRunning()
 }
 
 func containerAssertExists(eng *engine.Engine, id string, t utils.Fataler) {
diff --git a/components/engine/links.go b/components/engine/links.go
index 3c689d0bf3..2fe255b4c5 100644
--- a/components/engine/links.go
+++ b/components/engine/links.go
@@ -21,7 +21,7 @@ func NewLink(parent, child *Container, name, bridgeInterface string) (*Link, err
 	if parent.ID == child.ID {
 		return nil, fmt.Errorf("Cannot link to self: %s == %s", parent.ID, child.ID)
 	}
-	if !child.State.Running {
+	if !child.State.IsRunning() {
 		return nil, fmt.Errorf("Cannot link to a non running container: %s AS %s", child.Name, name)
 	}
 
diff --git a/components/engine/runtime.go b/components/engine/runtime.go
index f453a0a705..3c90616f16 100644
--- a/components/engine/runtime.go
+++ b/components/engine/runtime.go
@@ -100,8 +100,8 @@ func (runtime *Runtime) load(id string) (*Container, error) {
 	if container.ID != id {
 		return container, fmt.Errorf("Container %s is stored at %s", container.ID, id)
 	}
-	if container.State.Running {
-		container.State.Ghost = true
+	if container.State.IsRunning() {
+		container.State.SetGhost(true)
 	}
 	return container, nil
 }
@@ -136,7 +136,7 @@ func (runtime *Runtime) Register(container *Container) error {
 	// 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
-	if container.State.Running {
+	if container.State.IsRunning() {
 		output, err := exec.Command("lxc-info", "-n", container.ID).CombinedOutput()
 		if err != nil {
 			return err
@@ -145,14 +145,14 @@ func (runtime *Runtime) Register(container *Container) error {
 			utils.Debugf("Container %s was supposed to be running be is not.", container.ID)
 			if runtime.config.AutoRestart {
 				utils.Debugf("Restarting")
-				container.State.Ghost = false
-				container.State.setStopped(0)
+				container.State.SetGhost(false)
+				container.State.SetStopped(0)
 				if err := container.Start(); err != nil {
 					return err
 				}
 			} else {
 				utils.Debugf("Marking as stopped")
-				container.State.setStopped(-127)
+				container.State.SetStopped(-127)
 				if err := container.ToDisk(); err != nil {
 					return err
 				}
diff --git a/components/engine/server.go b/components/engine/server.go
index 39c6dfdc6d..b4632339d8 100644
--- a/components/engine/server.go
+++ b/components/engine/server.go
@@ -694,7 +694,7 @@ func (srv *Server) Containers(all, size bool, n int, since, before string) []API
 	}, -1)
 
 	for _, container := range srv.runtime.List() {
-		if !container.State.Running && !all && n == -1 && since == "" && before == "" {
+		if !container.State.IsRunning() && !all && n == -1 && since == "" && before == "" {
 			continue
 		}
 		if before != "" {
@@ -1342,7 +1342,7 @@ func (srv *Server) ContainerDestroy(name string, removeVolume, removeLink bool)
 	}
 
 	if container != nil {
-		if container.State.Running {
+		if container.State.IsRunning() {
 			return fmt.Errorf("Impossible to remove a running container, please stop it first")
 		}
 		volumes := make(map[string]struct{})
@@ -1504,7 +1504,7 @@ func (srv *Server) ImageDelete(name string, autoPrune bool) ([]APIRmi, error) {
 
 	// Prevent deletion if image is used by a running container
 	for _, container := range srv.runtime.List() {
-		if container.State.Running {
+		if container.State.IsRunning() {
 			parent, err := srv.runtime.repositories.LookupImage(container.Image)
 			if err != nil {
 				return nil, err
@@ -1726,7 +1726,7 @@ func (srv *Server) ContainerAttach(name string, logs, stream, stdin, stdout, std
 
 	//stream
 	if stream {
-		if container.State.Ghost {
+		if container.State.IsGhost() {
 			return fmt.Errorf("Impossible to attach to a ghost container")
 		}
 
diff --git a/components/engine/state.go b/components/engine/state.go
index af7de9f4da..71775719f1 100644
--- a/components/engine/state.go
+++ b/components/engine/state.go
@@ -8,7 +8,7 @@ import (
 )
 
 type State struct {
-	sync.Mutex
+	sync.RWMutex
 	Running    bool
 	Pid        int
 	ExitCode   int
@@ -19,6 +19,9 @@ type State struct {
 
 // String returns a human-readable description of the state
 func (s *State) String() string {
+	s.RLock()
+	defer s.RUnlock()
+
 	if s.Running {
 		if s.Ghost {
 			return fmt.Sprintf("Ghost")
@@ -28,7 +31,38 @@ func (s *State) String() string {
 	return fmt.Sprintf("Exit %d", s.ExitCode)
 }
 
-func (s *State) setRunning(pid int) {
+func (s *State) IsRunning() bool {
+	s.RLock()
+	defer s.RUnlock()
+
+	return s.Running
+}
+
+func (s *State) IsGhost() bool {
+	s.RLock()
+	defer s.RUnlock()
+
+	return s.Ghost
+}
+
+func (s *State) GetExitCode() int {
+	s.RLock()
+	defer s.RUnlock()
+
+	return s.ExitCode
+}
+
+func (s *State) SetGhost(val bool) {
+	s.Lock()
+	defer s.Unlock()
+
+	s.Ghost = val
+}
+
+func (s *State) SetRunning(pid int) {
+	s.Lock()
+	defer s.Unlock()
+
 	s.Running = true
 	s.Ghost = false
 	s.ExitCode = 0
@@ -36,7 +70,10 @@ func (s *State) setRunning(pid int) {
 	s.StartedAt = time.Now()
 }
 
-func (s *State) setStopped(exitCode int) {
+func (s *State) SetStopped(exitCode int) {
+	s.Lock()
+	defer s.Unlock()
+
 	s.Running = false
 	s.Pid = 0
 	s.FinishedAt = time.Now()

From 89913b08346bed9588ccfa1a8609e69f5aa9fdeb Mon Sep 17 00:00:00 2001
From: Victor Vieux <victor@docker.com>
Date: Thu, 21 Nov 2013 17:51:28 -0800
Subject: [PATCH 184/184] Bump version to v0.6.7 Upstream-commit:
 53f1bf0f995d4c0e6af3eb14cd76a1b049c851a2 Component: engine

---
 components/engine/CHANGELOG.md | 39 ++++++++++++++++++++++++++++++++++
 components/engine/VERSION      |  2 +-
 2 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/components/engine/CHANGELOG.md b/components/engine/CHANGELOG.md
index 8c08cefaad..a1042ba53a 100644
--- a/components/engine/CHANGELOG.md
+++ b/components/engine/CHANGELOG.md
@@ -1,5 +1,43 @@
 # Changelog
 
+## 0.6.7 (2013-11-21)
+
+#### Runtime
+
+* Improved stability, fixes some race conditons
+* Skip the volumes mounted when deleting the volumes of container.
+* Fix layer size computation: handle hard links correctly
+* Use the work Path for docker cp CONTAINER:PATH
+* Fix tmp dir never cleanup
+* Speedup docker ps
+* More informative error message on name collisions
+* Fix nameserver regex
+* Always return long id's
+* Fix container restart race condition
+* Keep published ports on docker stop;docker start
+* Fix container networking on Fedora
+* Correctly express "any address" to iptables
+* Fix network setup when reconnecting to ghost container
+* Prevent deletion if image is used by a running container
+* Lock around read operations in graph
+
+#### RemoteAPI
+
+* Return full ID on docker rmi
+
+#### Client
+
++ Add -tree option to images
++ Offline image transfer
+* Exit with status 2 on usage error and display usage on stderr
+* Do not forward SIGCHLD to container
+* Use string timestamp for docker events -since
+
+#### Other
+
+* Update to go 1.2rc5
++ Add /etc/default/docker support to upstart
+
 ## 0.6.6 (2013-11-06)
 
 #### Runtime
@@ -17,6 +55,7 @@
 + Prevent DNS server conflicts in CreateBridgeIface
 + Validate bind mounts on the server side
 + Use parent image config in docker build
+* Fix regression in /etc/hosts
 
 #### Client
 
diff --git a/components/engine/VERSION b/components/engine/VERSION
index 3e8bed9e92..2228cad41f 100644
--- a/components/engine/VERSION
+++ b/components/engine/VERSION
@@ -1 +1 @@
-0.6.6-dev
+0.6.7