Bumped version to 0.2.1

* Packaging: connect to Ubuntu key server on port 80

CHANGELOG.md

@@ -0,0 +1,96 @@
+# Changelog
+
+## 0.2.1 (2012-05-01)
+ + 'docker commit -run' bundles a layer with default runtime options: command, ports etc. 
+ * Improve install process on Vagrant
+ + New Dockerfile operation: "maintainer"
+ + New Dockerfile operation: "expose"
+ + New Dockerfile operation: "cmd"
+ + Contrib script to build a Debian base layer
+ + 'docker -d -r': restart crashed containers at daemon startup
+ * Runtime: improve test coverage
+
+## 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

@@ -1,41 +1,37 @@
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-def v10(config)
-  config.vm.box = "quantal64_3.5.0-25"
-  config.vm.box_url = "http://get.docker.io/vbox/ubuntu/12.10/quantal64_3.5.0-25.box"
+BOX_NAME = "ubuntu"
+BOX_URI = "http://files.vagrantup.com/precise64.box"
+PPA_KEY = "E61D797F63561DC6"
 
-  config.vm.share_folder "v-data", "/opt/go/src/github.com/dotcloud/docker", File.dirname(__FILE__)
-
-  # Ensure puppet is installed on the instance
-  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"
+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
+  # Add docker PPA key to the local repository and install docker
+  pkg_cmd = "apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys #{PPA_KEY}; "
+  pkg_cmd << "echo 'deb http://ppa.launchpad.net/dotcloud/lxc-docker/ubuntu precise main' >>/etc/apt/sources.list; "
+  pkg_cmd << "apt-get update -qq; apt-get install -q -y lxc-docker"
+  if ARGV.include?("--provider=aws".downcase)
+    # Add AUFS dependency to amazon's VM
+    pkg_cmd << "; apt-get install linux-image-extra-3.2.0-40-virtual"
   end
+  config.vm.provision :shell, :inline => pkg_cmd
 end
 
-Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|
-  v10(config)
-end
-
-Vagrant::VERSION >= "1.1.0" and Vagrant.configure("1") do |config|
-  v10(config)
-end
-
+# Providers were added on Vagrant >= 1.1.0
 Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
-  config.vm.provider :aws do |aws|
+  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"]
-    aws.ssh_private_key_path = ENV["AWS_SSH_PRIVKEY"]
+    override.ssh.private_key_path = ENV["AWS_SSH_PRIVKEY"]
+    override.ssh.username = "ubuntu"
     aws.region = "us-east-1"
-    aws.ami = "ami-ae9806c7"
-    aws.ssh_username = "ubuntu"
+    aws.ami = "ami-d0f89fb9"
     aws.instance_type = "t1.micro"
   end
 
@@ -51,7 +47,15 @@ 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_url = "http://get.docker.io/vbox/ubuntu/12.10/quantal64_3.5.0-25.box"
+    config.vm.box = BOX_NAME
+    config.vm.box_url = BOX_URI
+  end
+
+  config.vm.provider :vmware_fusion do |vm|
+    config.vm.box = "precise64"
+    config.vm.box_url = "http://files.vagrantup.com/precise64_vmware_fusion.box"
+    config.vm.provision :shell, :inline => <<-UPDATE
+      apt-get install -y linux-image-extra-3.2.0-29-virtual
+    UPDATE
   end
 end

commands.go

@@ -18,7 +18,7 @@ import (
 	"unicode"
 )
 
-const VERSION = "0.1.8"
+const VERSION = "0.2.1"
 
 var (
 	GIT_COMMIT string
@@ -477,7 +477,7 @@ func (srv *Server) CmdImport(stdin io.ReadCloser, stdout rcli.DockerConn, args .
 		}
 		archive = ProgressReader(resp.Body, int(resp.ContentLength), stdout, "Importing %v/%v (%v)")
 	}
-	img, err := srv.runtime.graph.Create(archive, nil, "Imported from "+src, "")
+	img, err := srv.runtime.graph.Create(archive, nil, "Imported from "+src, "", nil)
 	if err != nil {
 		return err
 	}
@@ -726,6 +726,7 @@ func (srv *Server) CmdCommit(stdin io.ReadCloser, stdout io.Writer, args ...stri
 		"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"]}')`)
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -734,7 +735,16 @@ func (srv *Server) CmdCommit(stdin io.ReadCloser, stdout io.Writer, args ...stri
 		cmd.Usage()
 		return nil
 	}
-	img, err := srv.runtime.Commit(containerName, repository, tag, *flComment, *flAuthor)
+
+	var config *Config
+	if *flConfig != "" {
+		config = &Config{}
+		if err := json.Unmarshal([]byte(*flConfig), config); err != nil {
+			return err
+		}
+	}
+
+	img, err := srv.runtime.Commit(containerName, repository, tag, *flComment, *flAuthor, config)
 	if err != nil {
 		return err
 	}
@@ -836,6 +846,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()
 	}
@@ -921,10 +935,6 @@ func (srv *Server) CmdRun(stdin io.ReadCloser, stdout rcli.DockerConn, args ...s
 		fmt.Fprintln(stdout, "Error: Image not specified")
 		return fmt.Errorf("Image not specified")
 	}
