Implement the COPY operator within the builder

- Packaging: Fixed Vagrantfile
* Documentation: Updated install instructions

CHANGELOG.md

@@ -0,0 +1,86 @@
+# Changelog
+
+## 0.2.0 (2012-04-23)
+ - Runtime: ghost containers can be killed and waited for
+ * Documentation: update install intructions
+ - Packaging: fix Vagrantfile
+ - Development: automate releasing binaries and ubuntu packages
+ + Add a changelog
+ - Various bugfixes
+
+
+## 0.1.8 (2013-04-22)
+ - Dynamically detect cgroup capabilities
+ - Issue stability warning on kernels <3.8
+ - 'docker push' buffers on disk instead of memory
+ - Fix 'docker diff' for removed files
+ - Fix 'docker stop' for ghost containers 
+ - Fix handling of pidfile
+ - Various bugfixes and stability improvements
+
+## 0.1.7 (2013-04-18)
+ - Container ports are available on localhost
+ - 'docker ps' shows allocated TCP ports
+ - Contributors can run 'make hack' to start a continuous integration VM
+ - Streamline ubuntu packaging & uploading
+ - Various bugfixes and stability improvements
+
+## 0.1.6 (2013-04-17)
+ - Record the author an image with 'docker commit -author'
+
+## 0.1.5 (2013-04-17)
+ - Disable standalone mode
+ - Use a custom DNS resolver with 'docker -d -dns'
+ - Detect ghost containers
+ - Improve diagnosis of missing system capabilities
+ - Allow disabling memory limits at compile time
+ - Add debian packaging
+ - Documentation: installing on Arch Linux 
+ - Documentation: running Redis on docker
+ - Fixed lxc 0.9 compatibility
+ - Automatically load aufs module
+ - Various bugfixes and stability improvements
+
+## 0.1.4 (2013-04-09)
+ - Full support for TTY emulation
+ - Detach from a TTY session with the escape sequence `C-p C-q`
+ - Various bugfixes and stability improvements
+ - Minor UI improvements
+ - Automatically create our own bridge interface 'docker0'
+
+## 0.1.3 (2013-04-04)
+ - Choose TCP frontend port with '-p :PORT'
+ - Layer format is versioned
+ - Major reliability improvements to the process manager
+ - Various bugfixes and stability improvements
+
+## 0.1.2 (2013-04-03)
+ - Set container hostname with 'docker run -h'
+ - Selective attach at run with 'docker run -a [stdin[,stdout[,stderr]]]'
+ - Various bugfixes and stability improvements
+ - UI polish
+ - Progress bar on push/pull
+ - Use XZ compression by default
+ - Make IP allocator lazy
+
+## 0.1.1 (2013-03-31)
+ - Display shorthand IDs for convenience
+ - Stabilize process management
+ - Layers can include a commit message
+ - Simplified 'docker attach'
+ - Fixed support for re-attaching
+ - Various bugfixes and stability improvements
+ - Auto-download at run
+ - Auto-login on push
+ - Beefed up documentation
+
+## 0.1.0 (2013-03-23)
+ - First release
+ - Implement registry in order to push/pull images
+ - TCP port allocation
+ - Fix termcaps on Linux
+ - Add documentation
+ - Add Vagrant support with Vagrantfile
+ - Add unit tests
+ - Add repository/tags to ease image management
+ - Improve the layer implementation

Makefile

@@ -1,5 +1,9 @@
 DOCKER_PACKAGE := github.com/dotcloud/docker
+RELEASE_VERSION := $(shell git tag | grep -E "v[0-9\.]+$$" | sort -nr | head -n 1)
+SRCRELEASE := docker-$(RELEASE_VERSION)
+BINRELEASE := docker-$(RELEASE_VERSION).tgz
 
+GIT_ROOT := $(shell git rev-parse --show-toplevel)
 BUILD_DIR := $(CURDIR)/.gopath
 
 GOPATH ?= $(BUILD_DIR)
@@ -23,18 +27,38 @@ DOCKER_MAIN := $(DOCKER_DIR)/docker
 DOCKER_BIN_RELATIVE := bin/docker
 DOCKER_BIN := $(CURDIR)/$(DOCKER_BIN_RELATIVE)
 
-.PHONY: all clean test hack
+.PHONY: all clean test hack release srcrelease $(BINRELEASE) $(SRCRELEASE) $(DOCKER_BIN) $(DOCKER_DIR)
 
 all: $(DOCKER_BIN)
 
 $(DOCKER_BIN): $(DOCKER_DIR)
 	@mkdir -p  $(dir $@)
-	@(cd $(DOCKER_MAIN); go get $(GO_OPTIONS); go build $(GO_OPTIONS) $(BUILD_OPTIONS) -o $@)
+	@(cd $(DOCKER_MAIN); go build $(GO_OPTIONS) $(BUILD_OPTIONS) -o $@)
 	@echo $(DOCKER_BIN_RELATIVE) is created.
 
 $(DOCKER_DIR):
 	@mkdir -p $(dir $@)
+	@rm -f $@
 	@ln -sf $(CURDIR)/ $@
+	@(cd $(DOCKER_MAIN); go get $(GO_OPTIONS))
+
+whichrelease:
+	echo $(RELEASE_VERSION)
+
+release: $(BINRELEASE)
+srcrelease: $(SRCRELEASE)
+deps: $(DOCKER_DIR)
+
+# A clean checkout of $RELEASE_VERSION, with vendored dependencies
+$(SRCRELEASE):
+	rm -fr $(SRCRELEASE)
+	git clone $(GIT_ROOT) $(SRCRELEASE)
+	cd $(SRCRELEASE); git checkout -q $(RELEASE_VERSION)
+
+# A binary release ready to be uploaded to a mirror
+$(BINRELEASE): $(SRCRELEASE)
+	rm -f $(BINRELEASE)
+	cd $(SRCRELEASE); make; cp -R bin docker-$(RELEASE_VERSION); tar -f ../$(BINRELEASE) -zv -c docker-$(RELEASE_VERSION)
 
 clean:
 	@rm -rf $(dir $(DOCKER_BIN))

Vagrantfile

@@ -2,19 +2,12 @@
 # vi: set ft=ruby :
 
 def v10(config)
