@@ -1,4 +1,5 @@

-docker

-dockerd

+.vagrant

+docker/docker

+dockerd/dockerd

 .*.swp

 a.out

@@ -23,7 +23,7 @@ Notable features

 * Resource isolation: system resources like cpu and memory can be allocated differently to each process container, using cgroups.

-* Network isolation: each process container runs in its own network namespace, with a virtual interface and IP address of its own (COMING SOON)

+* Network isolation: each process container runs in its own network namespace, with a virtual interface and IP address of its own.

 * Copy-on-write: root filesystems are created using copy-on-write, which makes deployment extremeley fast, memory-cheap and disk-cheap.

@@ -34,6 +34,56 @@ Notable features

 * Interactive shell: docker can allocate a pseudo-tty and attach to the standard input of any container, for example to run a throaway interactive shell.

+

+Under the hood

+--------------

+

+Under the hood, Docker is built on the following components:

+

+

+* The [cgroup](http://blog.dotcloud.com/kernel-secrets-from-the-paas-garage-part-24-c) and [namespacing](http://blog.dotcloud.com/under-the-hood-linux-kernels-on-dotcloud-part) capabilities of the Linux kernel;

+

+* [AUFS](http://aufs.sourceforge.net/aufs.html), a powerful union filesystem with copy-on-write capabilities;

+

+* The [Go](http://golang.org) programming language;

+

+* [lxc](http://lxc.sourceforge.net/), a set of convenience scripts to simplify the creation of linux containers.

+

+

+Setup instructions

+==================

+

+Requirements

+------------

+

+Right now, the officially supported distributions are:

+

+* Ubuntu 12.04 (precise LTS)

+* Ubuntu 12.10 (quantal)

+

+Docker probably works on other distributions featuring a recent kernel, the AUFS patch, and up-to-date lxc. However this has not been tested.

+

+

+Installation

+---------------

+

+1. Set up your host of choice on a physical / virtual machine

+2. Assume root identity on your newly installed environment (`sudo -s`)

+3. Type the following commands:

+

+        apt-get update

+        apt-get install lxc wget bsdtar curl

+

+4. Download the latest docker binaries: `wget http://docker.io.s3.amazonaws.com/builds/$(uname -s)/$(uname -m)/docker-master.tgz` ([Or get the Linux/x86_64 binaries here](http://docker.io.s3.amazonaws.com/builds/Linux/x86_64/docker-master.tgz) )

+5. Extract the contents of the tar file `tar -xf docker-master.tar.gz`

+6. Launch the docker daemon in the background `./dockerd &`

+7. Download a base image `./docker pull base`

+8. Run your first container! `./docker run -i -a -t base /bin/bash`

+9. Start exploring `./docker --help`

+

+Consider adding docker and dockerd to your `PATH` for simplicity.

+

+

 What is a Standard Container?

 -----------------------------

@@ -76,20 +126,6 @@ With Standard Containers we can put an end to that embarrassment, by making INDU

-Under the hood

-

-Under the hood, Docker is built on the following components:

-

-

-* The [cgroup](http://blog.dotcloud.com/kernel-secrets-from-the-paas-garage-part-24-c) and [namespacing](http://blog.dotcloud.com/under-the-hood-linux-kernels-on-dotcloud-part) capabilities of the Linux kernel;

-

-* [AUFS](http://aufs.sourceforge.net/aufs.html), a powerful union filesystem with copy-on-write capabilities;

-

-* The [Go](http://golang.org) programming language;

-

-* [lxc](http://lxc.sourceforge.net/), a set of convenience scripts to simplify the creation of linux containers.

-

 Standard Container Specification

 --------------------------------

@@ -135,121 +171,3 @@ Standard Container Specification

 #### Security

-Setup instructions

-==================

-

-Requirements

-

-Right now, the officially supported distributions are:

-

-* Ubuntu 12.04 (precise LTS)

-* Ubuntu 12.10 (quantal)

-

-Docker probably works on other distributions featuring a recent kernel, the AUFS patch, and up-to-date lxc. However this has not been tested.

-

-

-Step by step host setup

-

-1. Set up your host of choice on a physical / virtual machine

-2. Assume root identity on your newly installed environment (`sudo -s`)

-3. Type the following commands:

-

-        apt-get update

-        apt-get install lxc wget

-

-4. Download the latest version of the [docker binaries](https://dl.dropbox.com/u/20637798/docker.tar.gz) (`wget https://dl.dropbox.com/u/20637798/docker.tar.gz`) (warning: this may not be the most up-to-date build)

-5. Extract the contents of the tar file `tar -xf docker.tar.gz`

-6. Launch the docker daemon `./dockerd`

-7. Download a base image by running 'docker pull -j base'

-

-

-Client installation

-

-4. Download the latest version of the [docker binaries](https://dl.dropbox.com/u/20637798/docker.tar.gz) (`wget https://dl.dropbox.com/u/20637798/docker.tar.gz`)

-5. Extract the contents of the tar file `tar -xf docker.tar.gz`

-6. You can now use the docker client binary `./docker`. Consider adding it to your `PATH` for simplicity.

-

-Vagrant Usage

-

-1. Install Vagrant from http://vagrantup.com

-2. Run `vagrant up`. This will take a few minutes as it does the following:

-    - Download Quantal64 base box

-    - Kick off Puppet to do:

-        - Download & untar 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.

-

-Sample run output:

-

-```bash

-$ vagrant up

-[default] Importing base box 'quantal64'...

-[default] Matching MAC address for NAT networking...

-[default] Clearing any previously set forwarded ports...

-[default] Forwarding ports...

-[default] -- 22 => 2222 (adapter 1)

-[default] Creating shared folders metadata...

-[default] Clearing any previously set network interfaces...

-[default] Booting VM...

-[default] Waiting for VM to boot. This can take a few minutes.

-[default] VM booted and ready for use!

-[default] Mounting shared folders...

-[default] -- v-root: /vagrant

-[default] -- manifests: /tmp/vagrant-puppet/manifests

-[default] -- v-pp-m0: /tmp/vagrant-puppet/modules-0

-[default] Running provisioner: Vagrant::Provisioners::Puppet...

-[default] Running Puppet with /tmp/vagrant-puppet/manifests/quantal64.pp...

-stdin: is not a tty

-notice: /Stage[main]//Node[default]/Exec[apt_update]/returns: executed successfully

-

-notice: /Stage[main]/Docker/Exec[fetch-docker]/returns: executed successfully

-notice: /Stage[main]/Docker/Package[lxc]/ensure: ensure changed 'purged' to 'present'

-notice: /Stage[main]/Docker/Exec[fetch-go]/returns: executed successfully

-

-notice: /Stage[main]/Docker/Exec[copy-docker-bin]/returns: executed successfully

-notice: /Stage[main]/Docker/Exec[debootstrap]/returns: executed successfully

-notice: /Stage[main]/Docker/File[/etc/init/dockerd.conf]/ensure: defined content as '{md5}78a593d38dd9919af14d8f0545ac95e9'

-

-notice: /Stage[main]/Docker/Service[dockerd]/ensure: ensure changed 'stopped' to 'running'

-

-notice: Finished catalog run in 329.74 seconds

-```

-

-When this has successfully completed, you should be able to get into your new system with `vagrant ssh` and use `docker`:

-

-```bash

-$ vagrant ssh

-Welcome to Ubuntu 12.10 (GNU/Linux 3.5.0-17-generic x86_64)

-

- * Documentation:  https://help.ubuntu.com/

-

-Last login: Sun Feb  3 19:37:37 2013

-vagrant@vagrant-ubuntu-12:~$ DOCKER=localhost:4242 docker help

-Usage: docker COMMAND [arg...]

-

-A self-sufficient runtime for linux containers.

-

-Commands:

-    run       Run a command in a container

-    ps        Display a list of containers

-    pull      Download a tarball and create a container from it

-    put       Upload a tarball and create a container from it

-    rm        Remove containers

-    wait      Wait for the state of a container to change

-    stop      Stop a running container

-    logs      Fetch the logs of a container

-    diff      Inspect changes on a container's filesystem

-    commit    Save the state of a container

-    attach    Attach to the standard inputs and outputs of a running container

-    info      Display system-wide information

-    tar       Stream the contents of a container as a tar archive

-    web       Generate a web UI

-    attach    Attach to a running container

-```

-    

@@ -1,8 +1,8 @@

 package client

 import (

-	"github.com/dotcloud/docker/rcli"

 	"github.com/dotcloud/docker/future"

+	"github.com/dotcloud/docker/rcli"

 	"io"

 	"io/ioutil"

 	"log"

@@ -112,7 +112,7 @@ func InteractiveMode(scripts ...string) error {

 		return err

 	}

 	io.WriteString(rcfile, "enable -n help\n")

-	os.Setenv("PATH", tmp + ":" + os.Getenv("PATH"))

+	os.Setenv("PATH", tmp+":"+os.Getenv("PATH"))

 	os.Setenv("PS1", "\\h docker> ")

 	shell := exec.Command("/bin/bash", append([]string{"--rcfile", rcfile.Name()}, scripts...)...)

 	shell.Stdin = os.Stdin

@@ -15,7 +15,6 @@ type Termios struct {

 	Ospeed uintptr

 }

-

 const (

 	// Input flags

 	inpck  = 0x010

@@ -35,113 +34,110 @@ const (

 )

 const (

-        HUPCL                             = 0x4000 

-        ICANON                            = 0x100 

-        ICRNL                             = 0x100 

-        IEXTEN                            = 0x400

-        BRKINT                            = 0x2 

-        CFLUSH                            = 0xf 

-        CLOCAL                            = 0x8000 

-        CREAD                             = 0x800 

-        CS5                               = 0x0 

-        CS6                               = 0x100 

-        CS7                               = 0x200 

-        CS8                               = 0x300 

-        CSIZE                             = 0x300 

-        CSTART                            = 0x11 

-        CSTATUS                           = 0x14 

-        CSTOP                             = 0x13 

-        CSTOPB                            = 0x400 

-        CSUSP                             = 0x1a 

-        IGNBRK                            = 0x1 

-        IGNCR                             = 0x80 

-        IGNPAR                            = 0x4 

-        IMAXBEL                           = 0x2000 

-        INLCR                             = 0x40 

-        INPCK                             = 0x10 

-        ISIG                              = 0x80 

-        ISTRIP                            = 0x20 

-        IUTF8                             = 0x4000 

-        IXANY                             = 0x800 

-        IXOFF                             = 0x400 

-        IXON                              = 0x200 

-        NOFLSH                            = 0x80000000 

-        OCRNL                             = 0x10 

-        OFDEL                             = 0x20000 

-        OFILL                             = 0x80 

-        ONLCR                             = 0x2 

-        ONLRET                            = 0x40 

-        ONOCR                             = 0x20 

-        ONOEOT                            = 0x8 

-        OPOST                             = 0x1 

-RENB                            = 0x1000 

-        PARMRK                            = 0x8 

-        PARODD                            = 0x2000 

-

-        TOSTOP                            = 0x400000 

-        VDISCARD                          = 0xf 

-        VDSUSP                            = 0xb 

-        VEOF                              = 0x0 

-        VEOL                              = 0x1 

-        VEOL2                             = 0x2 

-        VERASE                            = 0x3 

-        VINTR                             = 0x8 

-        VKILL                             = 0x5 

-        VLNEXT                            = 0xe 

-        VMIN                              = 0x10 

-        VQUIT                             = 0x9 

-        VREPRINT                          = 0x6 

-        VSTART                            = 0xc 

-        VSTATUS                           = 0x12 

-        VSTOP                             = 0xd 

-        VSUSP                             = 0xa 

-        VT0                               = 0x0 

-        VT1                               = 0x10000 

-        VTDLY                             = 0x10000 

-        VTIME                             = 0x11 

-	ECHO				  = 0x00000008

-

-        PENDIN                            = 0x20000000 

+	HUPCL   = 0x4000

+	ICANON  = 0x100

+	ICRNL   = 0x100

+	IEXTEN  = 0x400

+	BRKINT  = 0x2

+	CFLUSH  = 0xf

+	CLOCAL  = 0x8000

+	CREAD   = 0x800

+	CS5     = 0x0

+	CS6     = 0x100

+	CS7     = 0x200

+	CS8     = 0x300

+	CSIZE   = 0x300

+	CSTART  = 0x11

+	CSTATUS = 0x14

+	CSTOP   = 0x13

+	CSTOPB  = 0x400

+	CSUSP   = 0x1a

+	IGNBRK  = 0x1

+	IGNCR   = 0x80

+	IGNPAR  = 0x4

+	IMAXBEL = 0x2000

+	INLCR   = 0x40

+	INPCK   = 0x10

+	ISIG    = 0x80

+	ISTRIP  = 0x20

+	IUTF8   = 0x4000

+	IXANY   = 0x800

+	IXOFF   = 0x400

+	IXON    = 0x200

+	NOFLSH  = 0x80000000

+	OCRNL   = 0x10

+	OFDEL   = 0x20000

+	OFILL   = 0x80

+	ONLCR   = 0x2

+	ONLRET  = 0x40

+	ONOCR   = 0x20

+	ONOEOT  = 0x8

+	OPOST   = 0x1

+	RENB    = 0x1000

+	PARMRK  = 0x8

+	PARODD  = 0x2000

+

+	TOSTOP   = 0x400000

+	VDISCARD = 0xf

+	VDSUSP   = 0xb

+	VEOF     = 0x0

+	VEOL     = 0x1

+	VEOL2    = 0x2

+	VERASE   = 0x3

+	VINTR    = 0x8

+	VKILL    = 0x5

+	VLNEXT   = 0xe

+	VMIN     = 0x10

+	VQUIT    = 0x9

+	VREPRINT = 0x6

+	VSTART   = 0xc

+	VSTATUS  = 0x12

+	VSTOP    = 0xd

+	VSUSP    = 0xa

+	VT0      = 0x0

+	VT1      = 0x10000

+	VTDLY    = 0x10000

+	VTIME    = 0x11

+	ECHO     = 0x00000008

+

+	PENDIN = 0x20000000

 )

 type State struct {

-       termios Termios

+	termios Termios

 }

 // IsTerminal returns true if the given file descriptor is a terminal.

 func IsTerminal(fd int) bool {

-        var termios Termios

-        _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(getTermios), uintptr(unsafe.Pointer(&termios)), 0, 0, 0)

-        return err == 0

+	var termios Termios

+	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(getTermios), uintptr(unsafe.Pointer(&termios)), 0, 0, 0)

+	return err == 0

 }

 // MakeRaw put the terminal connected to the given file descriptor into raw

 // mode and returns the previous state of the terminal so that it can be

 // restored.

 func MakeRaw(fd int) (*State, error) {

-        var oldState State

-        if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(getTermios), uintptr(unsafe.Pointer(&oldState.termios)), 0, 0, 0); err != 0 {

-                return nil, err

-        }

-

-        newState := oldState.termios

-        newState.Iflag &^= ISTRIP | INLCR | IGNCR | IXON | IXOFF

-        newState.Iflag |= ICRNL

-        newState.Oflag |= ONLCR

-        newState.Lflag &^= ECHO | ICANON | ISIG

-        if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(setTermios), uintptr(unsafe.Pointer(&newState)), 0, 0, 0); err != 0 {

-                return nil, err

-        }

-

-        return &oldState, nil

+	var oldState State

+	if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(getTermios), uintptr(unsafe.Pointer(&oldState.termios)), 0, 0, 0); err != 0 {

+		return nil, err

+	}

+

+	newState := oldState.termios

+	newState.Iflag &^= ISTRIP | INLCR | IGNCR | IXON | IXOFF

+	newState.Iflag |= ICRNL

+	newState.Oflag |= ONLCR

+	newState.Lflag &^= ECHO | ICANON | ISIG

+	if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(setTermios), uintptr(unsafe.Pointer(&newState)), 0, 0, 0); err != 0 {

+		return nil, err

+	}

+

+	return &oldState, nil

 }

-

 // Restore restores the terminal connected to the given file descriptor to a

 // previous state.

 func Restore(fd int, state *State) error {

-        _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(setTermios), uintptr(unsafe.Pointer(&state.termios)), 0, 0, 0)

-        return err

+	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(setTermios), uintptr(unsafe.Pointer(&state.termios)), 0, 0, 0)

+	return err

 }

-

-

@@ -1,7 +1,7 @@

 package docker

 import (

-	"bytes"

+	"./fs"

 	"encoding/json"

 	"errors"

 	"github.com/kr/pty"

@@ -11,10 +11,9 @@ import (

 	"os"

 	"os/exec"

 	"path"

-	"strings"

+	"strconv"

 	"syscall"

 	"time"

-	"./fs"

 )

 var sysInitPath string

@@ -35,7 +34,11 @@ type Container struct {

 	Config     *Config

 	Mountpoint *fs.Mountpoint

 	State      *State

-	Image	   string

+	Image      string

+

+	network         *NetworkInterface

+	networkManager  *NetworkManager

+	NetworkSettings *NetworkSettings

 	SysInitPath   string

 	lxcConfigPath string

@@ -45,40 +48,61 @@ type Container struct {

 	stdin         io.ReadCloser

 	stdinPipe     io.WriteCloser

-	stdoutLog *bytes.Buffer

-	stderrLog *bytes.Buffer

+	stdoutLog *os.File

+	stderrLog *os.File

 }

 type Config struct {

 	Hostname  string

 	User      string

 	Ram       int64

+	Ports     []int

 	Tty       bool // Attach standard streams to a tty, including stdin if it is not closed.

 	OpenStdin bool // Open stdin

 }

-func createContainer(id string, root string, command string, args []string, image *fs.Image, config *Config) (*Container, error) {

+type NetworkSettings struct {

+	IpAddress   string

+	IpPrefixLen int

+	Gateway     string

+	PortMapping map[string]string

+}

+

+func createContainer(id string, root string, command string, args []string, image *fs.Image, config *Config, netManager *NetworkManager) (*Container, error) {

 	mountpoint, err := image.Mountpoint(path.Join(root, "rootfs"), path.Join(root, "rw"))

 	if err != nil {

 		return nil, err

 	}

 	container := &Container{

-		Id:         id,

-		Root:       root,

-		Created:    time.Now(),

-		Path:       command,

-		Args:       args,

-		Config:     config,

-		Image:		image.Id,

-		Mountpoint: mountpoint,

-		State:      newState(),

-

-		SysInitPath:   sysInitPath,

-		lxcConfigPath: path.Join(root, "config.lxc"),

-		stdout:        newWriteBroadcaster(),

-		stderr:        newWriteBroadcaster(),

-		stdoutLog:     new(bytes.Buffer),

-		stderrLog:     new(bytes.Buffer),

+		Id:              id,

+		Root:            root,

+		Created:         time.Now(),

+		Path:            command,

+		Args:            args,

+		Config:          config,

+		Image:           image.Id,

+		Mountpoint:      mountpoint,

+		State:           newState(),

+		networkManager:  netManager,

+		NetworkSettings: &NetworkSettings{},

+		SysInitPath:     sysInitPath,

+		lxcConfigPath:   path.Join(root, "config.lxc"),

+		stdout:          newWriteBroadcaster(),

+		stderr:          newWriteBroadcaster(),

+	}

+	if err := os.Mkdir(root, 0700); err != nil {

+		return nil, err

+	}

+	// Setup logging of stdout and stderr to disk

+	if stdoutLog, err := os.OpenFile(path.Join(container.Root, id+"-stdout.log"), os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600); err != nil {

+		return nil, err

+	} else {

+		container.stdoutLog = stdoutLog

+	}

+	if stderrLog, err := os.OpenFile(path.Join(container.Root, id+"-stderr.log"), os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600); err != nil {

+		return nil, err

+	} else {

+		container.stderrLog = stderrLog

 	}

 	if container.Config.OpenStdin {

 		container.stdin, container.stdinPipe = io.Pipe()

@@ -88,36 +112,43 @@ func createContainer(id string, root string, command string, args []string, imag

 	container.stdout.AddWriter(NopWriteCloser(container.stdoutLog))

 	container.stderr.AddWriter(NopWriteCloser(container.stderrLog))

-	if err := os.Mkdir(root, 0700); err != nil {

-		return nil, err

-	}

-	/*if err := container.Filesystem.createMountPoints(); err != nil {

-		return nil, err

-	}*/

 	if err := container.save(); err != nil {

 		return nil, err

 	}

 	return container, nil

 }

-func loadContainer(containerPath string) (*Container, error) {

+func loadContainer(containerPath string, netManager *NetworkManager) (*Container, error) {

 	data, err := ioutil.ReadFile(path.Join(containerPath, "config.json"))

 	if err != nil {

 		return nil, err

 	}

 	container := &Container{

-		stdout:        newWriteBroadcaster(),

-		stderr:        newWriteBroadcaster(),

-		stdoutLog:     new(bytes.Buffer),

-		stderrLog:     new(bytes.Buffer),

-		lxcConfigPath: path.Join(containerPath, "config.lxc"),

+		stdout:          newWriteBroadcaster(),

+		stderr:          newWriteBroadcaster(),

+		lxcConfigPath:   path.Join(containerPath, "config.lxc"),

+		networkManager:  netManager,

+		NetworkSettings: &NetworkSettings{},

 	}

+	// Load container settings

 	if err := json.Unmarshal(data, container); err != nil {

 		return nil, err

 	}

-	// if err := container.Filesystem.createMountPoints(); err != nil {

-	// 	return nil, err

-	// }

+

+	// Setup logging of stdout and stderr to disk

+	if stdoutLog, err := os.OpenFile(path.Join(container.Root, container.Id+"-stdout.log"), os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600); err != nil {

+		return nil, err

+	} else {

+		container.stdoutLog = stdoutLog

+	}

+	if stderrLog, err := os.OpenFile(path.Join(container.Root, container.Id+"-stderr.log"), os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600); err != nil {

+		return nil, err

+	} else {

+		container.stderrLog = stderrLog

+	}

+	container.stdout.AddWriter(NopWriteCloser(container.stdoutLog))

+	container.stderr.AddWriter(NopWriteCloser(container.stderrLog))

+

 	if container.Config.OpenStdin {

 		container.stdin, container.stdinPipe = io.Pipe()

 	} else {

@@ -270,6 +301,9 @@ func (container *Container) Start() error {

 	if err := container.Mountpoint.EnsureMounted(); err != nil {

 		return err

 	}

+	if err := container.allocateNetwork(); err != nil {

+		return err

+	}

 	if err := container.generateLXCConfig(); err != nil {

 		return err

 	}

@@ -279,11 +313,19 @@ func (container *Container) Start() error {

 		"--",

 		"/sbin/init",

 	}

+

+	// Networking

+	params = append(params, "-g", container.network.Gateway.String())

+

+	// User

 	if container.Config.User != "" {

 		params = append(params, "-u", container.Config.User)

 	}

+

+	// Program

 	params = append(params, "--", container.Path)

 	params = append(params, container.Args...)

+

 	container.cmd = exec.Command("/usr/bin/lxc-start", params...)

 	var err error

@@ -337,7 +379,11 @@ func (container *Container) StdoutPipe() (io.ReadCloser, error) {

 }

 func (container *Container) StdoutLog() io.Reader {

-	return strings.NewReader(container.stdoutLog.String())

+	r, err := os.Open(container.stdoutLog.Name())

+	if err != nil {

+		return nil

+	}

+	return r

 }

 func (container *Container) StderrPipe() (io.ReadCloser, error) {

@@ -347,7 +393,39 @@ func (container *Container) StderrPipe() (io.ReadCloser, error) {

 }

 func (container *Container) StderrLog() io.Reader {

-	return strings.NewReader(container.stderrLog.String())

+	r, err := os.Open(container.stderrLog.Name())

+	if err != nil {

+		return nil

+	}

+	return r

+}

+

+func (container *Container) allocateNetwork() error {

+	iface, err := container.networkManager.Allocate()

+	if err != nil {

+		return err

+	}

+	container.NetworkSettings.PortMapping = make(map[string]string)

+	for _, port := range container.Config.Ports {

+		if extPort, err := iface.AllocatePort(port); err != nil {

+			iface.Release()

+			return err

+		} else {

+			container.NetworkSettings.PortMapping[strconv.Itoa(port)] = strconv.Itoa(extPort)

+		}

+	}

+	container.network = iface

+	container.NetworkSettings.IpAddress = iface.IPNet.IP.String()

+	container.NetworkSettings.IpPrefixLen, _ = iface.IPNet.Mask.Size()

+	container.NetworkSettings.Gateway = iface.Gateway.String()

+	return nil

+}

+

+func (container *Container) releaseNetwork() error {

+	err := container.network.Release()

+	container.network = nil

+	container.NetworkSettings = &NetworkSettings{}

+	return err

 }

 func (container *Container) monitor() {

@@ -356,6 +434,9 @@ func (container *Container) monitor() {

 	exitCode := container.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()

 	// Cleanup

+	if err := container.releaseNetwork(); err != nil {

+		log.Printf("%v: Failed to release network: %v", container.Id, err)

+	}

 	container.stdout.Close()

 	container.stderr.Close()

 	if err := container.Mountpoint.Umount(); err != nil {

@@ -422,11 +503,13 @@ func (container *Container) Restart() error {

 	return nil

 }

-func (container *Container) Wait() {

+// Wait blocks until the container stops running, then returns its exit code.

+func (container *Container) Wait() int {

 	for container.State.Running {

 		container.State.wait()

 	}

+	return container.State.ExitCode

 }

 func (container *Container) WaitTimeout(timeout time.Duration) error {

@@ -4,6 +4,7 @@ import (

 	"fmt"

 	"io"

 	"io/ioutil"

+	"sort"

 	"strings"

 	"testing"

 	"time"

@@ -513,6 +514,55 @@ func TestTty(t *testing.T) {

 	}

 }

+func TestEnv(t *testing.T) {

+	docker, err := newTestDocker()

+	if err != nil {

+		t.Fatal(err)

+	}

+	container, err := docker.Create(

+		"env_test",

+		"/usr/bin/env",

+		[]string{},

+		GetTestImage(docker),

+		&Config{},

+	)

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer docker.Destroy(container)

+	stdout, err := container.StdoutPipe()

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer stdout.Close()

+	if err := container.Start(); err != nil {

+		t.Fatal(err)

+	}

+	container.Wait()

+	output, err := ioutil.ReadAll(stdout)

+	if err != nil {

+		t.Fatal(err)

+	}

+	actualEnv := strings.Split(string(output), "\n")

+	if actualEnv[len(actualEnv)-1] == "" {

+		actualEnv = actualEnv[:len(actualEnv)-1]

+	}

+	sort.Strings(actualEnv)

+	goodEnv := []string{

+		"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",

+		"HOME=/",

+	}

+	sort.Strings(goodEnv)

+	if len(goodEnv) != len(actualEnv) {

+		t.Fatalf("Wrong environment: should be %d variables, not: '%s'\n", len(goodEnv), strings.Join(actualEnv, ", "))

+	}

+	for i := range goodEnv {

+		if actualEnv[i] != goodEnv[i] {

+			t.Fatalf("Wrong environment variable: should be %s, not %s", goodEnv[i], actualEnv[i])

+		}

+	}

+}

+

 func BenchmarkRunSequencial(b *testing.B) {

 	docker, err := newTestDocker()

 	if err != nil {

@@ -1,6 +1,7 @@

 package docker

 import (

+	"./fs"

 	"container/list"

 	"fmt"

 	"io/ioutil"

@@ -8,14 +9,14 @@ import (

 	"os"

 	"path"

 	"sort"

-	"./fs"

 )

 type Docker struct {

-	root       	string

-	repository 	string

-	containers 	*list.List

-	Store		*fs.Store

+	root           string

+	repository     string

+	containers     *list.List

+	networkManager *NetworkManager

+	Store          *fs.Store

 }

 func (docker *Docker) List() []*Container {

@@ -53,7 +54,8 @@ func (docker *Docker) Create(id string, command string, args []string, image *fs

 		return nil, fmt.Errorf("Container %v already exists", id)

 	}

 	root := path.Join(docker.repository, id)

-	container, err := createContainer(id, root, command, args, image, config)

+

+	container, err := createContainer(id, root, command, args, image, config, docker.networkManager)

 	if err != nil {

 		return nil, err

 	}

@@ -92,7 +94,7 @@ func (docker *Docker) restore() error {

 		return err

 	}

 	for _, v := range dir {

-		container, err := loadContainer(path.Join(docker.repository, v.Name()))

+		container, err := loadContainer(path.Join(docker.repository, v.Name()), docker.networkManager)

 		if err != nil {

 			log.Printf("Failed to load container %v: %v", v.Name(), err)

 			continue

@@ -112,12 +114,17 @@ func NewFromDirectory(root string) (*Docker, error) {

 	if err != nil {

 		return nil, err

 	}

+	netManager, err := newNetworkManager(networkBridgeIface)

+	if err != nil {

+		return nil, err

+	}

 	docker := &Docker{

-		root:       root,

-		repository: path.Join(root, "containers"),

-		containers: list.New(),

-		Store:		store,

+		root:           root,

+		repository:     path.Join(root, "containers"),

+		containers:     list.New(),

+		Store:          store,

+		networkManager: netManager,

 	}

 	if err := os.MkdirAll(docker.repository, 0700); err != nil && !os.IsExist(err) {

@@ -2,10 +2,10 @@ package main

 import (

 	"flag"

+	"github.com/dotcloud/docker/client"

 	"log"

 	"os"

 	"path"

-	"github.com/dotcloud/docker/client"

 )

 func main() {

@@ -27,4 +27,3 @@ func main() {

 		}

 	}