Better varibale names

use new image as base of next command

Vagrantfile

@@ -1,27 +1,55 @@
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-BOX_NAME = "ubuntu"
-BOX_URI = "http://files.vagrantup.com/precise64.box"
-PPA_KEY = "E61D797F63561DC6"
+def v10(config)
+  config.vm.box = 'precise64'
+  config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
 
-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 keyserver.ubuntu.com --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
+  # 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"
+  config.vm.provision :shell, :inline => 'export DEBIAN_FRONTEND=noninteractive; apt-get -qq update; apt-get install -qq -y --force-yes lxc-docker'
+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.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"]
+    aws.region = "us-east-1"
+    aws.ami = "ami-d0f89fb9"
+    aws.ssh_username = "ubuntu"
+    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
+
+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"
@@ -47,7 +75,8 @@ Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
   end
 
   config.vm.provider :virtualbox do |vb|
-    config.vm.box = BOX_NAME
-    config.vm.box_url = BOX_URI
+    config.vm.box = 'precise64'
+    config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
   end
+
 end

builder.go

@@ -0,0 +1,263 @@
+package docker
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"strings"
+	"time"
+)
+
+type Builder struct {
+	runtime      *Runtime
+	repositories *TagStore
+	graph        *Graph
+}
+
+func NewBuilder(runtime *Runtime) *Builder {
+	return &Builder{
+		runtime:      runtime,
+		graph:        runtime.graph,
+		repositories: runtime.repositories,
+	}
+}
+
+func (builder *Builder) Create(config *Config) (*Container, error) {
+	// Lookup image
+	img, err := builder.repositories.LookupImage(config.Image)
+	if err != nil {
+		return nil, err
+	}
+	// Generate id
+	id := GenerateId()
+	// Generate default hostname
+	// FIXME: the lxc template no longer needs to set a default hostname
+	if config.Hostname == "" {
+		config.Hostname = id[:12]
+	}
+
+	container := &Container{
+		// FIXME: we should generate the ID here instead of receiving it as an argument
+		Id:              id,
+		Created:         time.Now(),
+		Path:            config.Cmd[0],
+		Args:            config.Cmd[1:], //FIXME: de-duplicate from config
+		Config:          config,
+		Image:           img.Id, // Always use the resolved image id
+		NetworkSettings: &NetworkSettings{},
+		// FIXME: do we need to store this in the container?
+		SysInitPath: sysInitPath,
+	}
+	container.root = builder.runtime.containerRoot(container.Id)
+	// Step 1: create the container directory.
+	// This doubles as a barrier to avoid race conditions.
+	if err := os.Mkdir(container.root, 0700); err != nil {
+		return nil, err
+	}
+
+	// If custom dns exists, then create a resolv.conf for the container
+	if len(config.Dns) > 0 {
+		container.ResolvConfPath = path.Join(container.root, "resolv.conf")
+		f, err := os.Create(container.ResolvConfPath)
+		if err != nil {
+			return nil, err
+		}
+		defer f.Close()
+		for _, dns := range config.Dns {
+			if _, err := f.Write([]byte("nameserver " + dns + "\n")); err != nil {
+				return nil, err
+			}
+		}
+	} else {
+		container.ResolvConfPath = "/etc/resolv.conf"
+	}
+
+	// Step 2: save the container json
+	if err := container.ToDisk(); err != nil {
+		return nil, err
+	}
+	// Step 3: register the container
+	if err := builder.runtime.Register(container); err != nil {
+		return nil, err
+	}
+	return container, nil
+}
+
+// Commit creates a new filesystem image from the current state of a container.
+// The image can optionally be tagged into a repository
+func (builder *Builder) Commit(container *Container, repository, tag, comment, author string) (*Image, error) {
+	// FIXME: freeze the container before copying it to avoid data corruption?
+	// FIXME: this shouldn't be in commands.
+	rwTar, err := container.ExportRw()
+	if err != nil {
+		return nil, err
+	}
+	// Create a new image from the container's base layers + a new layer from container changes
+	img, err := builder.graph.Create(rwTar, container, comment, author)
+	if err != nil {
+		return nil, err
+	}
+	// Register the image if needed
+	if repository != "" {
+		if err := builder.repositories.Set(repository, tag, img.Id, true); err != nil {
+			return img, err
+		}
+	}
+	return img, nil
+}
+
+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) (*Image, 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 nil, 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 nil, fmt.Errorf("Invalid Dockerfile format")
+		}
+		instruction := tmp[0]
+		arguments := tmp[1]
+		switch strings.ToLower(instruction) {
+		case "from":
+			fmt.Fprintf(stdout, "FROM %s\n", arguments)
+			image, err = builder.runtime.repositories.LookupImage(arguments)
+			if err != nil {
+				return nil, err
+			}
+			break
+		case "run":
+			fmt.Fprintf(stdout, "RUN %s\n", arguments)
+			if image == nil {
+				return nil, fmt.Errorf("Please provide a source image with `from` prior to run")
+			}
+			config, err := ParseRun([]string{image.Id, "/bin/sh", "-c", arguments}, nil, builder.runtime.capabilities)
+			if err != nil {
+				return nil, err
+			}
+
+			// Create the container and start it
+			c, err := builder.Create(config)
+			if err != nil {
+				return nil, err
+			}
+			if err := c.Start(); err != nil {
+				return nil, err
+			}
+			tmpContainers[c.Id] = struct{}{}
+
+			// Wait for it to finish
+			if result := c.Wait(); result != 0 {
+				return nil, fmt.Errorf("!!! '%s' return non-zero exit code '%d'. Aborting.", arguments, result)
+			}
+
+			// Commit the container
+			base, err = builder.Commit(c, "", "", "", "")
+			if err != nil {
+				return nil, err
+			}
+			tmpImages[base.Id] = struct{}{}
+
+			fmt.Fprintf(stdout, "===> %s\n", base.ShortId())
+
+			// use the base as the new image
+			image = base
+
+			break
+		case "insert":
+			if image == nil {
+				return nil, fmt.Errorf("Please provide a source image with `from` prior to copy")
+			}
+			tmp = strings.SplitN(arguments, " ", 2)
+			if len(tmp) != 2 {
+				return nil, fmt.Errorf("Invalid INSERT format")
+			}
+			sourceUrl := tmp[0]
+			destPath := tmp[1]
+			fmt.Fprintf(stdout, "COPY %s to %s in %s\n", sourceUrl, destPath, base.ShortId())
+
+			file, err := Download(sourceUrl, stdout)
+			if err != nil {
+				return nil, err
+			}
+			defer file.Body.Close()
+
+			config, err := ParseRun([]string{base.Id, "echo", "insert", sourceUrl, destPath}, nil, builder.runtime.capabilities)
+			if err != nil {
+				return nil, err
+			}
+			c, err := builder.Create(config)
+			if err != nil {
+				return nil, err
+			}
+
+			if err := c.Start(); err != nil {
+				return nil, err
+			}
+
+			// Wait for echo to finish
+			if result := c.Wait(); result != 0 {
+				return nil, fmt.Errorf("!!! '%s' return non-zero exit code '%d'. Aborting.", arguments, result)
+			}
+
+			if err := c.Inject(file.Body, destPath); err != nil {
+				return nil, err
+			}
+
+			base, err = builder.Commit(c, "", "", "", "")
+			if err != nil {
+				return nil, err
+			}
+			fmt.Fprintf(stdout, "===> %s\n", base.ShortId())
+
+			image = base
+
+			break
+		default:
+			fmt.Fprintf(stdout, "Skipping unknown instruction %s\n", instruction)
+		}
+	}
+	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 base, nil
+}