-  config.vm.box = "quantal64_3.5.0-25"
+  config.vm.box = 'precise64'
-  config.vm.box_url = "http://get.docker.io/vbox/ubuntu/12.10/quantal64_3.5.0-25.box"
+  config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
 
-  config.vm.share_folder "v-data", "/opt/go/src/github.com/dotcloud/docker", File.dirname(__FILE__)
+  # Install ubuntu packaging dependencies and create ubuntu packages
-
+  config.vm.provision :shell, :inline => "echo 'deb http://ppa.launchpad.net/dotcloud/lxc-docker/ubuntu precise main' >>/etc/apt/sources.list"
-  # Ensure puppet is installed on the instance
+  config.vm.provision :shell, :inline => 'export DEBIAN_FRONTEND=noninteractive; apt-get -qq update; apt-get install -qq -y --force-yes lxc-docker'
-  config.vm.provision :shell, :inline => "apt-get -qq update; apt-get install -y puppet"
-
-  config.vm.provision :puppet do |puppet|
-    puppet.manifests_path = "puppet/manifests"
-    puppet.manifest_file  = "quantal64.pp"
-    puppet.module_path = "puppet/modules"
-  end
 end
 
 Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|
@@ -30,11 +23,11 @@ Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
     config.vm.box = "dummy"
     config.vm.box_url = "https://github.com/mitchellh/vagrant-aws/raw/master/dummy.box"
     aws.access_key_id = ENV["AWS_ACCESS_KEY_ID"]
-    aws.secret_access_key = ENV["AWS_SECRET_ACCESS_KEY"]
+    aws.secret_access_key =     ENV["AWS_SECRET_ACCESS_KEY"]
     aws.keypair_name = ENV["AWS_KEYPAIR_NAME"]
     aws.ssh_private_key_path = ENV["AWS_SSH_PRIVKEY"]
     aws.region = "us-east-1"
-    aws.ami = "ami-ae9806c7"
+    aws.ami = "ami-d0f89fb9"
     aws.ssh_username = "ubuntu"
     aws.instance_type = "t1.micro"
   end
@@ -51,7 +44,39 @@ Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
   end
 
   config.vm.provider :virtualbox do |vb|
-    config.vm.box = "quantal64_3.5.0-25"
+    config.vm.box = 'precise64'
-    config.vm.box_url = "http://get.docker.io/vbox/ubuntu/12.10/quantal64_3.5.0-25.box"
+    config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
   end
 end
+
+Vagrant::VERSION >= "1.2.0" and Vagrant.configure("2") do |config|
+  config.vm.provider :aws do |aws, override|
+    config.vm.box = "dummy"
+    config.vm.box_url = "https://github.com/mitchellh/vagrant-aws/raw/master/dummy.box"
+    aws.access_key_id = ENV["AWS_ACCESS_KEY_ID"]
+    aws.secret_access_key = ENV["AWS_SECRET_ACCESS_KEY"]
+    aws.keypair_name = ENV["AWS_KEYPAIR_NAME"]
+    override.ssh.private_key_path = ENV["AWS_SSH_PRIVKEY"]
+    override.ssh.username = "ubuntu"
+    aws.region = "us-east-1"
+    aws.ami = "ami-d0f89fb9"
+    aws.instance_type = "t1.micro"
+  end
+
+  config.vm.provider :rackspace do |rs|
+    config.vm.box = "dummy"
+    config.vm.box_url = "https://github.com/mitchellh/vagrant-rackspace/raw/master/dummy.box"
+    config.ssh.private_key_path = ENV["RS_PRIVATE_KEY"]
+    rs.username = ENV["RS_USERNAME"]
+    rs.api_key  = ENV["RS_API_KEY"]
+    rs.public_key_path = ENV["RS_PUBLIC_KEY"]
+    rs.flavor   = /512MB/
+    rs.image    = /Ubuntu/
+  end
+
+  config.vm.provider :virtualbox do |vb|
+    config.vm.box = 'precise64'
+    config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
+  end
+
+end

builder.go