-	if len(config.Cmd) == 0 {
-		fmt.Fprintln(stdout, "Error: Command not specified")
-		return fmt.Errorf("Command not specified")
-	}
 
 	if config.Tty {
 		stdout.SetOptionRawTerminal()
@@ -989,11 +999,11 @@ func (srv *Server) CmdRun(stdin io.ReadCloser, stdout rcli.DockerConn, args ...s
 	return nil
 }
 
-func NewServer() (*Server, error) {
+func NewServer(autoRestart bool) (*Server, error) {
 	if runtime.GOARCH != "amd64" {
 		log.Fatalf("The docker runtime currently only supports amd64 (not %s). This will change in the future. Aborting.", runtime.GOARCH)
 	}
-	runtime, err := NewRuntime()
+	runtime, err := NewRuntime(autoRestart)
 	if err != nil {
 		return nil, err
 	}

commands_test.go

@@ -394,4 +394,5 @@ func TestAttachDisconnect(t *testing.T) {
 	// Try to avoid the timeoout in destroy. Best effort, don't check error
 	cStdin, _ := container.StdinPipe()
 	cStdin.Close()
+	container.Wait()
 }

container.go

@@ -530,16 +530,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
-		Debugf("%s: Process: %s", container.Id, err)
+
+	// If the command does not exists, try to wait via lxc
+	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 +614,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 +626,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 +646,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 +655,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 {

container_test.go

@@ -22,9 +22,8 @@ func TestIdFormat(t *testing.T) {
 	defer nuke(runtime)
 	container1, err := runtime.Create(
 		&Config{
-			Image:  GetTestImage(runtime).Id,
-			Cmd:    []string{"/bin/sh", "-c", "echo hello world"},
-			Memory: 33554432,
+			Image: GetTestImage(runtime).Id,
+			Cmd:   []string{"/bin/sh", "-c", "echo hello world"},
 		},
 	)
 	if err != nil {
@@ -50,7 +49,6 @@ func TestMultipleAttachRestart(t *testing.T) {
 			Image: GetTestImage(runtime).Id,
 			Cmd: []string{"/bin/sh", "-c",
 				"i=1; while [ $i -le 5 ]; do i=`expr $i + 1`;  echo hello; done"},
-			Memory: 33554432,
 		},
 	)
 	if err != nil {
@@ -116,8 +114,8 @@ func TestMultipleAttachRestart(t *testing.T) {
 	if err := container.Start(); err != nil {
 		t.Fatal(err)
 	}
-	timeout := make(chan bool)
-	go func() {
+
+	setTimeout(t, "Timeout reading from the process", 3*time.Second, func() {
 		l1, err = bufio.NewReader(stdout1).ReadString('\n')
 		if err != nil {
 			t.Fatal(err)
@@ -139,15 +137,8 @@ func TestMultipleAttachRestart(t *testing.T) {
 		if strings.Trim(l3, " \r\n") != "hello" {
 			t.Fatalf("Unexpected output. Expected [%s], received [%s]", "hello", l3)
 		}
-		timeout <- false
-	}()
-	go func() {
-		time.Sleep(3 * time.Second)
-		timeout <- true
-	}()
-	if <-timeout {
-		t.Fatalf("Timeout reading from the process")
-	}
+	})
+	container.Wait()
 }
 
 func TestDiff(t *testing.T) {
@@ -193,7 +184,7 @@ func TestDiff(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image - diff", "")
+	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image - diff", "", nil)
 	if err != nil {
 		t.Error(err)
 	}
@@ -226,7 +217,7 @@ func TestDiff(t *testing.T) {
 	}
 }
 
-func TestCommitRun(t *testing.T) {
+func TestCommitAutoRun(t *testing.T) {
 	runtime, err := newTestRuntime()
 	if err != nil {
 		t.Fatal(err)
@@ -234,9 +225,8 @@ func TestCommitRun(t *testing.T) {
 	defer nuke(runtime)
 	container1, err := runtime.Create(
 		&Config{
-			Image:  GetTestImage(runtime).Id,
-			Cmd:    []string{"/bin/sh", "-c", "echo hello > /world"},
-			Memory: 33554432,
+			Image: GetTestImage(runtime).Id,
+			Cmd:   []string{"/bin/sh", "-c", "echo hello > /world"},
 		},
 	)
 	if err != nil {
@@ -258,7 +248,7 @@ func TestCommitRun(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image", "")
+	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image", "", &Config{Cmd: []string{"cat", "/world"}})
 	if err != nil {
 		t.Error(err)
 	}
@@ -267,9 +257,86 @@ func TestCommitRun(t *testing.T) {
 
 	container2, err := runtime.Create(
 		&Config{
-			Image:  img.Id,
-			Memory: 33554432,
-			Cmd:    []string{"cat", "/world"},
+			Image: img.Id,
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container2)
+	stdout, err := container2.StdoutPipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	stderr, err := container2.StderrPipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := container2.Start(); err != nil {
+		t.Fatal(err)
+	}
+	container2.Wait()
+	output, err := ioutil.ReadAll(stdout)
+	if err != nil {
+		t.Fatal(err)
+	}
+	output2, err := ioutil.ReadAll(stderr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := stdout.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if err := stderr.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if string(output) != "hello\n" {
+		t.Fatalf("Unexpected output. Expected %s, received: %s (err: %s)", "hello\n", output, output2)
+	}
+}
+
+func TestCommitRun(t *testing.T) {
+	runtime, err := newTestRuntime()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(runtime)
+	container1, err := runtime.Create(
+		&Config{
+			Image: GetTestImage(runtime).Id,
+			Cmd:   []string{"/bin/sh", "-c", "echo hello > /world"},
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container1)
+
+	if container1.State.Running {
+		t.Errorf("Container shouldn't be running")
+	}
+	if err := container1.Run(); err != nil {
+		t.Fatal(err)
+	}
+	if container1.State.Running {
+		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)
+	if err != nil {
+		t.Error(err)
+	}
+
+	// FIXME: Make a TestCommit that stops here and check docker.root/layers/img.id/world
+
+	container2, err := runtime.Create(
+		&Config{
+			Image: img.Id,
+			Cmd:   []string{"cat", "/world"},
 		},
 	)
 	if err != nil {
@@ -354,9 +421,8 @@ func TestRun(t *testing.T) {
 	defer nuke(runtime)
 	container, err := runtime.Create(
 		&Config{
-			Image:  GetTestImage(runtime).Id,
-			Memory: 33554432,
-			Cmd:    []string{"ls", "-al"},
+			Image: GetTestImage(runtime).Id,
+			Cmd:   []string{"ls", "-al"},
 		},
 	)
 	if err != nil {

contrib/crashTest.go

@@ -1,17 +1,22 @@
 package main
 
 import (
+	"fmt"
 	"io"
 	"log"
+	"net"
 	"os"
 	"os/exec"
+	"path"
 	"time"
 )
 
-const DOCKER_PATH = "/home/creack/dotcloud/docker/docker/docker"
+var DOCKER_PATH string = path.Join(os.Getenv("DOCKERPATH"), "docker")
 
+// WARNING: this crashTest will 1) crash your host, 2) remove all containers
 func runDaemon() (*exec.Cmd, error) {
 	os.Remove("/var/run/docker.pid")
+	exec.Command("rm", "-rf", "/var/lib/docker/containers").Run()
 	cmd := exec.Command(DOCKER_PATH, "-d")
 	outPipe, err := cmd.StdoutPipe()
 	if err != nil {
@@ -38,19 +43,43 @@ func crashTest() error {
 		return err
 	}
 
+	var endpoint string
+	if ep := os.Getenv("TEST_ENDPOINT"); ep == "" {
+		endpoint = "192.168.56.1:7979"
+	} else {
+		endpoint = ep
+	}
+
+	c := make(chan bool)
+	var conn io.Writer
+
+	go func() {
+		conn, _ = net.Dial("tcp", endpoint)
+		c <- false
+	}()
+	go func() {
+		time.Sleep(2 * time.Second)
+		c <- true
+	}()
+	<-c
+
+	restartCount := 0
+	totalTestCount := 1
 	for {
 		daemon, err := runDaemon()
 		if err != nil {
 			return err
 		}
+		restartCount++
 		//		time.Sleep(5000 * time.Millisecond)
 		var stop bool
 		go func() error {
 			stop = false
-			for i := 0; i < 100 && !stop; i++ {
+			for i := 0; i < 100 && !stop; {
 				func() error {
-					cmd := exec.Command(DOCKER_PATH, "run", "base", "echo", "hello", "world")
-					log.Printf("%d", i)
+					cmd := exec.Command(DOCKER_PATH, "run", "base", "echo", fmt.Sprintf("%d", totalTestCount))
+					i++
+					totalTestCount++
 					outPipe, err := cmd.StdoutPipe()
 					if err != nil {
 						return err
@@ -62,9 +91,10 @@ func crashTest() error {
 					if err := cmd.Start(); err != nil {
 						return err
 					}
-					go func() {
-						io.Copy(os.Stdout, outPipe)
-					}()
+					if conn != nil {
+						go io.Copy(conn, outPipe)
+					}
+
 					// Expecting error, do not check
 					inPipe.Write([]byte("hello world!!!!!\n"))
 					go inPipe.Write([]byte("hello world!!!!!\n"))

contrib/docker-build/docker-build

@@ -49,26 +49,36 @@ def docker(args, stdin=None):
 def image_exists(img):
 	return docker(["inspect", img]).read().strip() != ""
 
-def run_and_commit(img_in, cmd, stdin=None):
+def image_config(img):
+	return json.loads(docker(["inspect", img]).read()).get("config", {})
+
+def run_and_commit(img_in, cmd, stdin=None, author=None, run=None):
 	run_id = docker(["run"] + (["-i", "-a", "stdin"] if stdin else ["-d"]) + [img_in, "/bin/sh", "-c", cmd], stdin=stdin).read().rstrip()
 	print "---> Waiting for " + run_id
 	result=int(docker(["wait", run_id]).read().rstrip())
 	if result != 0:
 		print "!!! '{}' return non-zero exit code '{}'. Aborting.".format(cmd, result)
 		sys.exit(1)
-	return docker(["commit", run_id]).read().rstrip()
+	return docker(["commit"] + (["-author", author] if author else []) + (["-run", json.dumps(run)] if run is not None else []) + [run_id]).read().rstrip()
 
-def insert(base, src, dst):
+def insert(base, src, dst, author=None):
 	print "COPY {} to {} in {}".format(src, dst, base)
 	if dst == "":
 		raise Exception("Missing destination path")
 	stdin = file(src)
 	stdin.seek(0)
-	return run_and_commit(base, "cat > {0}; chmod +x {0}".format(dst), stdin=stdin)
-	
+	return run_and_commit(base, "cat > {0}; chmod +x {0}".format(dst), stdin=stdin, author=author)
+
+def push(base, dst, author=None):
+	print "PUSH to {} in {}".format(dst, base)
+	if dst == "":
+		raise Exception("Missing argument to push")
+	tar = subprocess.Popen(["tar", "-c", "."], stdout=subprocess.PIPE).stdout
+	return run_and_commit(base, "mkdir -p '{0}' && tar -C '{0}' -x".format(dst), stdin=tar, author=author)
 
 def main():
 	base=""
+	maintainer=""
 	steps = []
 	try:
 		for line in sys.stdin.readlines():
@@ -77,22 +87,46 @@ def main():
 			if line == "" or line[0] == "#":
 				continue
 			op, param = line.split("	", 1)
+			print op.upper() + " " + param
 			if op == "from":
-				print "FROM " + param
 				base = param
 				steps.append(base)
+			elif op == "maintainer":
+				maintainer = param
 			elif op == "run":
-				print "RUN " + param
-				result = run_and_commit(base, param)
+				result = run_and_commit(base, param, author=maintainer)
 				steps.append(result)
 				base = result
 				print "===> " + base
 			elif op == "copy":
 				src, dst = param.split("	", 1)
-				result = insert(base, src, dst)
+				result = insert(base, src, dst, author=maintainer)
 				steps.append(result)
 				base = result
 				print "===> " + base
+			elif op == "push":
+				result = push(base, param.strip(), author=maintainer)
+				steps.append(result)
+				base=result
+				print "===> " + base
+			elif op == "expose":
+				config = image_config(base)
+				if config.get("PortSpecs") is None:
+					config["PortSpecs"] = []
+				portspec = param.strip()
+				config["PortSpecs"].append(portspec)
+				result = run_and_commit(base, "# (nop) expose port {}".format(portspec), author=maintainer, run=config)
+				steps.append(result)
+				base=result
+				print "===> " + base
+			elif op == "cmd":
+				config  = image_config(base)
+				cmd = list(json.loads(param))
+				config["Cmd"] = cmd
+				result = run_and_commit(base, "# (nop) set default command to '{}'".format(" ".join(cmd)), author=maintainer, run=config)
+				steps.append(result)
+				base=result
+				print "===> " + base
 			else:
 				print "Skipping uknown op " + op
 	except:

contrib/docker-build/example.changefile

@@ -1,11 +1,13 @@
 # Start build from a know base image
+maintainer	Solomon Hykes <solomon@dotcloud.com>
 from	base:ubuntu-12.10
 # Update ubuntu sources
 run	echo 'deb http://archive.ubuntu.com/ubuntu quantal main universe multiverse' > /etc/apt/sources.list
 run	apt-get update
 # Install system packages
 run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q git
-run DEBIAN_FRONTEND=noninteractive apt-get install -y -q curl
-run DEBIAN_FRONTEND=noninteractive apt-get install -y -q golang
+run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q curl
+run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q golang
 # Insert files from the host (./myscript must be present in the current directory)
-copy	myscript /usr/local/bin/myscript
+copy	myscript	/usr/local/bin/myscript
+push	/src

contrib/docker-build/myscript

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+echo hello, world!

contrib/mkimage-debian.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+set -e
+
+# these should match the names found at http://www.debian.org/releases/
+stableSuite='squeeze'
+testingSuite='wheezy'
+unstableSuite='sid'
+
+# if suite is equal to this, it gets the "latest" tag
+latestSuite="$testingSuite"
+
+variant='minbase'
+include='iproute,iputils-ping'
+
+repo="$1"
+suite="${2:-$latestSuite}"
+mirror="${3:-}" # stick to the default debootstrap mirror if one is not provided
+
+if [ ! "$repo" ]; then
+	echo >&2 "usage: $0 repo [suite [mirror]]"
+	echo >&2 "   ie: $0 tianon/debian squeeze"
+	exit 1
+fi
+
+target="/tmp/docker-rootfs-debian-$suite-$$-$RANDOM"
+
+cd "$(dirname "$(readlink -f "$BASH_SOURCE")")"
+returnTo="$(pwd -P)"
+
+set -x
+
+# bootstrap
+mkdir -p "$target"
+sudo debootstrap --verbose --variant="$variant" --include="$include" "$suite" "$target" "$mirror"
+
+cd "$target"
+
+# create the image
+img=$(sudo tar -c . | docker import -)
+
+# tag suite
+docker tag $img $repo $suite
+
+if [ "$suite" = "$latestSuite" ]; then
+	# tag latest
+	docker tag $img $repo latest
+fi
+
+# test the image
+docker run -i -t $repo:$suite echo success
+
+# unstable's version numbers match testing (since it's mostly just a sandbox for testing), so it doesn't get a version number tag
+if [ "$suite" != "$unstableSuite" -a "$suite" != 'unstable' ]; then
+	# tag the specific version
+	ver=$(docker run $repo:$suite cat /etc/debian_version)
+	docker tag $img $repo $ver
+fi
+
+# cleanup
+cd "$returnTo"
+sudo rm -rf "$target"

docker/docker.go

@@ -28,6 +28,7 @@ func main() {
 	// FIXME: Switch d and D ? (to be more sshd like)
 	flDaemon := flag.Bool("d", false, "Daemon mode")
 	flDebug := flag.Bool("D", false, "Debug mode")
+	flAutoRestart := flag.Bool("r", false, "Restart previously running containers")
 	bridgeName := flag.String("b", "", "Attach containers to a pre-existing network bridge")
 	pidfile := flag.String("p", "/var/run/docker.pid", "File containing process PID")
 	flag.Parse()
@@ -45,7 +46,7 @@ func main() {
 			flag.Usage()
 			return
 		}
-		if err := daemon(*pidfile); err != nil {
+		if err := daemon(*pidfile, *flAutoRestart); err != nil {
 			log.Fatal(err)
 		}
 	} else {
@@ -82,7 +83,7 @@ func removePidFile(pidfile string) {
 	}
 }
 
-func daemon(pidfile string) error {
+func daemon(pidfile string, autoRestart bool) error {
 	if err := createPidFile(pidfile); err != nil {
 		log.Fatal(err)
 	}
@@ -97,7 +98,7 @@ func daemon(pidfile string) error {
 		os.Exit(0)
 	}()
 
-	service, err := docker.NewServer()
+	service, err := docker.NewServer(autoRestart)
 	if err != nil {
 		return err
 	}

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>tar -xf docker-master.tgz</pre>
+                            <pre>docker run -i -t ubuntu /bin/bash</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
-    may be out of date because it depends on some binaries to be updated and published
+  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.
+
 
 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.10 (quantal)
+- Ubuntu 12.04 (precise LTS) (64-bit)
+- 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
-    sudo apt-get install linux-image-extra-`uname -r`
+.. code-block:: bash
 
-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.
+   sudo apt-get install linux-image-extra-`uname -r`
 
 
-Run the docker daemon
----------------------
+Installation
+------------
 
-::
-
-    sudo docker -d &
-
-Run your first container!
--------------------------
-
-::
-    docker run -i -t ubuntu /bin/bash
+Docker is available as a Ubuntu PPA (Personal Package Archive),
+`hosted on launchpad  <https://launchpad.net/~dotcloud/+archive/lxc-docker>`_
+which makes installing Docker on Ubuntu very easy.
 
 
-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;

graph.go

@@ -84,18 +84,24 @@ func (graph *Graph) Get(name string) (*Image, error) {
 }
 
 // Create creates a new image and registers it in the graph.
-func (graph *Graph) Create(layerData Archive, container *Container, comment, author string) (*Image, error) {
+func (graph *Graph) Create(layerData Archive, container *Container, comment, author string, config *Config) (*Image, error) {
 	img := &Image{
 		Id:            GenerateId(),
 		Comment:       comment,
 		Created:       time.Now(),
 		DockerVersion: VERSION,
 		Author:        author,
+		Config:        config,
 	}
 	if container != nil {
 		img.Parent = container.Image
 		img.Container = container.Id
 		img.ContainerConfig = *container.Config
+		if config == nil {
+			if parentImage, err := graph.Get(container.Image); err == nil && parentImage != nil {
+				img.Config = parentImage.Config
+			}
+		}
 	}
 	if err := graph.Register(layerData, img); err != nil {
 		return nil, err

graph_test.go

@@ -62,7 +62,7 @@ func TestGraphCreate(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	image, err := graph.Create(archive, nil, "Testing", "")
+	image, err := graph.Create(archive, nil, "Testing", "", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -122,7 +122,7 @@ func TestMount(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	image, err := graph.Create(archive, nil, "Testing", "")
+	image, err := graph.Create(archive, nil, "Testing", "", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -166,7 +166,7 @@ func createTestImage(graph *Graph, t *testing.T) *Image {
 	if err != nil {
 		t.Fatal(err)
 	}
-	img, err := graph.Create(archive, nil, "Test image", "")
+	img, err := graph.Create(archive, nil, "Test image", "", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -181,7 +181,7 @@ func TestDelete(t *testing.T) {
 		t.Fatal(err)
 	}
 	assertNImages(graph, t, 0)
-	img, err := graph.Create(archive, nil, "Bla bla", "")
+	img, err := graph.Create(archive, nil, "Bla bla", "", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -192,11 +192,11 @@ func TestDelete(t *testing.T) {
 	assertNImages(graph, t, 0)
 
 	// Test 2 create (same name) / 1 delete
-	img1, err := graph.Create(archive, nil, "Testing", "")
+	img1, err := graph.Create(archive, nil, "Testing", "", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if _, err = graph.Create(archive, nil, "Testing", ""); err != nil {
+	if _, err = graph.Create(archive, nil, "Testing", "", nil); err != nil {
 		t.Fatal(err)
 	}
 	assertNImages(graph, t, 2)

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

image.go

@@ -24,6 +24,7 @@ type Image struct {
 	ContainerConfig Config    `json:"container_config,omitempty"`
 	DockerVersion   string    `json:"docker_version,omitempty"`
 	Author          string    `json:"author,omitempty"`
+	Config          *Config   `json:"config,omitempty"`
 	graph           *Graph
 }
 

packaging/ubuntu/changelog

@@ -1,30 +1,137 @@
+
+lxc-docker (0.2.1-1) precise; urgency=low
+
+  - 'docker commit -run' bundles a layer with default runtime options: command, ports etc. 
+  - Improve install process on Vagrant
+  - New Dockerfile operation: "maintainer"
+  - New Dockerfile operation: "expose"
+  - New Dockerfile operation: "cmd"
+  - Contrib script to build a Debian base layer
+  - 'docker -d -r': restart crashed containers at daemon startup
+  - Runtime: improve test coverage
+
+ -- dotCloud <ops@dotcloud.com>  Wed, 1 May 2013 00:00:00 -0700
+
+
+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 [-]:
-  + Multiple improvements, updates and bug fixes
+  - Record the author an image with 'docker commit -author'
 
- -- 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 [-]:
-  * Test PPA
+  - 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
 
- -- 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 [-]:
-  * Changed default bridge interface do 'docker0'
-  - Fix a race condition when running the port allocator
+  - 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'
 
- -- 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
-  to the PPA
+* Follow packaging/ubuntu/README.ubuntu to generate the actual source packages
+  and upload them to the PPA
+
 * Let vagrant do all the work for you::
 
   ( cd docker/packaging/ubuntu; vagrant up )

puppet/manifests/quantal64.pp

@@ -1,17 +0,0 @@
-node default {
-    exec {
-        "apt_update" : 
-            command => "/usr/bin/apt-get update"
-    }
-
-    Package {
-        require => Exec['apt_update']
-    }
-
-    group { "puppet":
-        ensure => "present"
-    }
-
-    include "docker"
-
-}

puppet/modules/docker/manifests/init.pp

@@ -1,99 +0,0 @@
-class virtualbox {
-    Package { ensure => "installed" }
-
-    # remove some files from the base vagrant image because they're old
-    file { "/home/vagrant/docker-master":
-        ensure => absent,
-        recurse => true,
-        force => true,
-        purge => true,
-    }
-    file { "/usr/local/bin/dockerd":
-        ensure => absent,
-    }
-    file { "/usr/local/bin/docker":
-        ensure => absent,
-    }
-
-    # Set up VirtualBox guest utils
-    package { "virtualbox-guest-utils": }
-    exec { "vbox-add" :
-        command => "/etc/init.d/vboxadd setup",
-        require => [
-            Package["virtualbox-guest-utils"],
-            Package["linux-headers-3.5.0-25-generic"], ],
-    }
-}
-
-class docker {
-    # update this with latest go binary dist
-    $go_url = "http://go.googlecode.com/files/go1.0.3.linux-amd64.tar.gz"
-
-    Package { ensure => "installed" }
-
-    package { ["lxc", "debootstrap", "wget", "bsdtar", "git",
-               "linux-image-3.5.0-25-generic",
-               "linux-image-extra-3.5.0-25-generic",
-               "linux-headers-3.5.0-25-generic"]: }
-
-    $ec2_version = file("/etc/ec2_version", "/dev/null")
-    $rax_version = inline_template("<%= %x{/usr/bin/xenstore-read vm-data/provider_data/provider} %>")
-
-    if ($ec2_version) {
-        $vagrant_user = "ubuntu"
-        $vagrant_home = "/home/ubuntu"
-    } elsif ($rax_version) {
-        $vagrant_user = "root"
-        $vagrant_home = "/root"
-    } else {
-        # virtualbox is the vagrant default, so it should be safe to assume
-        $vagrant_user = "vagrant"
-        $vagrant_home = "/home/vagrant"
-        include virtualbox
-    }
-
-    exec { "fetch-go":
-        require => Package["wget"],
-        command => "/usr/bin/wget -O - $go_url | /bin/tar xz -C /usr/local",
-        creates => "/usr/local/go/bin/go",
-    }
-
-    file { "/etc/init/dockerd.conf":
-        mode => 600,
-        owner => "root",
-        group => "root",
-        content => template("docker/dockerd.conf"),
-    }
-
-    file { "/opt/go":
-        owner => $vagrant_user,
-        group => $vagrant_user,
-        recurse => true,
-    }
-
-    file { "${vagrant_home}/.profile":
-        mode => 644,
-        owner => $vagrant_user,
-        group => $vagrant_user,
-        content => template("docker/profile"),
-    }
-
-     exec { "build-docker" :
-        cwd  => "/opt/go/src/github.com/dotcloud/docker",
-        user => $vagrant_user,
-        environment => "GOPATH=/opt/go",
-        command => "/usr/local/go/bin/go get -v ./... && /usr/local/go/bin/go install ./docker",
-        creates => "/opt/go/bin/docker",
-        logoutput => "on_failure",
-        require => [ Exec["fetch-go"], File["/opt/go"] ],
-    }
-
-    service { "dockerd" :
-        ensure => "running",
-        start => "/sbin/initctl start dockerd",
-        stop => "/sbin/initctl stop dockerd",
-        require => [ Exec["build-docker"], File["/etc/init/dockerd.conf"] ],
-        name => "dockerd",
-        provider => "base"
-    }
-}

puppet/modules/docker/templates/dockerd.conf

@@ -1,12 +0,0 @@
-description     "Run dockerd"
-
-stop on runlevel [!2345]
-start on runlevel [3]
-
-# if you want it to automatically restart if it crashes, leave the next line in
-respawn
-
-script
-    test -f /etc/default/locale && . /etc/default/locale || true
-    LANG=$LANG LC_ALL=$LANG /opt/go/bin/docker -d >> /var/log/dockerd 2>&1
-end script

puppet/modules/docker/templates/profile

@@ -1,30 +0,0 @@
-# ~/.profile: executed by the command interpreter for login shells.
-# This file is not read by bash(1), if ~/.bash_profile or ~/.bash_login
-# exists.
-# see /usr/share/doc/bash/examples/startup-files for examples.
-# the files are located in the bash-doc package.
-
-# the default umask is set in /etc/profile; for setting the umask
-# for ssh logins, install and configure the libpam-umask package.
-#umask 022
-
-# if running bash
-if [ -n "$BASH_VERSION" ]; then
-    # include .bashrc if it exists
-    if [ -f "$HOME/.bashrc" ]; then
-        . "$HOME/.bashrc"
-    fi
-fi
-
-# set PATH so it includes user's private bin if it exists
-if [ -d "$HOME/bin" ] ; then
-    PATH="$HOME/bin:$PATH"
-fi
-
-export GOPATH=/opt/go
-export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
-
-docker=/opt/go/src/github.com/dotcloud/docker
-if [ -d $docker ]; then
-  cd $docker
-fi

runtime.go

@@ -31,6 +31,7 @@ type Runtime struct {
 	idIndex        *TruncIndex
 	capabilities   *Capabilities
 	kernelVersion  *KernelVersionInfo
+	autoRestart    bool
 }
 
 var sysInitPath string
@@ -77,12 +78,58 @@ func (runtime *Runtime) containerRoot(id string) string {
 	return path.Join(runtime.repository, id)
 }
 
+func (runtime *Runtime) mergeConfig(userConf, imageConf *Config) {
+	if userConf.Hostname != "" {
+		userConf.Hostname = imageConf.Hostname
+	}
+	if userConf.User != "" {
+		userConf.User = imageConf.User
+	}
+	if userConf.Memory == 0 {
+		userConf.Memory = imageConf.Memory
+	}
+	if userConf.MemorySwap == 0 {
+		userConf.MemorySwap = imageConf.MemorySwap
+	}
+	if userConf.PortSpecs == nil || len(userConf.PortSpecs) == 0 {
+		userConf.PortSpecs = imageConf.PortSpecs
+	}
+	if !userConf.Tty {
+		userConf.Tty = userConf.Tty
+	}
+	if !userConf.OpenStdin {
+		userConf.OpenStdin = imageConf.OpenStdin
+	}
+	if !userConf.StdinOnce {
+		userConf.StdinOnce = imageConf.StdinOnce
+	}
+	if userConf.Env == nil || len(userConf.Env) == 0 {
+		userConf.Env = imageConf.Env
+	}
+	if userConf.Cmd == nil || len(userConf.Cmd) == 0 {
+		userConf.Cmd = imageConf.Cmd
+	}
+	if userConf.Dns == nil || len(userConf.Dns) == 0 {
+		userConf.Dns = imageConf.Dns
+	}
+}
+
 func (runtime *Runtime) Create(config *Config) (*Container, error) {
+
 	// Lookup image
 	img, err := runtime.repositories.LookupImage(config.Image)
 	if err != nil {
 		return nil, err
 	}
+
+	if img.Config != nil {
+		runtime.mergeConfig(config, img.Config)
+	}
+
+	if config.Cmd == nil {
+		return nil, fmt.Errorf("No command specified")
+	}
+
 	// Generate id
 	id := GenerateId()
 	// Generate default hostname
@@ -103,6 +150,7 @@ func (runtime *Runtime) Create(config *Config) (*Container, error) {
 		// FIXME: do we need to store this in the container?
 		SysInitPath: sysInitPath,
 	}
+
 	container.root = runtime.containerRoot(container.Id)
 	// Step 1: create the container directory.
 	// This doubles as a barrier to avoid race conditions.
@@ -167,29 +215,6 @@ func (runtime *Runtime) Register(container *Container) error {
 	// init the wait lock
 	container.waitLock = make(chan struct{})
 
-	// 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 output, err := exec.Command("lxc-info", "-n", container.Id).CombinedOutput(); err != nil {
-			return err
-		} else {
-			if !strings.Contains(string(output), "RUNNING") {
-				Debugf("Container %s was supposed to be running be is not.", container.Id)
-				container.State.setStopped(-127)
-				if err := container.ToDisk(); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	// 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 +232,47 @@ func (runtime *Runtime) Register(container *Container) error {
 	// done
 	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
+	if container.State.Running {
+		if output, err := exec.Command("lxc-info", "-n", container.Id).CombinedOutput(); err != nil {
+			return err
+		} else {
+			if !strings.Contains(string(output), "RUNNING") {
+				Debugf("Container %s was supposed to be running be is not.", container.Id)
+				if runtime.autoRestart {
+					Debugf("Restarting")
+					container.State.Ghost = false
+					container.State.setStopped(0)
+					if err := container.Start(); err != nil {
+						return err
+					}
+					nomonitor = true
+				} else {
+					Debugf("Marking as stopped")
+					container.State.setStopped(-127)
+					if err := container.ToDisk(); err != nil {
+						return err
+					}
+				}
+			}
+		}
+	}
+
+	// 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()
+	}
 	return nil
 }
 
@@ -246,7 +312,7 @@ func (runtime *Runtime) Destroy(container *Container) error {
 
 // Commit creates a new filesystem image from the current state of a container.
 // The image can optionally be tagged into a repository
-func (runtime *Runtime) Commit(id, repository, tag, comment, author string) (*Image, error) {
+func (runtime *Runtime) Commit(id, repository, tag, comment, author string, config *Config) (*Image, error) {
 	container := runtime.Get(id)
 	if container == nil {
 		return nil, fmt.Errorf("No such container: %s", id)
@@ -258,7 +324,7 @@ func (runtime *Runtime) Commit(id, repository, tag, comment, author string) (*Im
 		return nil, err
 	}
 	// Create a new image from the container's base layers + a new layer from container changes
-	img, err := runtime.graph.Create(rwTar, container, comment, author)
+	img, err := runtime.graph.Create(rwTar, container, comment, author, config)
 	if err != nil {
 		return nil, err
 	}
@@ -289,8 +355,8 @@ func (runtime *Runtime) restore() error {
 }
 
 // FIXME: harmonize with NewGraph()
-func NewRuntime() (*Runtime, error) {
-	runtime, err := NewRuntimeFromDirectory("/var/lib/docker")
+func NewRuntime(autoRestart bool) (*Runtime, error) {
+	runtime, err := NewRuntimeFromDirectory("/var/lib/docker", autoRestart)
 	if err != nil {
 		return nil, err
 	}
@@ -311,19 +377,19 @@ func NewRuntime() (*Runtime, error) {
 		_, err2 := ioutil.ReadFile(path.Join(cgroupMemoryMountpoint, "memory.soft_limit_in_bytes"))
 		runtime.capabilities.MemoryLimit = err1 == nil && err2 == nil
 		if !runtime.capabilities.MemoryLimit {
-		   	log.Printf("WARNING: Your kernel does not support cgroup memory limit.")
+			log.Printf("WARNING: Your kernel does not support cgroup memory limit.")
 		}
 
 		_, err = ioutil.ReadFile(path.Join(cgroupMemoryMountpoint, "memory.memsw.limit_in_bytes"))
 		runtime.capabilities.SwapLimit = err == nil
 		if !runtime.capabilities.SwapLimit {
-		   	log.Printf("WARNING: Your kernel does not support cgroup swap limit.")
+			log.Printf("WARNING: Your kernel does not support cgroup swap limit.")
 		}
 	}
 	return runtime, nil
 }
 
-func NewRuntimeFromDirectory(root string) (*Runtime, error) {
+func NewRuntimeFromDirectory(root string, autoRestart bool) (*Runtime, error) {
 	runtimeRepo := path.Join(root, "containers")
 
 	if err := os.MkdirAll(runtimeRepo, 0700); err != nil && !os.IsExist(err) {
@@ -360,6 +426,7 @@ func NewRuntimeFromDirectory(root string) (*Runtime, error) {
 		authConfig:     authConfig,
 		idIndex:        NewTruncIndex(),
 		capabilities:   &Capabilities{},
+		autoRestart:    autoRestart,
 	}
 
 	if err := runtime.restore(); err != nil {

runtime_test.go

@@ -60,8 +60,10 @@ func init() {
 		panic("docker tests needs to be run as root")
 	}
 
+	NetworkBridgeIface = "testdockbr0"
+
 	// Make it our Store root
-	runtime, err := NewRuntimeFromDirectory(unitTestStoreBase)
+	runtime, err := NewRuntimeFromDirectory(unitTestStoreBase, false)
 	if err != nil {
 		panic(err)
 	}
@@ -87,7 +89,7 @@ func newTestRuntime() (*Runtime, error) {
 		return nil, err
 	}
 
-	runtime, err := NewRuntimeFromDirectory(root)
+	runtime, err := NewRuntimeFromDirectory(root, false)
 	if err != nil {
 		return nil, err
 	}
@@ -273,7 +275,16 @@ func TestAllocatePortLocalhost(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer container.Kill()
-	time.Sleep(300 * time.Millisecond) // Wait for the container to run
+
+	setTimeout(t, "Waiting for the container to be started timed out", 2*time.Second, func() {
+		for {
+			if container.State.Running {
+				break
+			}
+			time.Sleep(10 * time.Millisecond)
+		}
+	})
+
 	conn, err := net.Dial("tcp",
 		fmt.Sprintf(
 			"localhost:%s", container.NetworkSettings.PortMapping["5555"],
@@ -293,6 +304,7 @@ func TestAllocatePortLocalhost(t *testing.T) {
 			string(output),
 		)
 	}
+	container.Wait()
 }
 
 func TestRestore(t *testing.T) {
@@ -308,7 +320,7 @@ func TestRestore(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	runtime1, err := NewRuntimeFromDirectory(root)
+	runtime1, err := NewRuntimeFromDirectory(root, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -367,7 +379,7 @@ func TestRestore(t *testing.T) {
 
 	// Here are are simulating a docker restart - that is, reloading all containers
 	// from scratch
-	runtime2, err := NewRuntimeFromDirectory(root)
+	runtime2, err := NewRuntimeFromDirectory(root, false)
 	if err != nil {
 		t.Fatal(err)
 	}

utils.go

@@ -12,7 +12,6 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"regexp"
 	"runtime"
 	"strings"
 	"sync"
@@ -437,17 +436,23 @@ func CompareKernelVersion(a, b *KernelVersionInfo) int {
 }
 
 func FindCgroupMountpoint(cgroupType string) (string, error) {
-	output, err := exec.Command("mount").CombinedOutput()
+	output, err := ioutil.ReadFile("/proc/mounts")
 	if err != nil {
 		return "", err
 	}
 
-	reg := regexp.MustCompile(`^cgroup on (.*) type cgroup \(.*` + cgroupType + `[,\)]`)
+	// /proc/mounts has 6 fields per line, one mount per line, e.g.
+	// cgroup /sys/fs/cgroup/devices cgroup rw,relatime,devices 0 0
 	for _, line := range strings.Split(string(output), "\n") {
-		r := reg.FindStringSubmatch(line)
-		if len(r) == 2 {
-			return r[1], nil
+		parts := strings.Split(line, " ")
+		if parts[2] == "cgroup" {
+			for _, opt := range strings.Split(parts[3], ",") {
+				if opt == cgroupType {
+					return parts[1], nil
+				}
+			}
 		}
 	}
+
 	return "", fmt.Errorf("cgroup mountpoint not found for %s", cgroupType)
 }