builder_test.go

@@ -0,0 +1,88 @@
+package docker
+
+import (
+	"strings"
+	"testing"
+)
+
+const Dockerfile = `
+# VERSION		0.1
+# DOCKER-VERSION	0.1.6
+
+from	docker-ut
+run	sh -c 'echo root:testpass > /tmp/passwd'
+run	mkdir -p /var/run/sshd
+copy	https://raw.github.com/dotcloud/docker/master/CHANGELOG.md /tmp/CHANGELOG.md
+`
+
+func TestBuild(t *testing.T) {
+	runtime, err := newTestRuntime()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(runtime)
+
+	builder := NewBuilder(runtime)
+
+	img, err := builder.Build(strings.NewReader(Dockerfile), &nopWriter{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	container, err := builder.Create(
+		&Config{
+			Image: img.Id,
+			Cmd:   []string{"cat", "/tmp/passwd"},
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container)
+
+	output, err := container.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(output) != "root:testpass\n" {
+		t.Fatalf("Unexpected output. Read '%s', expected '%s'", output, "root:testpass\n")
+	}
+
+	container2, err := builder.Create(
+		&Config{
+			Image: img.Id,
+			Cmd:   []string{"ls", "-d", "/var/run/sshd"},
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container2)
+
+	output, err = container2.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(output) != "/var/run/sshd\n" {
+		t.Fatal("/var/run/sshd has not been created")
+	}
+
+	container3, err := builder.Create(
+		&Config{
+			Image: img.Id,
+			Cmd:   []string{"cat", "/tmp/CHANGELOG.md"},
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container3)
+
+	output, err = container3.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(output) == 0 {
+		t.Fatal("/tmp/CHANGELOG.md has not been copied")
+	}
+}

commands.go

@@ -33,6 +33,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 via stdin"},
 		{"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 +41,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 +65,67 @@ 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()
+
+	config, err := ParseRun([]string{img.Id, "echo", "insert", url, path}, nil, srv.runtime.capabilities)
+	if err != nil {
+		return err
+	}
+
+	b := NewBuilder(srv.runtime)
+	c, err := b.Create(config)
+	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", "-", "Build a container from Dockerfile via stdin")
+	if err := cmd.Parse(args); err != nil {
+		return nil
+	}
+	img, err := NewBuilder(srv.runtime).Build(stdin, stdout)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(stdout, "%s\n", img.ShortId())
+	return nil
+}
+
 // '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
@@ -477,7 +540,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, "", nil)
+	img, err := srv.runtime.graph.Create(archive, nil, "Imported from "+src, "")
 	if err != nil {
 		return err
 	}
@@ -726,8 +789,6 @@ 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("config", "", "Config automatically applied when the image is run. This option must be the last one.")
-	flCommand := cmd.String("command", "", "Command to run when starting the image")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -737,21 +798,12 @@ func (srv *Server) CmdCommit(stdin io.ReadCloser, stdout io.Writer, args ...stri
 		return nil
 	}
 
-	var config []string
-	if *flConfig != "" {
-		config = strings.Split(*flConfig, " ")
-	}
-	if *flCommand != "" {
-		config = append(config, "", "/bin/sh", "-c", *flCommand)
-	} else if *flConfig != "" {
-		config = append(config, "", "")
-	}
-	c, err := ParseRun(config, stdout, srv.runtime.capabilities)
-	if err != nil {
-		return err
+	container := srv.runtime.Get(containerName)
+	if container == nil {
+		return fmt.Errorf("No such container: %s", containerName)
 	}
 
-	img, err := srv.runtime.Commit(containerName, repository, tag, *flComment, *flAuthor, c)
+	img, err := NewBuilder(srv.runtime).Commit(container, repository, tag, *flComment, *flAuthor)
 	if err != nil {
 		return err
 	}
@@ -942,6 +994,10 @@ 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()
@@ -950,8 +1006,10 @@ func (srv *Server) CmdRun(stdin io.ReadCloser, stdout rcli.DockerConn, args ...s
 	// or tell the client there is no options
 	stdout.Flush()
 
+	b := NewBuilder(srv.runtime)
+
 	// Create new container
-	container, err := srv.runtime.Create(config)
+	container, err := b.Create(config)
 	if err != nil {
 		// If container not found, try to pull it
 		if srv.runtime.graph.IsNotExist(err) {
@@ -959,7 +1017,7 @@ func (srv *Server) CmdRun(stdin io.ReadCloser, stdout rcli.DockerConn, args ...s
 			if err = srv.CmdPull(stdin, stdout, config.Image); err != nil {
 				return err
 			}
-			if container, err = srv.runtime.Create(config); err != nil {
+			if container, err = b.Create(config); err != nil {
 				return err
 			}
 		} else {

commands_test.go

@@ -339,7 +339,7 @@ func TestAttachDisconnect(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	container, err := runtime.Create(
+	container, err := NewBuilder(runtime).Create(
 		&Config{
 			Image:     GetTestImage(runtime).Id,
 			Memory:    33554432,

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
 }

container_test.go

@@ -20,7 +20,7 @@ func TestIdFormat(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container1, err := runtime.Create(
+	container1, err := NewBuilder(runtime).Create(
 		&Config{
 			Image:  GetTestImage(runtime).Id,
 			Cmd:    []string{"/bin/sh", "-c", "echo hello world"},
@@ -45,7 +45,7 @@ func TestMultipleAttachRestart(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(
+	container, err := NewBuilder(runtime).Create(
 		&Config{
 			Image: GetTestImage(runtime).Id,
 			Cmd: []string{"/bin/sh", "-c",
@@ -157,8 +157,10 @@ func TestDiff(t *testing.T) {
 	}
 	defer nuke(runtime)
 
+	builder := NewBuilder(runtime)
+
 	// Create a container and remove a file
-	container1, err := runtime.Create(
+	container1, err := builder.Create(
 		&Config{
 			Image: GetTestImage(runtime).Id,
 			Cmd:   []string{"/bin/rm", "/etc/passwd"},
@@ -193,13 +195,13 @@ func TestDiff(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image - diff", "", nil)
+	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image - diff", "")
 	if err != nil {
 		t.Error(err)
 	}
 
 	// Create a new container from the commited image
-	container2, err := runtime.Create(
+	container2, err := builder.Create(
 		&Config{
 			Image: img.Id,
 			Cmd:   []string{"cat", "/etc/passwd"},
@@ -226,91 +228,16 @@ func TestDiff(t *testing.T) {
 	}
 }
 
-func TestCommitAutoRun(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", "", &Config{Cmd: []string{"cat", "/world"}})
-	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,
-		},
-	)
-	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(
+
+	builder := NewBuilder(runtime)
+
+	container1, err := builder.Create(
 		&Config{
 			Image:  GetTestImage(runtime).Id,
 			Cmd:    []string{"/bin/sh", "-c", "echo hello > /world"},
@@ -336,14 +263,14 @@ func TestCommitRun(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image", "", nil)
+	img, err := runtime.graph.Create(rwTar, container1, "unit test commited image", "")
 	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(
+	container2, err := builder.Create(
 		&Config{
 			Image:  img.Id,
 			Memory: 33554432,
@@ -391,7 +318,7 @@ func TestStart(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(
+	container, err := NewBuilder(runtime).Create(
 		&Config{
 			Image:     GetTestImage(runtime).Id,
 			Memory:    33554432,
@@ -430,7 +357,7 @@ func TestRun(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(
+	container, err := NewBuilder(runtime).Create(
 		&Config{
 			Image:  GetTestImage(runtime).Id,
 			Memory: 33554432,
@@ -459,7 +386,7 @@ func TestOutput(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(
+	container, err := NewBuilder(runtime).Create(
 		&Config{
 			Image: GetTestImage(runtime).Id,
 			Cmd:   []string{"echo", "-n", "foobar"},
@@ -484,7 +411,7 @@ func TestKillDifferentUser(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"tail", "-f", "/etc/resolv.conf"},
 		User:  "daemon",
@@ -532,7 +459,7 @@ func TestKill(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"cat", "/dev/zero"},
 	},
@@ -578,7 +505,9 @@ func TestExitCode(t *testing.T) {
 	}
 	defer nuke(runtime)
 
-	trueContainer, err := runtime.Create(&Config{
+	builder := NewBuilder(runtime)
+
+	trueContainer, err := builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"/bin/true", ""},
 	})
@@ -593,7 +522,7 @@ func TestExitCode(t *testing.T) {
 		t.Errorf("Unexpected exit code %d (expected 0)", trueContainer.State.ExitCode)
 	}
 
-	falseContainer, err := runtime.Create(&Config{
+	falseContainer, err := builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"/bin/false", ""},
 	})
@@ -615,7 +544,7 @@ func TestRestart(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"echo", "-n", "foobar"},
 	},
@@ -648,7 +577,7 @@ func TestRestartStdin(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"cat"},
 
@@ -727,8 +656,10 @@ func TestUser(t *testing.T) {
 	}
 	defer nuke(runtime)
 
+	builder := NewBuilder(runtime)
+
 	// Default user must be root
-	container, err := runtime.Create(&Config{
+	container, err := builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"id"},
 	},
@@ -746,7 +677,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a username
-	container, err = runtime.Create(&Config{
+	container, err = builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"id"},
 
@@ -766,7 +697,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a UID
-	container, err = runtime.Create(&Config{
+	container, err = builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"id"},
 
@@ -786,7 +717,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a different user by uid
-	container, err = runtime.Create(&Config{
+	container, err = builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"id"},
 
@@ -808,7 +739,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a different user by username
-	container, err = runtime.Create(&Config{
+	container, err = builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"id"},
 
@@ -835,7 +766,9 @@ func TestMultipleContainers(t *testing.T) {
 	}
 	defer nuke(runtime)
 
-	container1, err := runtime.Create(&Config{
+	builder := NewBuilder(runtime)
+
+	container1, err := builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"cat", "/dev/zero"},
 	},
@@ -845,7 +778,7 @@ func TestMultipleContainers(t *testing.T) {
 	}
 	defer runtime.Destroy(container1)
 
-	container2, err := runtime.Create(&Config{
+	container2, err := builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"cat", "/dev/zero"},
 	},
@@ -891,7 +824,7 @@ func TestStdin(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"cat"},
 
@@ -938,7 +871,7 @@ func TestTty(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"cat"},
 
@@ -985,7 +918,7 @@ func TestEnv(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"/usr/bin/env"},
 	},
@@ -1059,7 +992,7 @@ func TestLXCConfig(t *testing.T) {
 	memMin := 33554432
 	memMax := 536870912
 	mem := memMin + rand.Intn(memMax-memMin)
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"/bin/true"},
 
@@ -1086,7 +1019,7 @@ func BenchmarkRunSequencial(b *testing.B) {
 	}
 	defer nuke(runtime)
 	for i := 0; i < b.N; i++ {
-		container, err := runtime.Create(&Config{
+		container, err := NewBuilder(runtime).Create(&Config{
 			Image: GetTestImage(runtime).Id,
 			Cmd:   []string{"echo", "-n", "foo"},
 		},
@@ -1121,7 +1054,7 @@ func BenchmarkRunParallel(b *testing.B) {
 		complete := make(chan error)
 		tasks = append(tasks, complete)
 		go func(i int, complete chan error) {
-			container, err := runtime.Create(&Config{
+			container, err := NewBuilder(runtime).Create(&Config{
 				Image: GetTestImage(runtime).Id,
 				Cmd:   []string{"echo", "-n", "foo"},
 			},

docs/sources/builder/basics.rst

@@ -0,0 +1,91 @@
+==============
+Docker Builder
+==============
+
+.. contents:: Table of Contents
+
+1. Format
+=========
+
+The Docker builder format is quite simple:
+
+    ``instruction arguments``
+
+The first instruction must be `FROM`
+
+All instruction are to be placed in a file named `Dockerfile`
+
+In order to place comments within a Dockerfile, simply prefix the line with "`#`"
+
+2. Instructions
+===============
+
+Docker builder comes with a set of instructions:
+
+1. FROM: Set from what image to build
+2. RUN: Execute a command
+3. INSERT: Insert a remote file (http) into the image
+
+2.1 FROM
+--------
+    ``FROM <image>``
+
+The `FROM` instruction must be the first one in order for Builder to know from where to run commands.
+
+`FROM` can also be used in order to build multiple images within a single Dockerfile
+
+2.2 RUN
+-------
+    ``RUN <command>``
+
+The `RUN` instruction is the main one, it allows you to execute any commands on the `FROM` image and to save the results.
+You can use as many `RUN` as you want within a Dockerfile, the commands will be executed on the result of the previous command.
+
+2.3 INSERT
+----------
+
+    ``INSERT <file url> <path>``
+
+The `INSERT` instruction will download the file at the given url and place it within the image at the given path.
+
+.. note::
+    The path must include the file name.
+
+3. Dockerfile Examples
+======================
+
+::
+
+    # Nginx
+    #
+    # VERSION               0.0.1
+    # DOCKER-VERSION        0.2
+    
+    from ubuntu
+
+    # make sure the package repository is up to date
+    run echo "deb http://archive.ubuntu.com/ubuntu precise main universe" > /etc/apt/sources.list
+    run apt-get update
+    
+    run apt-get install -y inotify-tools nginx apache openssh-server
+    insert https://raw.github.com/creack/docker-vps/master/nginx-wrapper.sh /usr/sbin/nginx-wrapper
+
+::
+
+    # Firefox over VNC
+    #
+    # VERSION               0.3
+    # DOCKER-VERSION        0.2
+    
+    from ubuntu
+    # make sure the package repository is up to date
+    run echo "deb http://archive.ubuntu.com/ubuntu precise main universe" > /etc/apt/sources.list
+    run apt-get update
+    
+    # Install vnc, xvfb in order to create a 'fake' display and firefox
+    run apt-get install -y x11vnc xvfb firefox
+    run mkdir /.vnc
+    # Setup a password
+    run x11vnc -storepasswd 1234 ~/.vnc/passwd
+    # Autostart firefox (might not be the best way to do it, but it does the trick)
+    run bash -c 'echo "firefox" >> /.bashrc'

docs/sources/builder/index.rst

@@ -0,0 +1,14 @@
+:title: docker documentation
+:description: Documentation for docker builder
+:keywords: docker, builder, dockerfile
+
+
+Builder
+=======
+
+Contents:
+
+.. toctree::
+  :maxdepth: 2
+
+  basics

docs/sources/commandline/cli.rst

@@ -27,6 +27,7 @@ Available Commands
    :maxdepth: 1
 
    command/attach
+   command/build
    command/commit
    command/diff
    command/export

docs/sources/commandline/command/build.rst

@@ -0,0 +1,9 @@
+===========================================
+``build`` -- Build a container from Dockerfile via stdin
+===========================================
+
+::
+
+    Usage: docker build -
+    Example: cat Dockerfile | docker build -
+    Build a new image from the Dockerfile passed via stdin

docs/sources/index.rst

@@ -15,7 +15,8 @@ This documentation has the following resources:
    examples/index
    contributing/index
    commandline/index
+   builder/index
    faq
 
 
-.. image:: http://www.docker.io/_static/lego_docker.jpg
+.. image:: http://www.docker.io/_static/lego_docker.jpg

graph.go

@@ -84,14 +84,13 @@ 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, config *Config) (*Image, error) {
+func (graph *Graph) Create(layerData Archive, container *Container, comment, author string) (*Image, error) {
 	img := &Image{
 		Id:            GenerateId(),
 		Comment:       comment,
 		Created:       time.Now(),
 		DockerVersion: VERSION,
 		Author:        author,
-		Config:        config,
 	}
 	if container != nil {
 		img.Parent = container.Image

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", "", nil)
+	image, err := graph.Create(archive, nil, "Testing", "")
 	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", "", nil)
+	image, err := graph.Create(archive, nil, "Testing", "")
 	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", "", nil)
+	img, err := graph.Create(archive, nil, "Test image", "")
 	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", "", nil)
+	img, err := graph.Create(archive, nil, "Bla bla", "")
 	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", "", nil)
+	img1, err := graph.Create(archive, nil, "Testing", "")
 	if err != nil {
 		t.Fatal(err)
 	}
-	if _, err = graph.Create(archive, nil, "Testing", "", nil); err != nil {
+	if _, err = graph.Create(archive, nil, "Testing", ""); err != nil {
 		t.Fatal(err)
 	}
 	assertNImages(graph, t, 2)

image.go

@@ -24,7 +24,6 @@ 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
 }
 

puppet/manifests/quantal64.pp

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,30 @@
+# ~/.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

@@ -12,7 +12,6 @@ import (
 	"path"
 	"sort"
 	"strings"
-	"time"
 )
 
 type Capabilities struct {
@@ -77,115 +76,6 @@ 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
-	}
-
-	//runtime.mergeConfig(config, img.Config)
-	if img.Config != nil {
-		config = img.Config
-	}
-
-	if config.Cmd == nil {
-		return nil, fmt.Errorf("No command specified")
-	}
-
-	// Generate id
-	id := GenerateId()
-	// Generate default hostname
-	// FIXME: the lxc template no longer needs to set a default hostname
-	if config.Hostname == "" {
-		config.Hostname = id[:12]
-	}
-
-	container := &Container{
-		// FIXME: we should generate the ID here instead of receiving it as an argument
-		Id:              id,
-		Created:         time.Now(),
-		Path:            config.Cmd[0],
-		Args:            config.Cmd[1:], //FIXME: de-duplicate from config
-		Config:          config,
-		Image:           img.Id, // Always use the resolved image id
-		NetworkSettings: &NetworkSettings{},
-		// 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.
-	if err := os.Mkdir(container.root, 0700); err != nil {
-		return nil, err
-	}
-
-	// If custom dns exists, then create a resolv.conf for the container
-	if len(config.Dns) > 0 {
-		container.ResolvConfPath = path.Join(container.root, "resolv.conf")
-		f, err := os.Create(container.ResolvConfPath)
-		if err != nil {
-			return nil, err
-		}
-		defer f.Close()
-		for _, dns := range config.Dns {
-			if _, err := f.Write([]byte("nameserver " + dns + "\n")); err != nil {
-				return nil, err
-			}
-		}
-	} else {
-		container.ResolvConfPath = "/etc/resolv.conf"
-	}
-
-	// Step 2: save the container json
-	if err := container.ToDisk(); err != nil {
-		return nil, err
-	}
-	// Step 3: register the container
-	if err := runtime.Register(container); err != nil {
-		return nil, err
-	}
-	return container, nil
-}
-
 func (runtime *Runtime) Load(id string) (*Container, error) {
 	container := &Container{root: runtime.containerRoot(id)}
 	if err := container.FromDisk(); err != nil {
@@ -295,33 +185,6 @@ func (runtime *Runtime) Destroy(container *Container) error {
 	return nil
 }
 
-// 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, config *Config) (*Image, error) {
-	container := runtime.Get(id)
-	if container == nil {
-		return nil, fmt.Errorf("No such container: %s", id)
-	}
-	// FIXME: freeze the container before copying it to avoid data corruption?
-	// FIXME: this shouldn't be in commands.
-	rwTar, err := container.ExportRw()
-	if err != nil {
-		return nil, err
-	}
-	// Create a new image from the container's base layers + a new layer from container changes
-	img, err := runtime.graph.Create(rwTar, container, comment, author, config)
-	if err != nil {
-		return nil, err
-	}
-	// Register the image if needed
-	if repository != "" {
-		if err := runtime.repositories.Set(repository, tag, img.Id, true); err != nil {
-			return img, err
-		}
-	}
-	return img, nil
-}
-
 func (runtime *Runtime) restore() error {
 	dir, err := ioutil.ReadDir(runtime.repository)
 	if err != nil {

runtime_test.go

@@ -60,8 +60,6 @@ func init() {
 		panic("docker tests needs to be run as root")
 	}
 
-	NetworkBridgeIface = "testdockbr0"
-
 	// Make it our Store root
 	runtime, err := NewRuntimeFromDirectory(unitTestStoreBase)
 	if err != nil {
@@ -118,7 +116,7 @@ func TestRuntimeCreate(t *testing.T) {
 	if len(runtime.List()) != 0 {
 		t.Errorf("Expected 0 containers, %v found", len(runtime.List()))
 	}
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"ls", "-al"},
 	},
@@ -165,7 +163,7 @@ func TestDestroy(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"ls", "-al"},
 	},
@@ -212,7 +210,10 @@ func TestGet(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer nuke(runtime)
-	container1, err := runtime.Create(&Config{
+
+	builder := NewBuilder(runtime)
+
+	container1, err := builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"ls", "-al"},
 	},
@@ -222,7 +223,7 @@ func TestGet(t *testing.T) {
 	}
 	defer runtime.Destroy(container1)
 
-	container2, err := runtime.Create(&Config{
+	container2, err := builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"ls", "-al"},
 	},
@@ -232,7 +233,7 @@ func TestGet(t *testing.T) {
 	}
 	defer runtime.Destroy(container2)
 
-	container3, err := runtime.Create(&Config{
+	container3, err := builder.Create(&Config{
 		Image: GetTestImage(runtime).Id,
 		Cmd:   []string{"ls", "-al"},
 	},
@@ -262,7 +263,7 @@ func TestAllocatePortLocalhost(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	container, err := runtime.Create(&Config{
+	container, err := NewBuilder(runtime).Create(&Config{
 		Image:     GetTestImage(runtime).Id,
 		Cmd:       []string{"sh", "-c", "echo well hello there | nc -l -p 5555"},
 		PortSpecs: []string{"5555"},
@@ -315,8 +316,10 @@ func TestRestore(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	builder := NewBuilder(runtime1)
+
 	// Create a container with one instance of docker
-	container1, err := runtime1.Create(&Config{
+	container1, err := builder.Create(&Config{
 		Image: GetTestImage(runtime1).Id,
 		Cmd:   []string{"ls", "-al"},
 	},
@@ -327,7 +330,7 @@ func TestRestore(t *testing.T) {
 	defer runtime1.Destroy(container1)
 
 	// Create a second container meant to be killed
-	container2, err := runtime1.Create(&Config{
+	container2, err := builder.Create(&Config{
 		Image:     GetTestImage(runtime1).Id,
 		Cmd:       []string{"/bin/cat"},
 		OpenStdin: true,

utils.go

@@ -154,6 +154,13 @@ func SelfPath() string {
 	return path
 }
 
+type nopWriter struct {
+}
+
+func (w *nopWriter) Write(buf []byte) (int, error) {
+	return len(buf), nil
+}
+
 type nopWriteCloser struct {
 	io.Writer
 }