@@ -0,0 +1,169 @@
+package docker
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"strings"
+)
+
+type Builder struct {
+	runtime *Runtime
+}
+
+func NewBuilder(runtime *Runtime) *Builder {
+	return &Builder{
+		runtime: runtime,
+	}
+}
+
+func (builder *Builder) Run(image *Image, cmd ...string) (*Container, error) {
+	// FIXME: pass a NopWriter instead of nil
+	config, err := ParseRun(append([]string{"-d", image.Id}, cmd...), nil, builder.runtime.capabilities)
+	if config.Image == "" {
+		return nil, fmt.Errorf("Image not specified")
+	}
+	if len(config.Cmd) == 0 {
+		return nil, fmt.Errorf("Command not specified")
+	}
+	if config.Tty {
+		return nil, fmt.Errorf("The tty mode is not supported within the builder")
+	}
+
+	// Create new container
+	container, err := builder.runtime.Create(config)
+	if err != nil {
+		return nil, err
+	}
+	if err := container.Start(); err != nil {
+		return nil, err
+	}
+	return container, nil
+}
+
+func (builder *Builder) Commit(container *Container, repository, tag, comment, author string) (*Image, error) {
+	return builder.runtime.Commit(container.Id, repository, tag, comment, author)
+}
+
+func (builder *Builder) clearTmp(containers, images map[string]struct{}) {
+	for c := range containers {
+		tmp := builder.runtime.Get(c)
+		builder.runtime.Destroy(tmp)
+		Debugf("Removing container %s", c)
+	}
+	for i := range images {
+		builder.runtime.graph.Delete(i)
+		Debugf("Removing image %s", i)
+	}
+}
+
+func (builder *Builder) Build(dockerfile io.Reader, stdout io.Writer) error {
+	var (
+		image, base   *Image
+		tmpContainers map[string]struct{} = make(map[string]struct{})
+		tmpImages     map[string]struct{} = make(map[string]struct{})
+	)
+	defer builder.clearTmp(tmpContainers, tmpImages)
+
+	file := bufio.NewReader(dockerfile)
+	for {
+		line, err := file.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		line = strings.TrimSpace(line)
+		// Skip comments and empty line
+		if len(line) == 0 || line[0] == '#' {
+			continue
+		}
+		tmp := strings.SplitN(line, "	", 2)
+		if len(tmp) != 2 {
+			return fmt.Errorf("Invalid Dockerfile format")
+		}
+		switch tmp[0] {
+		case "from":
+			fmt.Fprintf(stdout, "FROM %s\n", tmp[1])
+			image, err = builder.runtime.repositories.LookupImage(tmp[1])
+			if err != nil {
+				return err
+			}
+			break
+		case "run":
+			fmt.Fprintf(stdout, "RUN %s\n", tmp[1])
+			if image == nil {
+				return fmt.Errorf("Please provide a source image with `from` prior to run")
+			}
+
+			// Create the container and start it
+			c, err := builder.Run(image, "/bin/sh", "-c", tmp[1])
+			if err != nil {
+				return err
+			}
+			tmpContainers[c.Id] = struct{}{}
+
+			// Wait for it to finish
+			if result := c.Wait(); result != 0 {
+				return fmt.Errorf("!!! '%s' return non-zero exit code '%d'. Aborting.", tmp[1], result)
+			}
+
+			// Commit the container
+			base, err = builder.Commit(c, "", "", "", "")
+			if err != nil {
+				return err
+			}
+			tmpImages[base.Id] = struct{}{}
+
+			fmt.Fprintf(stdout, "===> %s\n", base.ShortId())
+			break
+		case "copy":
+			if image == nil {
+				return fmt.Errorf("Please provide a source image with `from` prior to copy")
+			}
+			tmp2 := strings.SplitN(tmp[1], " ", 2)
+			if len(tmp) != 2 {
+				return fmt.Errorf("Invalid COPY format")
+			}
+			fmt.Fprintf(stdout, "COPY %s to %s in %s\n", tmp2[0], tmp2[1], base.ShortId())
+
+			file, err := Download(tmp2[0], stdout)
+			if err != nil {
+				return err
+			}
+			defer file.Body.Close()
+
+			c, err := builder.Run(base, "echo", "insert", tmp2[0], tmp2[1])
+			if err != nil {
+				return err
+			}
+
+			if err := c.Inject(file.Body, tmp2[1]); err != nil {
+				return err
+			}
+
+			base, err = builder.Commit(c, "", "", "", "")
+			if err != nil {
+				return err
+			}
+			fmt.Fprintf(stdout, "===> %s\n", base.ShortId())
+			break
+		default:
+			fmt.Fprintf(stdout, "Skipping unknown op %s\n", tmp[0])
+		}
+	}
+	if base != nil {
+		// The build is successful, keep the temporary containers and images
+		for i := range tmpImages {
+			delete(tmpImages, i)
+		}
+		for i := range tmpContainers {
+			delete(tmpContainers, i)
+		}
+		fmt.Fprintf(stdout, "Build finished. image id: %s\n", base.ShortId())
+	} else {
+		fmt.Fprintf(stdout, "An error occured during the build\n")
+	}
+	return nil
+}

commands.go

@@ -10,6 +10,7 @@ import (
 	"log"
 	"net/http"
 	"net/url"
+	"os"
 	"runtime"
 	"strconv"
 	"strings"
@@ -18,7 +19,7 @@ import (
 	"unicode"
 )
 
-const VERSION = "0.1.8"
+const VERSION = "0.2.0"
 
 var (
 	GIT_COMMIT string
@@ -33,6 +34,7 @@ func (srv *Server) Help() string {
 	help := "Usage: docker COMMAND [arg...]\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n"
 	for _, cmd := range [][]string{
 		{"attach", "Attach to a running container"},
+		{"build", "Build a container from Dockerfile"},
 		{"commit", "Create a new image from a container's changes"},
 		{"diff", "Inspect changes on a container's filesystem"},
 		{"export", "Stream the contents of a container as a tar archive"},
@@ -40,6 +42,7 @@ func (srv *Server) Help() string {
 		{"images", "List images"},
 		{"import", "Create a new filesystem image from the contents of a tarball"},
 		{"info", "Display system-wide information"},
+		{"insert", "Insert a file in an image"},
 		{"inspect", "Return low-level information on a container"},
 		{"kill", "Kill a running container"},
 		{"login", "Register or Login to the docker registry server"},
@@ -63,6 +66,74 @@ func (srv *Server) Help() string {
 	return help
 }
 
+func (srv *Server) CmdInsert(stdin io.ReadCloser, stdout rcli.DockerConn, args ...string) error {
+	stdout.Flush()
+	cmd := rcli.Subcmd(stdout, "insert", "IMAGE URL PATH", "Insert a file from URL in the IMAGE at PATH")
+	if err := cmd.Parse(args); err != nil {
+		return nil
+	}
+	if cmd.NArg() != 3 {
+		cmd.Usage()
+		return nil
+	}
+	imageId := cmd.Arg(0)
+	url := cmd.Arg(1)
+	path := cmd.Arg(2)
+
+	img, err := srv.runtime.repositories.LookupImage(imageId)
+	if err != nil {
+		return err
+	}
+	file, err := Download(url, stdout)
+	if err != nil {
+		return err
+	}
+	defer file.Body.Close()
+
+	b := NewBuilder(srv.runtime)
+	c, err := b.Run(img, "echo", "insert", url, path)
+	if err != nil {
+		return err
+	}
+
+	if err := c.Inject(ProgressReader(file.Body, int(file.ContentLength), stdout, "Downloading %v/%v (%v)"), path); err != nil {
+		return err
+	}
+	// FIXME: Handle custom repo, tag comment, author
+	img, err = b.Commit(c, "", "", img.Comment, img.Author)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(stdout, "%s\n", img.Id)
+	return nil
+}
+
+func (srv *Server) CmdBuild(stdin io.ReadCloser, stdout rcli.DockerConn, args ...string) error {
+	stdout.Flush()
+	cmd := rcli.Subcmd(stdout, "build", "[Dockerfile|-]", "Build a container from Dockerfile")
+	if err := cmd.Parse(args); err != nil {
+		return nil
+	}
+	dockerfile := cmd.Arg(0)
+	if dockerfile == "" {
+		dockerfile = "Dockerfile"
+	}
+
+	var file io.Reader
+
+	if dockerfile != "-" {
+		f, err := os.Open(dockerfile)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+		file = f
+	} else {
+		file = stdin
+	}
+	return NewBuilder(srv.runtime).Build(file, stdout)
+}
+
 // 'docker login': login / register a user to registry service.
 func (srv *Server) CmdLogin(stdin io.ReadCloser, stdout rcli.DockerConn, args ...string) error {
 	// Read a line on raw terminal with support for simple backspace
@@ -836,6 +907,10 @@ func (srv *Server) CmdAttach(stdin io.ReadCloser, stdout rcli.DockerConn, args .
 		return fmt.Errorf("No such container: %s", name)
 	}
 
+	if container.State.Ghost {
+		return fmt.Errorf("Impossible to attach to a ghost container")
+	}
+
 	if container.Config.Tty {
 		stdout.SetOptionRawTerminal()
 	}

container.go

@@ -168,6 +168,23 @@ func (settings *NetworkSettings) PortMappingHuman() string {
 	return strings.Join(mapping, ", ")
 }
 
+// Inject the io.Reader at the given path. Note: do not close the reader
+func (container *Container) Inject(file io.Reader, pth string) error {
+	// Make sure the directory exists
+	if err := os.MkdirAll(path.Join(container.rwPath(), path.Dir(pth)), 0755); err != nil {
+		return err
+	}
+	// FIXME: Handle permissions/already existing dest
+	dest, err := os.Create(path.Join(container.rwPath(), pth))
+	if err != nil {
+		return err
+	}
+	if _, err := io.Copy(dest, file); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (container *Container) Cmd() *exec.Cmd {
 	return container.cmd
 }
@@ -530,16 +547,42 @@ func (container *Container) releaseNetwork() {
 	container.NetworkSettings = &NetworkSettings{}
 }
 
+// FIXME: replace this with a control socket within docker-init
+func (container *Container) waitLxc() error {
+	for {
+		if output, err := exec.Command("lxc-info", "-n", container.Id).CombinedOutput(); err != nil {
+			return err
+		} else {
+			if !strings.Contains(string(output), "RUNNING") {
+				return nil
+			}
+		}
+		time.Sleep(500 * time.Millisecond)
+	}
+	return nil
+}
+
 func (container *Container) monitor() {
 	// Wait for the program to exit
 	Debugf("Waiting for process")
-	if err := container.cmd.Wait(); err != nil {
+
-		// Discard the error as any signals or non 0 returns will generate an error
+	// If the command does not exists, try to wait via lxc
-		Debugf("%s: Process: %s", container.Id, err)
+	if container.cmd == nil {
+		if err := container.waitLxc(); err != nil {
+			Debugf("%s: Process: %s", container.Id, err)
+		}
+	} else {
+		if err := container.cmd.Wait(); err != nil {
+			// Discard the error as any signals or non 0 returns will generate an error
+			Debugf("%s: Process: %s", container.Id, err)
+		}
 	}
 	Debugf("Process finished")
 
-	exitCode := container.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
+	var exitCode int = -1
+	if container.cmd != nil {
+		exitCode = container.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
+	}
 
 	// Cleanup
 	container.releaseNetwork()
@@ -588,7 +631,7 @@ func (container *Container) monitor() {
 }
 
 func (container *Container) kill() error {
-	if !container.State.Running || container.cmd == nil {
+	if !container.State.Running {
 		return nil
 	}
 
@@ -600,6 +643,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.Id)
+		}
 		log.Printf("Container %s failed to exit within 10 seconds of lxc SIGKILL - trying direct SIGKILL", container.Id)
 		if err := container.cmd.Process.Kill(); err != nil {
 			return err
@@ -617,9 +663,6 @@ func (container *Container) Kill() error {
 	if !container.State.Running {
 		return nil
 	}
-	if container.State.Ghost {
-		return fmt.Errorf("Can't kill ghost container")
-	}
 	return container.kill()
 }
 
@@ -629,9 +672,6 @@ func (container *Container) Stop(seconds int) error {
 	if !container.State.Running {
 		return nil
 	}
-	if container.State.Ghost {
-		return fmt.Errorf("Can't stop ghost container")
-	}
 
 	// 1. Send a SIGTERM
 	if output, err := exec.Command("lxc-kill", "-n", container.Id, "15").CombinedOutput(); err != nil {

docs/Makefile

@@ -51,6 +51,7 @@ docs:
 	cp sources/dotcloud.yml $(BUILDDIR)/html/
 	cp sources/CNAME $(BUILDDIR)/html/
 	cp sources/.nojekyll $(BUILDDIR)/html/
+	cp sources/nginx.conf $(BUILDDIR)/html/
 	@echo
 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
 

docs/sources/concepts/buildingblocks.rst

@@ -10,7 +10,7 @@ Building blocks
 
 Images
 ------
-An original container image. These are stored on disk and are comparable with what you normally expect from a stoppped virtual machine image. Images are stored (and retrieved from) repository
+An original container image. These are stored on disk and are comparable with what you normally expect from a stopped virtual machine image. Images are stored (and retrieved from) repository
 
 Images are stored on your local file system under /var/lib/docker/images
 

docs/sources/examples/python_web_app.rst

@@ -49,7 +49,7 @@ Save the changed we just made in the container to a new image called "_/builds/g
     WEB_WORKER=$(docker run -d -p 5000 $BUILD_IMG /usr/local/bin/runapp)
 
 - **"docker run -d "** run a command in a new container. We pass "-d" so it runs as a daemon.
-  **"-p 5000"* the web app is going to listen on this port, so it must be mapped from the container to the host system.
+- **"-p 5000"** the web app is going to listen on this port, so it must be mapped from the container to the host system.
 - **"$BUILD_IMG"** is the image we want to run the command inside of.
 - **/usr/local/bin/runapp** is the command which starts the web app.
 

docs/sources/gettingstarted/index.html

@@ -71,34 +71,40 @@
                 <h2>
                     <a name="installing-on-ubuntu-1204-and-1210" class="anchor" href="#installing-on-ubuntu-1204-and-1210"><span class="mini-icon mini-icon-link"></span>
                     </a>Installing on Ubuntu</h2>
+
+                    <p><strong>Requirements</strong></p>
+                    <ul>
+                        <li>Ubuntu 12.04 (LTS) (64-bit)</li>
+                        <li> or Ubuntu 12.10 (quantal) (64-bit)</li>
+                    </ul>
                 <ol>
                     <li>
-                        <p>Install dependencies:</p>
+                    <p><strong>Install dependencies</strong></p>
+                    The linux-image-extra package is only needed on standard Ubuntu EC2 AMIs in order to install the aufs kernel module.
+                    <pre>sudo apt-get install linux-image-extra-`uname -r`</pre>
 
-                        <div class="highlight">
-                            <pre>sudo apt-get install lxc wget bsdtar curl</pre>
-                            <pre>sudo apt-get install linux-image-extra-<span class="sb">`</span>uname -r<span class="sb">`</span></pre></div>
 
-                        <p>The <code>linux-image-extra</code> package is needed on standard Ubuntu EC2 AMIs in order to install the aufs kernel module.</p>
                     </li>
                     <li>
-                        <p>Install the latest docker binary:</p>
+                        <p><strong>Install Docker</strong></p>
+                        <p>Add the Ubuntu PPA (Personal Package Archive) sources to your apt sources list, update and install.</p>
+                        <p>You may see some warnings that the GPG keys cannot be verified.</p>
+                        <div class="highlight">
+                            <pre>sudo sh -c "echo 'deb http://ppa.launchpad.net/dotcloud/lxc-docker/ubuntu precise main' >> /etc/apt/sources.list"</pre>
+                            <pre>sudo apt-get update</pre>
+                            <pre>sudo apt-get install lxc-docker</pre>
+                        </div>
+
+
+                    </li>
+
+                    <li>
+                        <p><strong>Run!</strong></p>
 
                         <div class="highlight">
-                            <pre>wget http://get.docker.io/builds/<span class="k">$(</span>uname -s<span class="k">)</span>/<span class="k">$(</span>uname -m<span class="k">)</span>/docker-master.tgz</pre>
+                            <pre>docker run -i -t ubuntu /bin/bash</pre>
-                            <pre>tar -xf docker-master.tgz</pre>
                         </div>
                     </li>
-                    <li>
-                        <p>Run your first container!</p>
-
-                        <div class="highlight"><pre><span class="nb">cd </span>docker-master</pre>
-                            <pre>sudo ./docker run -i -t base /bin/bash</pre>
-                        </div>
-                        <p>Done!</p>
-                        <p>Consider adding docker to your <code>PATH</code> for simplicity.</p>
-                    </li>
-
                     Continue with the <a href="http://docs.docker.io/en/latest/examples/hello_world/">Hello world</a> example.
                 </ol>
             </section>
@@ -117,7 +123,7 @@
                     vagrant and an Ubuntu virtual machine.</strong></p>
 
                 <ul>
-                    <li><a href="http://docs.docker.io/en/latest/installation/macos/">Mac OS X and other linuxes</a></li>
+                    <li><a href="http://docs.docker.io/en/latest/installation/vagrant/">Mac OS X and other linuxes</a></li>
                     <li><a href="http://docs.docker.io/en/latest/installation/windows/">Windows</a></li>
                 </ul>
 

docs/sources/installation/amazon.rst

@@ -1,8 +1,9 @@
 Amazon EC2
 ==========
 
-    Please note this is a community contributed installation path. The only 'official' installation is using the :ref:`ubuntu_linux` installation path. This version
+  Please note this is a community contributed installation path. The only 'official' installation is using the
-    may be out of date because it depends on some binaries to be updated and published
+  :ref:`ubuntu_linux` installation path. This version may sometimes be out of date.
+
 
 Installation
 ------------
@@ -17,7 +18,7 @@ Docker can now be installed on Amazon EC2 with a single vagrant command. Vagrant
        vagrant plugin install vagrant-aws
 
 
-3. Get the docker sources, this will give you the latest Vagrantfile and puppet manifests.
+3. Get the docker sources, this will give you the latest Vagrantfile.
 
    ::
 

docs/sources/installation/archlinux.rst

@@ -3,6 +3,10 @@
 Arch Linux
 ==========
 
+  Please note this is a community contributed installation path. The only 'official' installation is using the
+  :ref:`ubuntu_linux` installation path. This version may sometimes be out of date.
+
+
 Installing on Arch Linux is not officially supported but can be handled via 
 either of the following AUR packages:
 
@@ -40,6 +44,7 @@ new kernel will be compiled and this can take quite a while.
 
     yaourt -S lxc-docker-git
 
+
 Starting Docker
 ---------------
 
@@ -52,6 +57,7 @@ There is a systemd service unit created for docker.  To start the docker service
 
     sudo systemctl start docker
 
+
 To start on system boot:
 
 ::

docs/sources/installation/binaries.rst

@@ -0,0 +1,53 @@
+.. _binaries:
+
+Binaries
+========
+
+  **Please note this project is currently under heavy development. It should not be used in production.**
+
+
+Right now, the officially supported distributions are:
+
+- Ubuntu 12.04 (precise LTS) (64-bit)
+- Ubuntu 12.10 (quantal) (64-bit)
+
+
+Install dependencies:
+---------------------
+
+::
+
+    sudo apt-get install lxc bsdtar
+    sudo apt-get install linux-image-extra-`uname -r`
+
+The linux-image-extra package is needed on standard Ubuntu EC2 AMIs in order to install the aufs kernel module.
+
+Install the docker binary:
+
+::
+
+    wget http://get.docker.io/builds/Linux/x86_64/docker-master.tgz
+    tar -xf docker-master.tgz
+    sudo cp ./docker-master /usr/local/bin
+
+Note: docker currently only supports 64-bit Linux hosts.
+
+
+Run the docker daemon
+---------------------
+
+::
+
+    sudo docker -d &
+
+
+Run your first container!
+-------------------------
+
+::
+
+    docker run -i -t ubuntu /bin/bash
+
+
+
+Continue with the :ref:`hello_world` example.

docs/sources/installation/index.rst

@@ -13,8 +13,9 @@ Contents:
    :maxdepth: 1
 
    ubuntulinux
+   binaries
    archlinux
-   macos
+   vagrant
    windows
    amazon
    upgrading

docs/sources/installation/macos.rst

@@ -1,66 +0,0 @@
-
-Mac OS X and other linux
-========================
-
-  Please note this is a community contributed installation path. The only 'official' installation is using the :ref:`ubuntu_linux` installation path. This version
-  may be out of date because it depends on some binaries to be updated and published
-
-
-Requirements
-------------
-
-We currently rely on some Ubuntu-linux specific packages, this will change in the future, but for now we provide a
-streamlined path to install Virtualbox with a Ubuntu 12.10 image using Vagrant.
-
-1. Install virtualbox from https://www.virtualbox.org/ (or use your package manager)
-2. Install vagrant from http://www.vagrantup.com/ (or use your package manager)
-3. Install git if you had not installed it before, check if it is installed by running
-   ``git`` in a terminal window
-
-We recommend having at least about 2Gb of free disk space and 2Gb RAM (or more).
-
-Installation
-------------
-
-1. Fetch the docker sources
-
-.. code-block:: bash
-
-   git clone https://github.com/dotcloud/docker.git
-
-2. Run vagrant from the sources directory
-
-.. code-block:: bash
-
-    vagrant up
-
-Vagrant will:
-
-* Download the Quantal64 base ubuntu virtual machine image from get.docker.io/
-* Boot this image in virtualbox
-
-Then it will use Puppet to perform an initial setup in this machine:
-
-* Download & untar the most recent docker binary tarball to vagrant homedir.
-* Debootstrap to /var/lib/docker/images/ubuntu.
-* Install & run dockerd as service.
-* Put docker in /usr/local/bin.
-* Put latest Go toolchain in /usr/local/go.
-
-You now have a Ubuntu Virtual Machine running with docker pre-installed.
-
-To access the VM and use Docker, Run ``vagrant ssh`` from the same directory as where you ran
-``vagrant up``. Vagrant will make sure to connect you to the correct VM.
-
-.. code-block:: bash
-
-    vagrant ssh
-
-Now you are in the VM, run docker
-
-.. code-block:: bash
-
-    docker
-
-
-Continue with the :ref:`hello_world` example.

docs/sources/installation/ubuntulinux.rst

@@ -1,56 +1,61 @@
 .. _ubuntu_linux:
 
-Installing on Ubuntu Linux
+Ubuntu Linux
-==========================
+============
 
   **Please note this project is currently under heavy development. It should not be used in production.**
 
 
-
-Installing on Ubuntu 12.04 and 12.10
-
 Right now, the officially supported distributions are:
 
-* Ubuntu 12.04 (precise LTS)
+- Ubuntu 12.04 (precise LTS) (64-bit)
-* Ubuntu 12.10 (quantal)
+- Ubuntu 12.10 (quantal) (64-bit)
 
-Install dependencies:
+Dependencies
----------------------
+------------
 
-::
+The linux-image-extra package is only needed on standard Ubuntu EC2 AMIs in order to install the aufs kernel module.
 
-    sudo apt-get install lxc bsdtar
+.. code-block:: bash
-    sudo apt-get install linux-image-extra-`uname -r`
 
-The linux-image-extra package is needed on standard Ubuntu EC2 AMIs in order to install the aufs kernel module.
+   sudo apt-get install linux-image-extra-`uname -r`
-
-Install the docker binary
--------------------------
-
-::
-
-    wget http://get.docker.io/builds/Linux/x86_64/docker-master.tgz
-    tar -xf docker-master.tgz
-    sudo cp ./docker-master /usr/local/bin
-
-Note: docker currently only supports 64-bit Linux hosts.
 
 
-Run the docker daemon
+Installation
----------------------
+------------
 
-::
+Docker is available as a Ubuntu PPA (Personal Package Archive),
-
+`hosted on launchpad  <https://launchpad.net/~dotcloud/+archive/lxc-docker>`_
-    sudo docker -d &
+which makes installing Docker on Ubuntu very easy.
-
-Run your first container!
--------------------------
-
-::
-    docker run -i -t ubuntu /bin/bash
 
 
-Check out more examples
------------------------
 
-Continue with the :ref:`hello_world` example.
+Add the custom package sources to your apt sources list. Copy and paste the following lines at once.
+
+.. code-block:: bash
+
+   sudo sh -c "echo 'deb http://ppa.launchpad.net/dotcloud/lxc-docker/ubuntu precise main' >> /etc/apt/sources.list"
+
+
+Update your sources. You will see a warning that GPG signatures cannot be verified.
+
+.. code-block:: bash
+
+   sudo apt-get update
+
+
+Now install it, you will see another warning that the package cannot be authenticated. Confirm install.
+
+.. code-block:: bash
+
+   sudo apt-get install lxc-docker
+
+
+Verify it worked
+
+.. code-block:: bash
+
+   docker
+
+
+**Done!**, now continue with the :ref:`hello_world` example.

docs/sources/installation/upgrading.rst

@@ -3,7 +3,8 @@
 Upgrading
 ============
 
-   We assume you are upgrading from within the operating system which runs your docker daemon.
+These instructions are for upgrading your Docker binary for when you had a custom (non package manager) installation.
+If you istalled docker using apt-get, use that to upgrade.
 
 
 Get the latest docker binary:

docs/sources/installation/vagrant.rst

@@ -0,0 +1,70 @@
+
+.. _install_using_vagrant:
+
+Using Vagrant
+=============
+
+  Please note this is a community contributed installation path. The only 'official' installation is using the
+  :ref:`ubuntu_linux` installation path. This version may sometimes be out of date.
+
+**Requirements:**
+This guide will setup a new virtual machine with docker installed on your computer. This works on most operating
+systems, including MacOX, Windows, Linux, FreeBSD and others. If you can install these and have at least 400Mb RAM
+to spare you should be good.
+
+
+Install Vagrant and Virtualbox
+------------------------------
+
+1. Install virtualbox from https://www.virtualbox.org/ (or use your package manager)
+2. Install vagrant from http://www.vagrantup.com/ (or use your package manager)
+3. Install git if you had not installed it before, check if it is installed by running
+   ``git`` in a terminal window
+
+
+Spin it up
+----------
+
+1. Fetch the docker sources (this includes the Vagrantfile for machine setup).
+
+   .. code-block:: bash
+
+      git clone https://github.com/dotcloud/docker.git
+
+2. Run vagrant from the sources directory
+
+   .. code-block:: bash
+
+      vagrant up
+
+   Vagrant will:
+
+   * Download the 'official' Precise64 base ubuntu virtual machine image from vagrantup.com
+   * Boot this image in virtualbox
+   * Add the `Docker PPA sources <https://launchpad.net/~dotcloud/+archive/lxc-docker>`_ to /etc/apt/sources.lst
+   * Update your sources
+   * Install lxc-docker
+
+   You now have a Ubuntu Virtual Machine running with docker pre-installed.
+
+Connect
+-------
+
+To access the VM and use Docker, Run ``vagrant ssh`` from the same directory as where you ran
+``vagrant up``. Vagrant will connect you to the correct VM.
+
+.. code-block:: bash
+
+   vagrant ssh
+
+Run
+-----
+
+Now you are in the VM, run docker
+
+.. code-block:: bash
+
+   docker
+
+
+Continue with the :ref:`hello_world` example.

docs/sources/installation/windows.rst

@@ -3,8 +3,8 @@
 :keywords: Docker, Docker documentation, Windows, requirements, virtualbox, vagrant, git, ssh, putty, cygwin
 
 
-Windows
+Windows (with Vagrant)
-=========
+======================
 
   Please note this is a community contributed installation path. The only 'official' installation is using the :ref:`ubuntu_linux` installation path. This version
   may be out of date because it depends on some binaries to be updated and published

docs/sources/nginx.conf

@@ -0,0 +1,6 @@
+
+# rule to redirect original links created when hosted on github pages
+rewrite ^/documentation/(.*).html http://docs.docker.io/en/latest/$1/ permanent;
+
+# rewrite the stuff which was on the current page
+rewrite ^/gettingstarted.html$ /gettingstarted/ permanent;

hack/dockerbuilder/Dockerfile

@@ -0,0 +1,17 @@
+# This will build a container capable of producing an official binary build of docker and
+# uploading it to S3
+from	ubuntu:12.10
+run	apt-get update
+run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q s3cmd
+# Packages required to checkout and build docker
+run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q golang
+run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q git
+run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q build-essential
+# Packages required to build an ubuntu package
+run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q debhelper
+run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q autotools-dev
+copy	fake_initctl	/usr/local/bin/initctl
+run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q devscripts
+copy	dockerbuilder	/usr/local/bin/dockerbuilder
+copy	s3cfg	/.s3cfg
+# run $img dockerbuilder $REVISION_OR_TAG $S3_ID $S3_KEY

hack/dockerbuilder/dockerbuilder

@@ -0,0 +1,53 @@
+#!/bin/sh
+set -x
+set -e
+
+PACKAGE=github.com/dotcloud/docker
+
+if [ $# -gt 1 ]; then
+	echo "Usage: $0 [REVISION]"
+	exit 1
+fi
+
+export REVISION=$1
+
+if [ -z "$AWS_ID" ]; then
+	echo "Warning: environment variable AWS_ID is not set. Won't upload to S3."
+	NO_S3=1
+fi
+
+if [ -z "$AWS_KEY" ]; then
+	echo "Warning: environment variable AWS_KEY is not set. Won't upload to S3."
+	NO_S3=1
+fi
+
+if [ -z "$GPG_KEY" ]; then
+	echo "Warning: environment variable GPG_KEY is not set. Ubuntu package upload will not succeed."
+	NO_UBUNTU=1
+fi
+
+if [ -z "$REVISION" ]; then
+	rm -fr docker-master
+	git clone https://github.com/dotcloud/docker docker-master
+	cd docker-master
+else 
+	rm -fr docker-$REVISION
+	git init docker-$REVISION
+	cd docker-$REVISION
+	git fetch -t https://github.com/dotcloud/docker $REVISION
+	git reset --hard FETCH_HEAD
+fi
+
+if [ -z "$REVISION" ]; then
+	make release
+else
+	make release RELEASE_VERSION=$REVISION
+fi
+
+if [ -z "$NO_S3" ]; then
+	s3cmd -P put docker-$REVISION.tgz s3://get.docker.io/builds/$(uname -s)/$(uname -m)/docker-$REVISION.tgz
+fi
+
+if [ -z "$NO_UBUNTU" ]; then
+	(cd packaging/ubuntu && make ubuntu)
+fi

hack/dockerbuilder/fake_initctl

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+echo Whatever you say, man

hack/dockerbuilder/s3cfg

@@ -0,0 +1,3 @@
+[default]
+access_key = $AWS_ID
+secret_key = $AWS_KEY

packaging/ubuntu/changelog

@@ -1,30 +1,122 @@
+lxc-docker (0.2.0-1) precise; urgency=low
+
+  - Runtime: ghost containers can be killed and waited for
+  - Documentation: update install intructions
+  - Packaging: fix Vagrantfile
+  - Development: automate releasing binaries and ubuntu packages
+  - Add a changelog
+  - Various bugfixes
+
+ -- dotCloud <ops@dotcloud.com>  Mon, 23 Apr 2013 00:00:00 -0700
+
+
+lxc-docker (0.1.8-1) precise; urgency=low
+
+  - Dynamically detect cgroup capabilities
+  - Issue stability warning on kernels <3.8
+  - 'docker push' buffers on disk instead of memory
+  - Fix 'docker diff' for removed files
+  - Fix 'docker stop' for ghost containers
+  - Fix handling of pidfile
+  - Various bugfixes and stability improvements
+
+ -- dotCloud <ops@dotcloud.com>  Mon, 22 Apr 2013 00:00:00 -0700
+
+
+lxc-docker (0.1.7-1) precise; urgency=low
+
+  - Container ports are available on localhost
+  - 'docker ps' shows allocated TCP ports
+  - Contributors can run 'make hack' to start a continuous integration VM
+  - Streamline ubuntu packaging & uploading
+  - Various bugfixes and stability improvements
+
+ -- dotCloud <ops@dotcloud.com>  Thu, 18 Apr 2013 00:00:00 -0700
+
+
 lxc-docker (0.1.6-1) precise; urgency=low
 
-  Improvements [+], Updates [*], Bug fixes [-]:
+  - Record the author an image with 'docker commit -author'
-  + Multiple improvements, updates and bug fixes
 
- -- dotCloud <ops@dotcloud.com>  Wed, 17 Apr 2013 20:43:43 -0700
+ -- dotCloud <ops@dotcloud.com>  Wed, 17 Apr 2013 00:00:00 -0700
 
 
-lxc-docker (0.1.4.1-1) precise; urgency=low
+lxc-docker (0.1.5-1) precise; urgency=low
 
-  Improvements [+], Updates [*], Bug fixes [-]:
+  - Disable standalone mode
-  * Test PPA
+  - Use a custom DNS resolver with 'docker -d -dns'
+  - Detect ghost containers
+  - Improve diagnosis of missing system capabilities
+  - Allow disabling memory limits at compile time
+  - Add debian packaging
+  - Documentation: installing on Arch Linux
+  - Documentation: running Redis on docker
+  - Fixed lxc 0.9 compatibility
+  - Automatically load aufs module
+  - Various bugfixes and stability improvements
 
- -- dotCloud <ops@dotcloud.com>  Mon, 15 Apr 2013 12:14:50 -0700
+ -- dotCloud <ops@dotcloud.com>  Wed, 17 Apr 2013 00:00:00 -0700
 
 
 lxc-docker (0.1.4-1) precise; urgency=low
 
-  Improvements [+], Updates [*], Bug fixes [-]:
+  - Full support for TTY emulation
-  * Changed default bridge interface do 'docker0'
+  - Detach from a TTY session with the escape sequence `C-p C-q`
-  - Fix a race condition when running the port allocator
+  - Various bugfixes and stability improvements
+  - Minor UI improvements
+  - Automatically create our own bridge interface 'docker0'
 
- -- dotCloud <ops@dotcloud.com>  Fri, 12 Apr 2013 12:20:06 -0700
+ -- dotCloud <ops@dotcloud.com>  Tue,  9 Apr 2013 00:00:00 -0700
 
 
-lxc-docker (0.1.0-1) unstable; urgency=low
+lxc-docker (0.1.3-1) precise; urgency=low
 
-  * Initial release
+  - Choose TCP frontend port with '-p :PORT'
+  - Layer format is versioned
+  - Major reliability improvements to the process manager
+  - Various bugfixes and stability improvements
 
- -- dotCloud <ops@dotcloud.com>  Mon, 25 Mar 2013 05:51:12 -0700
+ -- dotCloud <ops@dotcloud.com>  Thu,  4 Apr 2013 00:00:00 -0700
+
+
+lxc-docker (0.1.2-1) precise; urgency=low
+
+  - Set container hostname with 'docker run -h'
+  - Selective attach at run with 'docker run -a [stdin[,stdout[,stderr]]]'
+  - Various bugfixes and stability improvements
+  - UI polish
+  - Progress bar on push/pull
+  - Use XZ compression by default
+  - Make IP allocator lazy
+
+ -- dotCloud <ops@dotcloud.com>  Wed,  3 Apr 2013 00:00:00 -0700
+
+
+lxc-docker (0.1.1-1) precise; urgency=low
+
+  - Display shorthand IDs for convenience
+  - Stabilize process management
+  - Layers can include a commit message
+  - Simplified 'docker attach'
+  - Fixed support for re-attaching
+  - Various bugfixes and stability improvements
+  - Auto-download at run
+  - Auto-login on push
+  - Beefed up documentation
+
+ -- dotCloud <ops@dotcloud.com>  Sun, 31 Mar 2013 00:00:00 -0700
+
+
+lxc-docker (0.1.0-1) precise; urgency=low
+
+  - First release
+  - Implement registry in order to push/pull images
+  - TCP port allocation
+  - Fix termcaps on Linux
+  - Add documentation
+  - Add Vagrant support with Vagrantfile
+  - Add unit tests
+  - Add repository/tags to ease image management
+  - Improve the layer implementation
+
+ -- dotCloud <ops@dotcloud.com>  Sat, 23 Mar 2013 00:00:00 -0700

packaging/ubuntu/maintainer.ubuntu

@@ -15,9 +15,12 @@ accessed adding the following line to /etc/apt/sources.list ::
 Releasing a new package
 ~~~~~~~~~~~~~~~~~~~~~~~
 
-The most relevant information to update is the changelog file:
+The most relevant information to update is the packaging/ubuntu/changelog file:
 Each new release should create a new first paragraph with new release version,
-changes, and the maintainer information.
+changes, and the maintainer information. The core of this paragraph is
+located on CHANGELOG.md. Make sure to transcribe it and translate the formats
+(eg: packaging/ubuntu/changelog uses 2 spaces for body change descriptions
+instead of 1 space from CHANGELOG.md)
 
 Assuming your PPA GPG signing key is on /media/usbdrive/docker.key, load it
 into the GPG_KEY environment variable with::
@@ -28,8 +31,9 @@ into the GPG_KEY environment variable with::
 After this is done and you are ready to upload the package to the PPA, you have
 a couple of choices:
 
-* Follow README.debian to generate the actual source packages and upload them
+* Follow packaging/ubuntu/README.ubuntu to generate the actual source packages
-  to the PPA
+  and upload them to the PPA
+
 * Let vagrant do all the work for you::
 
   ( cd docker/packaging/ubuntu; vagrant up )

runtime.go

@@ -184,12 +184,6 @@ func (runtime *Runtime) Register(container *Container) error {
 		}
 	}
 
-	// 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)
-	}
-
 	// Even if not running, we init the lock (prevents races in start/stop/kill)
 	container.State.initLock()
 
@@ -207,6 +201,15 @@ func (runtime *Runtime) Register(container *Container) error {
 	// done
 	runtime.containers.PushBack(container)
 	runtime.idIndex.Add(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 {
+		container.allocateNetwork()
+		go container.monitor()
+	}
 	return nil
 }
 

runtime_test.go

@@ -273,7 +273,7 @@ func TestAllocatePortLocalhost(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer container.Kill()
-	time.Sleep(300 * time.Millisecond) // Wait for the container to run
+	time.Sleep(600 * time.Millisecond) // Wait for the container to run
 	conn, err := net.Dial("tcp",
 		fmt.Sprintf(
 			"localhost:%s", container.NetworkSettings.PortMapping["5555"],

utils.go

@@ -442,7 +442,7 @@ func FindCgroupMountpoint(cgroupType string) (string, error) {
 		return "", err
 	}
 
-	reg := regexp.MustCompile(`^cgroup on (.*) type cgroup \(.*` + cgroupType + `[,\)]`)
+	reg := regexp.MustCompile(`^.* on (.*) type cgroup \(.*` + cgroupType + `[,\)]`)
 	for _, line := range strings.Split(string(output), "\n") {
 		r := reg.FindStringSubmatch(line)
 		if len(r) == 2 {