Fix rebase conflicts from master

Add docs and maintainers file for new sub pkgs
Remove network connection when link is removed
2026-08-19 20:26:54 +00:00 · 2013-10-02 13:58:43 -07:00 · 2013-10-02 12:48:27 -07:00 · 2013-10-02 12:44:41 -07:00 · 2013-10-02 12:44:41 -07:00 · 2013-10-02 12:43:09 -07:00
331 changed files with 9962 additions and 22693 deletions
@@ -17,5 +17,3 @@ docs/_templates
 bundles/
 .hg/
 .git/
-vendor/pkg/
-pyenv
@@ -26,15 +26,3 @@ Roberto Hashioka <roberto_hashioka@hotmail.com>
 Konstantin Pelykh <kpelykh@zettaset.com>
 David Sissitka <me@dsissitka.com>
 Nolan Darilek <nolan@thewordnerd.info>
-<mastahyeti@gmail.com> <mastahyeti@users.noreply.github.com>
-Benoit Chesneau <bchesneau@gmail.com>
-Jordan Arentsen <blissdev@gmail.com>
-Daniel Garcia <daniel@danielgarcia.info>
-Miguel Angel Fernández <elmendalerenda@gmail.com>
-Bhiraj Butala <abhiraj.butala@gmail.com>
-Faiz Khan <faizkhan00@gmail.com>
-Victor Lyuboslavsky <victor@victoreda.com>
-Jean-Baptiste Barth <jeanbaptiste.barth@gmail.com>
-Matthew Mueller <mattmuelle@gmail.com>
-<mosoni@ebay.com> <mohitsoni1989@gmail.com>
-Shih-Yuan Lee <fourdollars@gmail.com>
@@ -5,102 +5,64 @@
 #
 Al Tobey <al@ooyala.com>
 Alex Gaynor <alex.gaynor@gmail.com>
-Alexander Larsson <alexl@redhat.com>
 Alexey Shamrin <shamrin@gmail.com>
 Andrea Luzzardi <aluzzardi@gmail.com>
-Andreas Savvides <andreas@editd.com>
 Andreas Tiefenthaler <at@an-ti.eu>
-Andrew Macgregor <andrew.macgregor@agworld.com.au>
 Andrew Munsell <andrew@wizardapps.net>
 Andrews Medina <andrewsmedina@gmail.com>
 Andy Rothfusz <github@metaliveblog.com>
 Andy Smith <github@anarkystic.com>
 Anthony Bishopric <git@anthonybishopric.com>
 Antony Messerli <amesserl@rackspace.com>
-Asbjørn Enge <asbjorn@hanafjedle.net>
 Barry Allard <barry.allard@gmail.com>
-Ben Toews <mastahyeti@gmail.com>
-Benoit Chesneau <bchesneau@gmail.com>
-Bhiraj Butala <abhiraj.butala@gmail.com>
-Bouke Haarsma <bouke@webatoom.nl>
 Brandon Liu <bdon@bdon.org>
-Brandon Philips <brandon@ifup.co>
 Brian McCallister <brianm@skife.org>
 Brian Olsen <brian@maven-group.org>
-Brian Shumate <brian@couchbase.com>
-Briehan Lombaard <briehan.lombaard@gmail.com>
 Bruno Bigras <bigras.bruno@gmail.com>
 Caleb Spare <cespare@gmail.com>
 Calen Pennington <cale@edx.org>
 Charles Hooper <charles.hooper@dotcloud.com>
 Christopher Currie <codemonkey+github@gmail.com>
-Colin Dunklau <colin.dunklau@gmail.com>
 Colin Rice <colin@daedrum.net>
-Dan Buch <d.buch@modcloth.com>
-Daniel Garcia <daniel@danielgarcia.info>
 Daniel Gasienica <daniel@gasienica.ch>
 Daniel Mizyrycki <daniel.mizyrycki@dotcloud.com>
-Daniel Nordberg <dnordberg@gmail.com>
 Daniel Robinson <gottagetmac@gmail.com>
 Daniel Von Fange <daniel@leancoder.com>
 Daniel YC Lin <dlin.tw@gmail.com>
-Darren Coxall <darren@darrencoxall.com>
 David Calavera <david.calavera@gmail.com>
 David Sissitka <me@dsissitka.com>
-Deni Bertovic <deni@kset.org>
 Dominik Honnef <dominik@honnef.co>
 Don Spaulding <donspauldingii@gmail.com>
 Dr Nic Williams <drnicwilliams@gmail.com>
-Dražen Lučanin <kermit666@gmail.com>
 Elias Probst <mail@eliasprobst.eu>
 Emily Rose <emily@contactvibe.com>
 Eric Hanchrow <ehanchrow@ine.com>
 Eric Myhre <hash@exultant.us>
 Erno Hopearuoho <erno.hopearuoho@gmail.com>
-Evan Phoenix <evan@fallingsnow.net>
 Evan Wies <evan@neomantra.net>
 ezbercih <cem.ezberci@gmail.com>
 Fabrizio Regini <freegenie@gmail.com>
-Faiz Khan <faizkhan00@gmail.com>
 Fareed Dudhia <fareeddudhia@googlemail.com>
 Flavio Castelli <fcastelli@suse.com>
 Francisco Souza <f@souza.cc>
 Frederick F. Kautz IV <fkautz@alumni.cmu.edu>
 Gabriel Monroy <gabriel@opdemand.com>
 Gareth Rushgrove <gareth@morethanseven.net>
-Greg Thornton <xdissent@me.com>
 Guillaume J. Charmes <guillaume.charmes@dotcloud.com>
-Gurjeet Singh <gurjeet@singh.im>
-Guruprasad <lgp171188@gmail.com>
 Harley Laue <losinggeneration@gmail.com>
-Hector Castro <hectcastro@gmail.com>
 Hunter Blanks <hunter@twilio.com>
-Isao Jonas <isao.jonas@gmail.com>
-James Carr <james.r.carr@gmail.com>
-James Turnbull <james@lovedthanlost.net>
-Jason McVetta <jason.mcvetta@gmail.com>
-Jean-Baptiste Barth <jeanbaptiste.barth@gmail.com>
 Jeff Lindsay <progrium@gmail.com>
 Jeremy Grosser <jeremy@synack.me>
-Jim Alateras <jima@comware.com.au>
-Jimmy Cuadra <jimmy@jimmycuadra.com>
-Joe Van Dyk <joe@tanga.com>
 Joffrey F <joffrey@dotcloud.com>
 Johan Euphrosine <proppy@google.com>
 John Costa <john.costa@gmail.com>
 Jon Wedaman <jweede@gmail.com>
 Jonas Pfenniger <jonas@pfenniger.name>
-Jonathan Mueller <j.mueller@apoveda.ch>
 Jonathan Rudenberg <jonathan@titanous.com>
-Joost Cassee <joost@cassee.net>
-Jordan Arentsen <blissdev@gmail.com>
 Joseph Anthony Pasquale Holsten <joseph@josephholsten.com>
-Josh Poimboeuf <jpoimboe@redhat.com>
 Julien Barbier <write0@gmail.com>
 Jérôme Petazzoni <jerome.petazzoni@dotcloud.com>
 Karan Lyons <karan@karanlyons.com>
-Karl Grzeszczak <karl@karlgrz.com>
-Kawsar Saiyeed <kawsar.saiyeed@projiris.com>
 Keli Hu <dev@keli.hu>
 Ken Cochrane <kencochrane@gmail.com>
 Kevin Clark <kevin.clark@gmail.com>
@@ -109,47 +71,28 @@ kim0 <email.ahmedkamal@googlemail.com>
 Kimbro Staken <kstaken@kstaken.com>
 Kiran Gangadharan <kiran.daredevil@gmail.com>
 Konstantin Pelykh <kpelykh@zettaset.com>
-Kyle Conroy <kyle.j.conroy@gmail.com>
-Laurie Voss <github@seldo.com>
 Louis Opter <kalessin@kalessin.fr>
-Manuel Meurer <manuel@krautcomputing.com>
 Marco Hennings <marco.hennings@freiheit.com>
 Marcus Farkas <toothlessgear@finitebox.com>
-Marcus Ramberg <marcus@nordaaker.com>
 Mark McGranaghan <mmcgrana@gmail.com>
-Marko Mikulicic <mmikulicic@gmail.com>
-Markus Fix <lispmeister@gmail.com>
-Martin Redmond <martin@tinychat.com>
-Matt Apperson <me@mattapperson.com>
-Mathieu Le Marec - Pasquet <kiorky@cryptelium.net>
-Matt Bachmann <bachmann.matt@gmail.com>
-Matthew Mueller <mattmuelle@gmail.com>
+Martin Redmond <mrtodo@gmail.com>
 Maxim Treskin <zerthurd@gmail.com>
 meejah <meejah@meejah.ca>
 Michael Crosby <crosby.michael@gmail.com>
-Michael Gorsuch <gorsuch@github.com>
-Miguel Angel Fernández <elmendalerenda@gmail.com>
 Mike Gaffney <mike@uberu.com>
 Mikhail Sobolev <mss@mawhrin.net>
-Mohit Soni <mosoni@ebay.com>
-Morten Siebuhr <sbhr@sbhr.dk>
 Nan Monnand Deng <monnand@gmail.com>
 Nate Jones <nate@endot.org>
 Nelson Chen <crazysim@gmail.com>
 Niall O'Higgins <niallo@unworkable.org>
-Nick Payne <nick@kurai.co.uk>
 Nick Stenning <nick.stenning@digital.cabinet-office.gov.uk>
 Nick Stinemates <nick@stinemates.org>
 Nolan Darilek <nolan@thewordnerd.info>
 odk- <github@odkurzacz.org>
-Pascal Borreli <pascal@borreli.com>
 Paul Bowsher <pbowsher@globalpersonals.co.uk>
 Paul Hammond <paul@paulhammond.org>
-Paul Nasrat <pnasrat@gmail.com>
 Phil Spitler <pspitler@gmail.com>
 Piotr Bogdan <ppbogdan@gmail.com>
-pysqz <randomq@126.com>
-Ramon van Alteren <ramon@vanalteren.nl>
 Renato Riccieri Santos Zannon <renato.riccieri@gmail.com>
 Rhys Hiltner <rhys@twitch.tv>
 Robert Obryk <robryk@gmail.com>
@@ -157,23 +100,14 @@ Roberto Hashioka <roberto_hashioka@hotmail.com>
 Ryan Fowler <rwfowler@gmail.com>
 Sam Alba <sam.alba@gmail.com>
 Sam J Sharpe <sam.sharpe@digital.cabinet-office.gov.uk>
-Scott Bessler <scottbessler@gmail.com>
-Sean P. Kane <skane@newrelic.com>
 Shawn Siefkas <shawn.siefkas@meredith.com>
-Shih-Yuan Lee <fourdollars@gmail.com>
 Silas Sewell <silas@sewell.org>
 Solomon Hykes <solomon@dotcloud.com>
-Song Gao <song@gao.io>
-Sridatta Thatipamala <sthatipamala@gmail.com>
 Sridhar Ratnakumar <sridharr@activestate.com>
-Steeve Morin <steeve.morin@gmail.com>
 Stefan Praszalowicz <stefan@greplin.com>
-Sven Dowideit <SvenDowideit@home.org.au>
 Thatcher Peskens <thatcher@dotcloud.com>
-Thermionix <bond711@gmail.com>
 Thijs Terlouw <thijsterlouw@gmail.com>
 Thomas Bikeev <thomas.bikeev@mac.com>
-Thomas Frössman <thomasf@jossystem.se>
 Thomas Hansen <thomas.hansen@gmail.com>
 Tianon Gravi <admwiggin@gmail.com>
 Tim Terhorst <mynamewastaken+git@gmail.com>
@@ -181,17 +115,8 @@ Tobias Bieniek <Tobias.Bieniek@gmx.de>
 Tobias Schmidt <ts@soundcloud.com>
 Tobias Schwab <tobias.schwab@dynport.de>
 Tom Hulihan <hulihan.tom159@gmail.com>
-Tommaso Visconti <tommaso.visconti@gmail.com>
-Tyler Brock <tyler.brock@gmail.com>
 unclejack <unclejacksons@gmail.com>
-Victor Coisne <victor.coisne@dotcloud.com>
-Victor Lyuboslavsky <victor@victoreda.com>
 Victor Vieux <victor.vieux@dotcloud.com>
-Vincent Bernat <bernat@luffy.cx>
 Vivek Agarwal <me@vivek.im>
-Vladimir Kirillov <proger@wilab.org.ua>
 Walter Stanish <walter@pratyeka.org>
-Wes Morgan <cap10morgan@gmail.com>
 Will Dietz <w@wdtz.org>
-Yang Bai <hamo.by@gmail.com>
-Zaiste! <oh@zaiste.net>
@@ -1,14 +1,7 @@
 # Contributing to Docker

-Want to hack on Docker? Awesome! Here are instructions to get you
-started. They are probably not perfect, please let us know if anything
-feels wrong or incomplete.
-
-## Build Environment
-
-For instructions on setting up your development environment, please
-see our dedicated [dev environment setup
-docs](http://docs.docker.io/en/latest/contributing/devenvironment/).
+Want to hack on Docker? Awesome! Here are instructions to get you started. They are probably not perfect, please let us know if anything feels
+wrong or incomplete.

 ## Contribution guidelines

@@ -62,10 +55,8 @@ Submit unit tests for your changes.  Go has a great test framework built in; use
 it! Take a look at existing tests for inspiration. Run the full test suite on
 your branch before submitting a pull request.

-Update the documentation when creating or modifying features. Test
-your documentation changes for clarity, concision, and correctness, as
-well as a clean docmuent build. See ``docs/README.md`` for more
-information on building the docs and how docs get released.
+Make sure you include relevant updates or additions to documentation when
+creating or modifying features.

 Write clean code. Universally formatted code promotes ease of writing, reading,
 and maintenance. Always run `go fmt` before committing your changes. Most
@@ -98,17 +89,6 @@ name and email address match your git configuration. The AUTHORS file is
 regenerated occasionally from the git commit history, so a mismatch may result
 in your changes being overwritten.

-### Approval
-
-Docker maintainers use LGTM (looks good to me) in comments on the code review
-to indicate acceptance.
-
-A change requires LGTMs from an absolute majority of the maintainers of each
-component affected. For example, if a change affects docs/ and registry/, it
-needs an absolute majority from the maintainers of docs/ AND, separately, an
-absolute majority of the maintainers of registry
-
-For more details see [MAINTAINERS.md](hack/MAINTAINERS.md)

 ### How can I become a maintainer?

@@ -4,26 +4,26 @@
 #
 # # Assemble the full dev environment. This is slow the first time.
 # docker build -t docker .
+# # Apparmor messes with privileged mode: disable it
+# /etc/init.d/apparmor stop ; /etc/init.d/apparmor teardown
 #
 # # Mount your source in an interactive container for quick testing:
-# docker run -v `pwd`:/go/src/github.com/dotcloud/docker -privileged -i -t docker bash
+# docker run -v `pwd`:/go/src/github.com/dotcloud/docker -privileged -lxc-conf=lxc.aa_profile=unconfined -i -t docker bash
+#
 #
 # # Run the test suite:
-# docker run -privileged docker hack/make.sh test
+# docker run -privileged -lxc-conf=lxc.aa_profile=unconfined docker go test -v
 #
 # # Publish a release:
-# docker run -privileged \
+# docker run -privileged -lxc-conf=lxc.aa_profile=unconfined \
 #  -e AWS_S3_BUCKET=baz \
 #  -e AWS_ACCESS_KEY=foo \
 #  -e AWS_SECRET_KEY=bar \
 #  -e GPG_PASSPHRASE=gloubiboulga \
 #  docker hack/release.sh
 #
-# Note: Apparmor used to mess with privileged mode, but this is no longer
-# the case. Therefore, you don't have to disable it anymore.
-#

-docker-version	0.6.1
+docker-version 0.6.1
 from	ubuntu:12.04
 maintainer	Solomon Hykes <solomon@dotcloud.com>

@@ -33,43 +33,34 @@ run	apt-get update
 run	apt-get install -y -q curl
 run	apt-get install -y -q git
 run	apt-get install -y -q mercurial
-run	apt-get install -y -q build-essential libsqlite3-dev
+run apt-get install -y -q build-essential libsqlite3-dev

 # Install Go
-run	curl -s https://go.googlecode.com/files/go1.2rc5.src.tar.gz | tar -v -C /usr/local -xz
+run	curl -s https://go.googlecode.com/files/go1.2rc1.src.tar.gz | tar -v -C /usr/local -xz
+run cd /usr/local/go/src && ./make.bash && go install -ldflags '-w -linkmode external -extldflags "-static -Wl,--unresolved-symbols=ignore-in-shared-libs"' -tags netgo -a std
 env	PATH	/usr/local/go/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
 env	GOPATH	/go:/go/src/github.com/dotcloud/docker/vendor
-run	cd /usr/local/go/src && ./make.bash && go install -ldflags '-w -linkmode external -extldflags "-static -Wl,--unresolved-symbols=ignore-in-shared-libs"' -tags netgo -a std
-
+run	cd /tmp && echo 'package main' > t.go && go test -a -i -v
 # Ubuntu stuff
 run	apt-get install -y -q ruby1.9.3 rubygems libffi-dev
 run	gem install --no-rdoc --no-ri fpm
 run	apt-get install -y -q reprepro dpkg-sig

+# Install s3cmd 1.0.1 (earlier versions don't support env variables in the config)
 run	apt-get install -y -q python-pip
-run	pip install s3cmd==1.1.0-beta3
-run	pip install python-magic==0.4.6
+run	pip install s3cmd
+run	pip install python-magic
 run	/bin/echo -e '[default]\naccess_key=$AWS_ACCESS_KEY\nsecret_key=$AWS_SECRET_KEY\n' > /.s3cfg

 # Runtime dependencies
 run	apt-get install -y -q iptables
 run	apt-get install -y -q lxc
-run	apt-get install -y -q aufs-tools
-
-# Get lvm2 source for compiling statically
-run	git clone git://git.fedorahosted.org/git/lvm2.git /usr/local/lvm2 && cd /usr/local/lvm2 && git checkout v2_02_103
-# see https://git.fedorahosted.org/cgit/lvm2.git/refs/tags for release tags
-# note: we can't use "git clone -b" above because it requires at least git 1.7.10 to be able to use that on a tag instead of a branch and we only have 1.7.9.5
-
-# Compile and install lvm2
-run	cd /usr/local/lvm2 && ./configure --enable-static_link && make device-mapper && make install_device-mapper
-# see https://git.fedorahosted.org/cgit/lvm2.git/tree/INSTALL

 volume	/var/lib/docker
 workdir	/go/src/github.com/dotcloud/docker

 # Wrap all commands in the "docker-in-docker" script to allow nested containers
-entrypoint	["hack/dind"]
+entrypoint ["hack/dind"]

 # Upload docker source
-add	.	/go/src/github.com/dotcloud/docker
+add	.       /go/src/github.com/dotcloud/docker
@@ -15,16 +15,23 @@ to put them - so we put them here :)
 * Run linter on codebase
 * Unify build commands and regular commands
 * Move source code into src/ subdir for clarity
+* Clean up the Makefile, it's a mess
 * docker build: on non-existent local path for ADD, don't show full absolute path on the host
+* mount into /dockerinit rather than /sbin/init
 * docker tag foo REPO:TAG
 * use size header for progress bar in pull
 * Clean up context upload in build!!!
 * Parallel pull
+* Ensure /proc/sys/net/ipv4/ip_forward is 1
+* Force DNS to public!
 * Always generate a resolv.conf per container, to avoid changing resolv.conf under thne container's feet
-* Save metadata with import/export (#1974)
+* Save metadata with import/export
 * Upgrade dockerd without stopping containers
-* Simple command to remove all untagged images (`docker rmi $(docker images | awk '/^<none>/ { print $3 }')`)
+* bring back git revision info, looks like it was lost
+* Simple command to remove all untagged images
 * Simple command to clean up containers for disk space
-* Caching after an ADD (#880)
+* Caching after an ADD
+* entry point config
+* bring back git revision info, looks like it was lost
 * Clean up the ProgressReader api, it's a PITA to use
 * Use netlink instead of iproute2/iptables (#925)
@@ -1,19 +1,43 @@
 Docker
-Copyright 2012-2013 Docker, Inc.
+Copyright 2012-2013 dotCloud, inc.

-This product includes software developed at Docker, Inc. (http://www.docker.com).
+This product includes software developed at dotCloud,
+inc. (http://www.dotcloud.com).

 This product contains software (https://github.com/kr/pty) developed
 by Keith Rarick, licensed under the MIT License.

 The following is courtesy of our legal counsel:

+Transfers of Docker shall be in accordance with applicable export
+controls of any country and all other applicable legal requirements.
+Docker shall not be distributed or downloaded to or in Cuba, Iran,
+North Korea, Sudan or Syria and shall not be distributed or downloaded
+to any person on the Denied Persons List administered by the U.S.
+Department of Commerce.

-Use and transfer of Docker may be subject to certain restrictions by the
-United States and other governments.  
-It is your responsibility to ensure that your use and/or transfer does not
-violate applicable laws. 
+What does that mean? 
+Here is a further explanation from our legal counsel:

-For more information, please see http://www.bis.doc.gov
+Like all software products that utilize cryptography, the export and
+use of Docker is subject to the U.S. Commerce Department's Export
+Administration Regulations (EAR) because it uses or contains
+cryptography (see
+http://www.bis.doc.gov/index.php/policy-guidance/encryption).  Certain
+free and open source software projects have a lightweight set of
+requirements, which can generally be met by providing email notice to
+the appropriate U.S. government agencies that their source code is
+available on a publicly available repository and making the
+appropriate statements in the README.

-See also http://www.apache.org/dev/crypto.html and/or seek legal counsel.
+The restrictions of the EAR apply to certain denied locations
+(currently Iran, Sudan, Syria, North Korea, or Cuba) and those
+individuals on the Denied Persons List, which is available here:
+http://www.bis.doc.gov/index.php/policy-guidance/lists-of-parties-of-concern/denied-persons-list.
+If you are incorporating Docker into a new open source project, the
+EAR restrictions apply to your incorporation of Docker into your
+project in the same manner as other cryptography-enabled projects,
+such as OpenSSL, almost all Linux distributions, etc.
+
+For more information, see http://www.apache.org/dev/crypto.html and/or
+seek legal counsel.
@@ -193,9 +193,10 @@ wrong or incomplete.
 *Brought to you courtesy of our legal counsel. For more context,
 please see the Notice document.*

-Use and transfer of Docker may be subject to certain restrictions by the
-United States and other governments.  
-It is your responsibility to ensure that your use and/or transfer does not
-violate applicable laws. 
+Transfers of Docker shall be in accordance with applicable export
+controls of any country and all other applicable legal requirements.
+Docker shall not be distributed or downloaded to or in Cuba, Iran,
+North Korea, Sudan or Syria and shall not be distributed or downloaded
+to any person on the Denied Persons List administered by the U.S.
+Department of Commerce.

-For more information, please see http://www.bis.doc.gov
@@ -1 +1 @@
-0.7.0-rc7
+0.6.3-dev
@@ -4,135 +4,63 @@
 BOX_NAME = ENV['BOX_NAME'] || "ubuntu"
 BOX_URI = ENV['BOX_URI'] || "http://files.vagrantup.com/precise64.box"
 VF_BOX_URI = ENV['BOX_URI'] || "http://files.vagrantup.com/precise64_vmware_fusion.box"
-AWS_BOX_URI = ENV['BOX_URI'] || "https://github.com/mitchellh/vagrant-aws/raw/master/dummy.box"
 AWS_REGION = ENV['AWS_REGION'] || "us-east-1"
-AWS_AMI = ENV['AWS_AMI'] || "ami-69f5a900"
-AWS_INSTANCE_TYPE = ENV['AWS_INSTANCE_TYPE'] || 't1.micro'
-
+AWS_AMI    = ENV['AWS_AMI']    || "ami-d0f89fb9"
 FORWARD_DOCKER_PORTS = ENV['FORWARD_DOCKER_PORTS']

-SSH_PRIVKEY_PATH = ENV["SSH_PRIVKEY_PATH"]
-
-# A script to upgrade from the 12.04 kernel to the raring backport kernel (3.8)
-# and install docker.
-$script = <<SCRIPT
-# The username to add to the docker group will be passed as the first argument
-# to the script.  If nothing is passed, default to "vagrant".
-user="$1"
-if [ -z "$user" ]; then
-    user=vagrant
-fi
-
-# Adding an apt gpg key is idempotent.
-wget -q -O - https://get.docker.io/gpg | apt-key add -
-
-# Creating the docker.list file is idempotent, but it may overrite desired
-# settings if it already exists.  This could be solved with md5sum but it
-# doesn't seem worth it.
-echo 'deb http://get.docker.io/ubuntu docker main' > \
-    /etc/apt/sources.list.d/docker.list
-
-# Update remote package metadata.  'apt-get update' is idempotent.
-apt-get update -q
-
-# Install docker.  'apt-get install' is idempotent.
-apt-get install -q -y lxc-docker
-
-usermod -a -G docker "$user"
-
-tmp=`mktemp -q` && {
-    # Only install the backport kernel, don't bother upgrade if the backport is
-    # already installed.  We want parse the output of apt so we need to save it
-    # with 'tee'.  NOTE: The installation of the kernel will trigger dkms to
-    # install vboxguest if needed.
-    apt-get install -q -y --no-upgrade linux-image-generic-lts-raring | \
-        tee "$tmp"
-
-    # Parse the number of installed packages from the output
-    NUM_INST=`awk '$2 == "upgraded," && $4 == "newly" { print $3 }' "$tmp"`
-    rm "$tmp"
-}
-
-# If the number of installed packages is greater than 0, we want to reboot (the
-# backport kernel was installed but is not running).
-if [ "$NUM_INST" -gt 0 ];
-then
-    echo "Rebooting down to activate new kernel."
-    echo "/vagrant will not be mounted.  Use 'vagrant halt' followed by"
-    echo "'vagrant up' to ensure /vagrant is mounted."
-    shutdown -r now
-fi
-SCRIPT
-
-# We need to install the virtualbox guest additions *before* we do the normal
-# docker installation.  As such this script is prepended to the common docker
-# install script above.  This allows the install of the backport kernel to
-# trigger dkms to build the virtualbox guest module install.
-$vbox_script = <<VBOX_SCRIPT + $script
-# Install the VirtualBox guest additions if they aren't already installed.
-if [ ! -d /opt/VBoxGuestAdditions-4.3.2/ ]; then
-    # Update remote package metadata.  'apt-get update' is idempotent.
-    apt-get update -q
-
-    # Kernel Headers and dkms are required to build the vbox guest kernel
-    # modules.
-    apt-get install -q -y linux-headers-generic-lts-raring dkms
-
-    echo 'Downloading VBox Guest Additions...'
-    wget -cq http://dlc.sun.com.edgesuite.net/virtualbox/4.3.2/VBoxGuestAdditions_4.3.2.iso
-
-    mount -o loop,ro /home/vagrant/VBoxGuestAdditions_4.3.2.iso /mnt
-    /mnt/VBoxLinuxAdditions.run --nox11
-    umount /mnt
-fi
-VBOX_SCRIPT
-
 Vagrant::Config.run do |config|
  # Setup virtual machine box. This VM configuration code is always executed.
  config.vm.box = BOX_NAME
  config.vm.box_url = BOX_URI

-  # Use the specified private key path if it is specified and not empty.
-  if SSH_PRIVKEY_PATH
-      config.ssh.private_key_path = SSH_PRIVKEY_PATH
-  end
-
  config.ssh.forward_agent = true
+
+  # Provision docker and new kernel if deployment was not done.
+  # It is assumed Vagrant can successfully launch the provider instance.
+  if Dir.glob("#{File.dirname(__FILE__)}/.vagrant/machines/default/*/id").empty?
+    # Add lxc-docker package
+    pkg_cmd = "wget -q -O - https://get.docker.io/gpg | apt-key add -;" \
+      "echo deb http://get.docker.io/ubuntu docker main > /etc/apt/sources.list.d/docker.list;" \
+      "apt-get update -qq; apt-get install -q -y --force-yes lxc-docker; "
+    # Add Ubuntu raring backported kernel
+    pkg_cmd << "apt-get update -qq; apt-get install -q -y linux-image-generic-lts-raring; "
+    # Add guest additions if local vbox VM. As virtualbox is the default provider,
+    # it is assumed it won't be explicitly stated.
+    if ENV["VAGRANT_DEFAULT_PROVIDER"].nil? && ARGV.none? { |arg| arg.downcase.start_with?("--provider") }
+      pkg_cmd << "apt-get install -q -y linux-headers-generic-lts-raring dkms; " \
+        "echo 'Downloading VBox Guest Additions...'; " \
+        "wget -q http://dlc.sun.com.edgesuite.net/virtualbox/4.2.12/VBoxGuestAdditions_4.2.12.iso; "
+      # Prepare the VM to add guest additions after reboot
+      pkg_cmd << "echo -e 'mount -o loop,ro /home/vagrant/VBoxGuestAdditions_4.2.12.iso /mnt\n" \
+        "echo yes | /mnt/VBoxLinuxAdditions.run\numount /mnt\n" \
+          "rm /root/guest_additions.sh; ' > /root/guest_additions.sh; " \
+        "chmod 700 /root/guest_additions.sh; " \
+        "sed -i -E 's#^exit 0#[ -x /root/guest_additions.sh ] \\&\\& /root/guest_additions.sh#' /etc/rc.local; " \
+        "echo 'Installation of VBox Guest Additions is proceeding in the background.'; " \
+        "echo '\"vagrant reload\" can be used in about 2 minutes to activate the new guest additions.'; "
+    end
+    # Activate new kernel
+    pkg_cmd << "shutdown -r +1; "
+    config.vm.provision :shell, :inline => pkg_cmd
+  end
 end

+
 # Providers were added on Vagrant >= 1.1.0
-#
-# NOTE: The vagrant "vm.provision" appends its arguments to a list and executes
-# them in order.  If you invoke "vm.provision :shell, :inline => $script"
-# twice then vagrant will run the script two times.  Unfortunately when you use
-# providers and the override argument to set up provisioners (like the vbox
-# guest extensions) they 1) don't replace the other provisioners (they append
-# to the end of the list) and 2) you can't control the order the provisioners
-# are executed (you can only append to the list).  If you want the virtualbox
-# only script to run before the other script, you have to jump through a lot of
-# hoops.
-#
-# Here is my only repeatable solution: make one script that is common ($script)
-# and another script that is the virtual box guest *prepended* to the common
-# script.  Only ever use "vm.provision" *one time* per provider.  That means
-# every single provider has an override, and every single one configures
-# "vm.provision".  Much saddness, but such is life.
 Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
  config.vm.provider :aws do |aws, override|
-    username = "ubuntu"
-    override.vm.box_url = AWS_BOX_URI
-    override.vm.provision :shell, :inline => $script, :args => username
-    aws.access_key_id = ENV["AWS_ACCESS_KEY"]
-    aws.secret_access_key = ENV["AWS_SECRET_KEY"]
+    aws.access_key_id = ENV["AWS_ACCESS_KEY_ID"]
+    aws.secret_access_key = ENV["AWS_SECRET_ACCESS_KEY"]
    aws.keypair_name = ENV["AWS_KEYPAIR_NAME"]
-    override.ssh.username = username
+    override.ssh.private_key_path = ENV["AWS_SSH_PRIVKEY"]
+    override.ssh.username = "ubuntu"
    aws.region = AWS_REGION
    aws.ami    = AWS_AMI
-    aws.instance_type = AWS_INSTANCE_TYPE
+    aws.instance_type = "t1.micro"
  end

-  config.vm.provider :rackspace do |rs, override|
-    override.vm.provision :shell, :inline => $script
+  config.vm.provider :rackspace do |rs|
+    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"]
@@ -141,25 +69,18 @@ Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
  end

  config.vm.provider :vmware_fusion do |f, override|
+    override.vm.box = BOX_NAME
    override.vm.box_url = VF_BOX_URI
    override.vm.synced_folder ".", "/vagrant", disabled: true
-    override.vm.provision :shell, :inline => $script
    f.vmx["displayName"] = "docker"
  end

-  config.vm.provider :virtualbox do |vb, override|
-    override.vm.provision :shell, :inline => $vbox_script
-    vb.customize ["modifyvm", :id, "--natdnshostresolver1", "on"]
-    vb.customize ["modifyvm", :id, "--natdnsproxy1", "on"]
+  config.vm.provider :virtualbox do |vb|
+    config.vm.box = BOX_NAME
+    config.vm.box_url = BOX_URI
  end
 end

-# If this is a version 1 config, virtualbox is the only option.  A version 2
-# config would have already been set in the above provider section.
-Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|
-  config.vm.provision :shell, :inline => $vbox_script
-end
-
 if !FORWARD_DOCKER_PORTS.nil?
  Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|
    (49000..49900).each do |port|
@@ -5,8 +5,8 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"github.com/dotcloud/docker/archive"
 	"github.com/dotcloud/docker/auth"
+	"github.com/dotcloud/docker/gograph"
 	"github.com/dotcloud/docker/utils"
 	"github.com/gorilla/mux"
 	"io"
@@ -15,6 +15,7 @@ import (
 	"mime"
 	"net"
 	"net/http"
+	"net/url"
 	"os"
 	"os/exec"
 	"regexp"
@@ -23,7 +24,7 @@ import (
 )

 const (
-	APIVERSION        = 1.7
+	APIVERSION        = 1.6
 	DEFAULTHTTPHOST   = "127.0.0.1"
 	DEFAULTHTTPPORT   = 4243
 	DEFAULTUNIXSOCKET = "/var/run/docker.sock"
@@ -43,9 +44,6 @@ func hijackServer(w http.ResponseWriter) (io.ReadCloser, io.Writer, error) {

 //If we don't do this, POST method without Content-type (even with empty body) will fail
 func parseForm(r *http.Request) error {
-	if r == nil {
-		return nil
-	}
 	if err := r.ParseForm(); err != nil && !strings.HasPrefix(err.Error(), "mime:") {
 		return err
 	}
@@ -61,10 +59,7 @@ func parseMultipartForm(r *http.Request) error {

 func httpError(w http.ResponseWriter, err error) {
 	statusCode := http.StatusInternalServerError
-	// FIXME: this is brittle and should not be necessary.
-	// If we need to differentiate between different possible error types, we should
-	// create appropriate error types with clearly defined meaning.
-	if strings.Contains(err.Error(), "No such") {
+	if strings.HasPrefix(err.Error(), "No such") {
 		statusCode = http.StatusNotFound
 	} else if strings.HasPrefix(err.Error(), "Bad parameter") {
 		statusCode = http.StatusBadRequest
@@ -77,11 +72,8 @@ func httpError(w http.ResponseWriter, err error) {
 	} else if strings.Contains(err.Error(), "hasn't been activated") {
 		statusCode = http.StatusForbidden
 	}
-
-	if err != nil {
-		utils.Errorf("HTTP Error: statusCode=%d %s", statusCode, err.Error())
-		http.Error(w, err.Error(), statusCode)
-	}
+	utils.Debugf("[error %d] %s", statusCode, err)
+	http.Error(w, err.Error(), statusCode)
 }

 func writeJSON(w http.ResponseWriter, code int, v interface{}) error {
@@ -112,7 +104,7 @@ func getBoolParam(value string) (bool, error) {
 func matchesContentType(contentType, expectedType string) bool {
 	mimetype, _, err := mime.ParseMediaType(contentType)
 	if err != nil {
-		utils.Errorf("Error parsing media type: %s error: %s", contentType, err.Error())
+		utils.Debugf("Error parsing media type: %s error: %s", contentType, err.Error())
 	}
 	return err == nil && mimetype == expectedType
 }
@@ -142,22 +134,9 @@ func postContainersKill(srv *Server, version float64, w http.ResponseWriter, r *
 	if vars == nil {
 		return fmt.Errorf("Missing parameter")
 	}
-	if err := parseForm(r); err != nil {
-		return err
-	}
 	name := vars["name"]
-
-	signal := 0
-	if r != nil {
-		if s := r.Form.Get("signal"); s != "" {
-			s, err := strconv.Atoi(s)
-			if err != nil {
-				return err
-			}
-			signal = s
-		}
-	}
-	if err := srv.ContainerKill(name, signal); err != nil {
+	name = decodeName(name)
+	if err := srv.ContainerKill(name); err != nil {
 		return err
 	}
 	w.WriteHeader(http.StatusNoContent)
@@ -169,9 +148,10 @@ func getContainersExport(srv *Server, version float64, w http.ResponseWriter, r
 		return fmt.Errorf("Missing parameter")
 	}
 	name := vars["name"]
+	name = decodeName(name)

 	if err := srv.ContainerExport(name, w); err != nil {
-		utils.Errorf("%s", err)
+		utils.Debugf("%s", err)
 		return err
 	}
 	return nil
@@ -193,23 +173,10 @@ func getImagesJSON(srv *Server, version float64, w http.ResponseWriter, r *http.
 		return err
 	}

-	if version < 1.7 {
-		outs2 := []APIImagesOld{}
-		for _, ctnr := range outs {
-			outs2 = append(outs2, ctnr.ToLegacy()...)
-		}
-
-		return writeJSON(w, http.StatusOK, outs2)
-	}
 	return writeJSON(w, http.StatusOK, outs)
 }

 func getImagesViz(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if version > 1.6 {
-		w.WriteHeader(http.StatusNotFound)
-		return fmt.Errorf("This is now implemented in the client.")
-	}
-
 	if err := srv.ImagesViz(w); err != nil {
 		return err
 	}
@@ -229,7 +196,7 @@ func getEvents(srv *Server, version float64, w http.ResponseWriter, r *http.Requ
 		_, err = wf.Write(b)
 		if err != nil {
 			// On error, evict the listener
-			utils.Errorf("%s", err)
+			utils.Debugf("%s", err)
 			srv.Lock()
 			delete(srv.listeners, r.RemoteAddr)
 			srv.Unlock()
@@ -251,7 +218,6 @@ func getEvents(srv *Server, version float64, w http.ResponseWriter, r *http.Requ
 	}
 	w.Header().Set("Content-Type", "application/json")
 	wf := utils.NewWriteFlusher(w)
-	wf.Flush()
 	if since != 0 {
 		// If since, send previous events that happened after the timestamp
 		for _, event := range srv.events {
@@ -314,10 +280,13 @@ func getContainersTop(srv *Server, version float64, w http.ResponseWriter, r *ht
 	if err := parseForm(r); err != nil {
 		return err
 	}
-	procsStr, err := srv.ContainerTop(vars["name"], r.Form.Get("ps_args"))
+	name := vars["name"]
+	ps_args := r.Form.Get("ps_args")
+	procsStr, err := srv.ContainerTop(name, ps_args)
 	if err != nil {
 		return err
 	}
+
 	return writeJSON(w, http.StatusOK, procsStr)
 }

@@ -345,12 +314,13 @@ func getContainersJSON(srv *Server, version float64, w http.ResponseWriter, r *h
 	if version < 1.5 {
 		outs2 := []APIContainersOld{}
 		for _, ctnr := range outs {
-			outs2 = append(outs2, *ctnr.ToLegacy())
+			outs2 = append(outs2, ctnr.ToLegacy())
 		}

 		return writeJSON(w, http.StatusOK, outs2)
+	} else {
+		return writeJSON(w, http.StatusOK, outs)
 	}
-	return writeJSON(w, http.StatusOK, outs)
 }

 func postImagesTag(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -380,8 +350,8 @@ func postCommit(srv *Server, version float64, w http.ResponseWriter, r *http.Req
 		return err
 	}
 	config := &Config{}
-	if err := json.NewDecoder(r.Body).Decode(config); err != nil && err != io.EOF {
-		utils.Errorf("%s", err)
+	if err := json.NewDecoder(r.Body).Decode(config); err != nil {
+		utils.Debugf("%s", err)
 	}
 	repo := r.Form.Get("repo")
 	tag := r.Form.Get("tag")
@@ -476,16 +446,15 @@ func postImagesInsert(srv *Server, version float64, w http.ResponseWriter, r *ht
 		w.Header().Set("Content-Type", "application/json")
 	}
 	sf := utils.NewStreamFormatter(version > 1.0)
-	err := srv.ImageInsert(name, url, path, w, sf)
+	imgID, err := srv.ImageInsert(name, url, path, w, sf)
 	if err != nil {
 		if sf.Used() {
 			w.Write(sf.FormatError(err))
 			return nil
 		}
-		return err
 	}

-	return nil
+	return writeJSON(w, http.StatusOK, &APIID{ID: imgID})
 }

 func postImagesPush(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -534,52 +503,43 @@ func postImagesPush(srv *Server, version float64, w http.ResponseWriter, r *http
 	return nil
 }

-func getImagesGet(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	name := vars["name"]
-	if version > 1.0 {
-		w.Header().Set("Content-Type", "application/x-tar")
-	}
-	return srv.ImageExport(name, w)
-}
-
-func postImagesLoad(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	return srv.ImageLoad(r.Body)
-}
-
 func postContainersCreate(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := parseForm(r); err != nil {
-		return nil
-	}
+	config := &Config{}
 	out := &APIRun{}
-	job := srv.Eng.Job("create", r.Form.Get("name"))
-	if err := job.DecodeEnv(r.Body); err != nil {
+
+	if err := json.NewDecoder(r.Body).Decode(config); err != nil {
 		return err
 	}
+
 	resolvConf, err := utils.GetResolvConf()
 	if err != nil {
 		return err
 	}
-	if !job.GetenvBool("NetworkDisabled") && len(job.Getenv("Dns")) == 0 && len(srv.runtime.config.Dns) == 0 && utils.CheckLocalDns(resolvConf) {
+
+	if !config.NetworkDisabled && len(config.Dns) == 0 && len(srv.runtime.config.Dns) == 0 && utils.CheckLocalDns(resolvConf) {
 		out.Warnings = append(out.Warnings, fmt.Sprintf("Docker detected local DNS server on resolv.conf. Using default external servers: %v", defaultDns))
-		job.SetenvList("Dns", defaultDns)
+		config.Dns = defaultDns
 	}
-	// Read container ID from the first line of stdout
-	job.StdoutParseString(&out.ID)
-	// Read warnings from stderr
-	job.StderrParseLines(&out.Warnings, 0)
-	if err := job.Run(); err != nil {
+
+	id, warnings, err := srv.ContainerCreate(config)
+	if err != nil {
 		return err
 	}
-	if job.GetenvInt("Memory") > 0 && !srv.runtime.capabilities.MemoryLimit {
+	out.ID = id
+	for _, warning := range warnings {
+		out.Warnings = append(out.Warnings, warning)
+	}
+
+	if config.Memory > 0 && !srv.runtime.capabilities.MemoryLimit {
 		log.Println("WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.")
 		out.Warnings = append(out.Warnings, "Your kernel does not support memory limit capabilities. Limitation discarded.")
 	}
-	if job.GetenvInt("Memory") > 0 && !srv.runtime.capabilities.SwapLimit {
+	if config.Memory > 0 && !srv.runtime.capabilities.SwapLimit {
 		log.Println("WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.")
 		out.Warnings = append(out.Warnings, "Your kernel does not support memory swap capabilities. Limitation discarded.")
 	}

-	if !job.GetenvBool("NetworkDisabled") && srv.runtime.capabilities.IPv4ForwardingDisabled {
+	if !config.NetworkDisabled && srv.runtime.capabilities.IPv4ForwardingDisabled {
 		log.Println("Warning: IPv4 forwarding is disabled.")
 		out.Warnings = append(out.Warnings, "IPv4 forwarding is disabled.")
 	}
@@ -599,6 +559,7 @@ func postContainersRestart(srv *Server, version float64, w http.ResponseWriter,
 		return fmt.Errorf("Missing parameter")
 	}
 	name := vars["name"]
+	name = decodeName(name)
 	if err := srv.ContainerRestart(name, t); err != nil {
 		return err
 	}
@@ -614,6 +575,7 @@ func deleteContainers(srv *Server, version float64, w http.ResponseWriter, r *ht
 		return fmt.Errorf("Missing parameter")
 	}
 	name := vars["name"]
+	name = decodeName(name)

 	removeVolume, err := getBoolParam(r.Form.Get("v"))
 	if err != nil {
@@ -646,28 +608,37 @@ func deleteImages(srv *Server, version float64, w http.ResponseWriter, r *http.R
 	if imgs != nil {
 		if len(imgs) != 0 {
 			return writeJSON(w, http.StatusOK, imgs)
+		} else {
+			return fmt.Errorf("Conflict, %s wasn't deleted", name)
 		}
-		return fmt.Errorf("Conflict, %s wasn't deleted", name)
+	} else {
+		w.WriteHeader(http.StatusNoContent)
 	}
-	w.WriteHeader(http.StatusNoContent)
 	return nil
 }

 func postContainersStart(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if vars == nil {
-		return fmt.Errorf("Missing parameter")
-	}
-	name := vars["name"]
-	job := srv.Eng.Job("start", name)
+	var hostConfig *HostConfig
 	// allow a nil body for backwards compatibility
 	if r.Body != nil {
 		if matchesContentType(r.Header.Get("Content-Type"), "application/json") {
-			if err := job.DecodeEnv(r.Body); err != nil {
+			hostConfig = &HostConfig{}
+			if err := json.NewDecoder(r.Body).Decode(hostConfig); err != nil {
 				return err
 			}
 		}
 	}
-	if err := job.Run(); err != nil {
+
+	if vars == nil {
+		return fmt.Errorf("Missing parameter")
+	}
+	var err error
+	name := vars["name"]
+	name = decodeName(name)
+	if err != nil {
+		return err
+	}
+	if err := srv.ContainerStart(name, hostConfig); err != nil {
 		return err
 	}
 	w.WriteHeader(http.StatusNoContent)
@@ -687,6 +658,7 @@ func postContainersStop(srv *Server, version float64, w http.ResponseWriter, r *
 		return fmt.Errorf("Missing parameter")
 	}
 	name := vars["name"]
+	name = decodeName(name)

 	if err := srv.ContainerStop(name, t); err != nil {
 		return err
@@ -700,6 +672,7 @@ func postContainersWait(srv *Server, version float64, w http.ResponseWriter, r *
 		return fmt.Errorf("Missing parameter")
 	}
 	name := vars["name"]
+	name = decodeName(name)

 	status, err := srv.ContainerWait(name)
 	if err != nil {
@@ -760,6 +733,7 @@ func postContainersAttach(srv *Server, version float64, w http.ResponseWriter, r
 		return fmt.Errorf("Missing parameter")
 	}
 	name := vars["name"]
+	name = decodeName(name)

 	c, err := srv.ContainerInspect(name)
 	if err != nil {
@@ -841,7 +815,7 @@ func wsContainersAttach(srv *Server, version float64, w http.ResponseWriter, r *
 		defer ws.Close()

 		if err := srv.ContainerAttach(name, logs, stream, stdin, stdout, stderr, ws, ws, ws); err != nil {
-			utils.Errorf("Error: %s", err)
+			utils.Debugf("Error: %s", err)
 		}
 	})
 	h.ServeHTTP(w, r)
@@ -916,7 +890,7 @@ func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Requ
 			return fmt.Errorf("Error trying to use git: %s (%s)", err, output)
 		}

-		c, err := archive.Tar(root, archive.Bzip2)
+		c, err := Tar(root, Bzip2)
 		if err != nil {
 			return err
 		}
@@ -931,7 +905,7 @@ func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Requ
 		if err != nil {
 			return err
 		}
-		c, err := MkBuildContext(string(dockerFile), nil)
+		c, err := mkBuildContext(string(dockerFile), nil)
 		if err != nil {
 			return err
 		}
@@ -954,7 +928,8 @@ func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Requ
 	b := NewBuildFile(srv, utils.NewWriteFlusher(w), !suppressOutput, !noCache, rm)
 	id, err := b.Build(context)
 	if err != nil {
-		return fmt.Errorf("Error build: %s", err)
+		fmt.Fprintf(w, "Error build: %s\n", err)
+		return err
 	}
 	if repoName != "" {
 		srv.runtime.repositories.Set(repoName, tag, id, false)
@@ -979,14 +954,14 @@ func postContainersCopy(srv *Server, version float64, w http.ResponseWriter, r *
 	}

 	if copyData.Resource == "" {
-		return fmt.Errorf("Path cannot be empty")
+		return fmt.Errorf("Resource cannot be empty")
 	}
 	if copyData.Resource[0] == '/' {
 		copyData.Resource = copyData.Resource[1:]
 	}

 	if err := srv.ContainerCopy(name, copyData.Resource, w); err != nil {
-		utils.Errorf("%s", err.Error())
+		utils.Debugf("%s", err.Error())
 		return err
 	}
 	return nil
@@ -1031,12 +1006,69 @@ func makeHttpHandler(srv *Server, logging bool, localMethod string, localRoute s
 		}

 		if err := handlerFunc(srv, version, w, r, mux.Vars(r)); err != nil {
-			utils.Errorf("Error: %s", err)
+			utils.Debugf("Error: %s", err)
 			httpError(w, err)
 		}
 	}
 }

+func getContainersLinks(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
+	runtime := srv.runtime
+
+	out := []APILink{}
+	err := runtime.containerGraph.Walk("/", func(p string, e *gograph.Entity) error {
+		if container := runtime.Get(e.ID()); container != nil {
+			out = append(out, APILink{
+				Path:        p,
+				ContainerID: container.ID,
+				Image:       runtime.repositories.ImageName(container.Image),
+			})
+		}
+		return nil
+	}, -1)
+	if err != nil {
+		return err
+	}
+	return writeJSON(w, http.StatusOK, out)
+}
+
+func postContainerLink(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
+	if vars == nil {
+		return fmt.Errorf("Missing parameter")
+	}
+	values := make(map[string]string)
+	if matchesContentType(r.Header.Get("Content-Type"), "application/json") && r.Body != nil {
+		defer r.Body.Close()
+
+		dec := json.NewDecoder(r.Body)
+		if err := dec.Decode(&values); err != nil {
+			return err
+		}
+	} else {
+		return fmt.Errorf("Invalid json body")
+	}
+	currentName := values["currentName"]
+	newName := values["newName"]
+
+	if currentName == "" {
+		return fmt.Errorf("currentName cannot be empty")
+	}
+	if newName == "" {
+		return fmt.Errorf("newName cannot be empty")
+	}
+
+	if err := srv.runtime.RenameLink(currentName, newName); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func decodeName(name string) string {
+	s, _ := url.QueryUnescape(name)
+	return s
+}
+
 func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 	r := mux.NewRouter()

@@ -1048,7 +1080,6 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			"/images/json":                    getImagesJSON,
 			"/images/viz":                     getImagesViz,
 			"/images/search":                  getImagesSearch,
-			"/images/{name:.*}/get":           getImagesGet,
 			"/images/{name:.*}/history":       getImagesHistory,
 			"/images/{name:.*}/json":          getImagesByName,
 			"/containers/ps":                  getContainersJSON,
@@ -1058,6 +1089,7 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			"/containers/{name:.*}/json":      getContainersByName,
 			"/containers/{name:.*}/top":       getContainersTop,
 			"/containers/{name:.*}/attach/ws": wsContainersAttach,
+			"/containers/links":               getContainersLinks,
 		},
 		"POST": {
 			"/auth":                         postAuth,
@@ -1065,7 +1097,6 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			"/build":                        postBuild,
 			"/images/create":                postImagesCreate,
 			"/images/{name:.*}/insert":      postImagesInsert,
-			"/images/load":                  postImagesLoad,
 			"/images/{name:.*}/push":        postImagesPush,
 			"/images/{name:.*}/tag":         postImagesTag,
 			"/containers/create":            postContainersCreate,
@@ -1077,6 +1108,7 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			"/containers/{name:.*}/resize":  postContainersResize,
 			"/containers/{name:.*}/attach":  postContainersAttach,
 			"/containers/{name:.*}/copy":    postContainersCopy,
+			"/containers/link":              postContainerLink,
 		},
 		"DELETE": {
 			"/containers/{name:.*}": deleteContainers,
@@ -1111,20 +1143,6 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 	return r, nil
 }

-// ServeRequest processes a single http request to the docker remote api.
-// FIXME: refactor this to be part of Server and not require re-creating a new
-// router each time. This requires first moving ListenAndServe into Server.
-func ServeRequest(srv *Server, apiversion float64, w http.ResponseWriter, req *http.Request) error {
-	router, err := createRouter(srv, false)
-	if err != nil {
-		return err
-	}
-	// Insert APIVERSION into the request as a convenience
-	req.URL.Path = fmt.Sprintf("/v%g%s", apiversion, req.URL.Path)
-	router.ServeHTTP(w, req)
-	return nil
-}
-
 func ListenAndServe(proto, addr string, srv *Server, logging bool) error {
 	log.Printf("Listening for HTTP on %s (%s)\n", addr, proto)

@@ -1,150 +1,129 @@
 package docker

-import "strings"
-
-type (
-	APIHistory struct {
-		ID        string   `json:"Id"`
-		Tags      []string `json:",omitempty"`
-		Created   int64
-		CreatedBy string `json:",omitempty"`
-		Size      int64
-	}
-
-	APIImages struct {
-		ID          string   `json:"Id"`
-		RepoTags    []string `json:",omitempty"`
-		Created     int64
-		Size        int64
-		VirtualSize int64
-		ParentId    string `json:",omitempty"`
-	}
-
-	APIImagesOld struct {
-		Repository  string `json:",omitempty"`
-		Tag         string `json:",omitempty"`
-		ID          string `json:"Id"`
-		Created     int64
-		Size        int64
-		VirtualSize int64
-	}
-
-	APIInfo struct {
-		Debug              bool
-		Containers         int
-		Images             int
-		Driver             string      `json:",omitempty"`
-		DriverStatus       [][2]string `json:",omitempty"`
-		NFd                int         `json:",omitempty"`
-		NGoroutines        int         `json:",omitempty"`
-		MemoryLimit        bool        `json:",omitempty"`
-		SwapLimit          bool        `json:",omitempty"`
-		IPv4Forwarding     bool        `json:",omitempty"`
-		LXCVersion         string      `json:",omitempty"`
-		NEventsListener    int         `json:",omitempty"`
-		KernelVersion      string      `json:",omitempty"`
-		IndexServerAddress string      `json:",omitempty"`
-	}
-
-	APITop struct {
-		Titles    []string
-		Processes [][]string
-	}
-
-	APIRmi struct {
-		Deleted  string `json:",omitempty"`
-		Untagged string `json:",omitempty"`
-	}
-
-	APIContainers struct {
-		ID         string `json:"Id"`
-		Image      string
-		Command    string
-		Created    int64
-		Status     string
-		Ports      []APIPort
-		SizeRw     int64
-		SizeRootFs int64
-		Names      []string
-	}
-
-	APIContainersOld struct {
-		ID         string `json:"Id"`
-		Image      string
-		Command    string
-		Created    int64
-		Status     string
-		Ports      string
-		SizeRw     int64
-		SizeRootFs int64
-	}
-
-	APIID struct {
-		ID string `json:"Id"`
-	}
-
-	APIRun struct {
-		ID       string   `json:"Id"`
-		Warnings []string `json:",omitempty"`
-	}
-
-	APIPort struct {
-		PrivatePort int64
-		PublicPort  int64
-		Type        string
-		IP          string
-	}
-
-	APIVersion struct {
-		Version   string
-		GitCommit string `json:",omitempty"`
-		GoVersion string `json:",omitempty"`
-	}
-
-	APIWait struct {
-		StatusCode int
-	}
-
-	APIAuth struct {
-		Status string
-	}
-
-	APIImageConfig struct {
-		ID string `json:"Id"`
-		*Config
-	}
-
-	APICopy struct {
-		Resource string
-		HostPath string
-	}
-)
-
-func (api APIImages) ToLegacy() []APIImagesOld {
-	outs := []APIImagesOld{}
-	for _, repotag := range api.RepoTags {
-		components := strings.SplitN(repotag, ":", 2)
-		outs = append(outs, APIImagesOld{
-			ID:          api.ID,
-			Repository:  components[0],
-			Tag:         components[1],
-			Created:     api.Created,
-			Size:        api.Size,
-			VirtualSize: api.VirtualSize,
-		})
-	}
-	return outs
+type APIHistory struct {
+	ID        string   `json:"Id"`
+	Tags      []string `json:",omitempty"`
+	Created   int64
+	CreatedBy string `json:",omitempty"`
 }

-func (api APIContainers) ToLegacy() *APIContainersOld {
-	return &APIContainersOld{
-		ID:         api.ID,
-		Image:      api.Image,
-		Command:    api.Command,
-		Created:    api.Created,
-		Status:     api.Status,
-		Ports:      displayablePorts(api.Ports),
-		SizeRw:     api.SizeRw,
-		SizeRootFs: api.SizeRootFs,
+type APIImages struct {
+	Repository  string `json:",omitempty"`
+	Tag         string `json:",omitempty"`
+	ID          string `json:"Id"`
+	Created     int64
+	Size        int64
+	VirtualSize int64
+}
+
+type APIInfo struct {
+	Debug              bool
+	Containers         int
+	Images             int
+	NFd                int    `json:",omitempty"`
+	NGoroutines        int    `json:",omitempty"`
+	MemoryLimit        bool   `json:",omitempty"`
+	SwapLimit          bool   `json:",omitempty"`
+	IPv4Forwarding     bool   `json:",omitempty"`
+	LXCVersion         string `json:",omitempty"`
+	NEventsListener    int    `json:",omitempty"`
+	KernelVersion      string `json:",omitempty"`
+	IndexServerAddress string `json:",omitempty"`
+}
+
+type APITop struct {
+	Titles    []string
+	Processes [][]string
+}
+
+type APIRmi struct {
+	Deleted  string `json:",omitempty"`
+	Untagged string `json:",omitempty"`
+}
+
+type APIContainers struct {
+	ID         string `json:"Id"`
+	Image      string
+	Command    string
+	Created    int64
+	Status     string
+	Ports      []APIPort
+	SizeRw     int64
+	SizeRootFs int64
+	Names      []string
+}
+
+func (self *APIContainers) ToLegacy() APIContainersOld {
+	return APIContainersOld{
+		ID:         self.ID,
+		Image:      self.Image,
+		Command:    self.Command,
+		Created:    self.Created,
+		Status:     self.Status,
+		Ports:      displayablePorts(self.Ports),
+		SizeRw:     self.SizeRw,
+		SizeRootFs: self.SizeRootFs,
 	}
 }
+
+type APIContainersOld struct {
+	ID         string `json:"Id"`
+	Image      string
+	Command    string
+	Created    int64
+	Status     string
+	Ports      string
+	SizeRw     int64
+	SizeRootFs int64
+}
+
+type APISearch struct {
+	Name        string
+	Description string
+}
+
+type APIID struct {
+	ID string `json:"Id"`
+}
+
+type APIRun struct {
+	ID       string   `json:"Id"`
+	Warnings []string `json:",omitempty"`
+}
+
+type APIPort struct {
+	PrivatePort int64
+	PublicPort  int64
+	Type        string
+	IP          string
+}
+
+type APIVersion struct {
+	Version   string
+	GitCommit string `json:",omitempty"`
+	GoVersion string `json:",omitempty"`
+}
+
+type APIWait struct {
+	StatusCode int
+}
+
+type APIAuth struct {
+	Status string
+}
+
+type APIImageConfig struct {
+	ID string `json:"Id"`
+	*Config
+}
+
+type APICopy struct {
+	Resource string
+	HostPath string
+}
+
+type APILink struct {
+	Path        string
+	ContainerID string
+	Image       string
+}
@@ -1,19 +0,0 @@
-package docker
-
-import (
-	"testing"
-)
-
-func TestJsonContentType(t *testing.T) {
-	if !matchesContentType("application/json", "application/json") {
-		t.Fail()
-	}
-
-	if !matchesContentType("application/json; charset=utf-8", "application/json") {
-		t.Fail()
-	}
-
-	if matchesContentType("dockerapplication/json", "application/json") {
-		t.Fail()
-	}
-}
@@ -1,4 +1,4 @@
-package archive
+package docker

 import (
 	"archive/tar"
@@ -15,15 +15,7 @@ import (

 type Archive io.Reader

-type Compression int
-
-type TarOptions struct {
-	Includes    []string
-	Excludes    []string
-	Recursive   bool
-	Compression Compression
-	CreateFiles []string
-}
+type Compression uint32

 const (
 	Uncompressed Compression = iota
@@ -88,78 +80,20 @@ func (compression *Compression) Extension() string {
 // Tar creates an archive from the directory at `path`, and returns it as a
 // stream of bytes.
 func Tar(path string, compression Compression) (io.Reader, error) {
-	return TarFilter(path, &TarOptions{Recursive: true, Compression: compression})
-}
-
-func escapeName(name string) string {
-	escaped := make([]byte, 0)
-	for i, c := range []byte(name) {
-		if i == 0 && c == '/' {
-			continue
-		}
-		// all printable chars except "-" which is 0x2d
-		if (0x20 <= c && c <= 0x7E) && c != 0x2d {
-			escaped = append(escaped, c)
-		} else {
-			escaped = append(escaped, fmt.Sprintf("\\%03o", c)...)
-		}
-	}
-	return string(escaped)
+	return TarFilter(path, compression, nil)
 }

 // Tar creates an archive from the directory at `path`, only including files whose relative
 // paths are included in `filter`. If `filter` is nil, then all files are included.
-func TarFilter(path string, options *TarOptions) (io.Reader, error) {
-	args := []string{"tar", "--numeric-owner", "-f", "-", "-C", path, "-T", "-"}
-	if options.Includes == nil {
-		options.Includes = []string{"."}
+func TarFilter(path string, compression Compression, filter []string) (io.Reader, error) {
+	args := []string{"tar", "--numeric-owner", "-f", "-", "-C", path}
+	if filter == nil {
+		filter = []string{"."}
 	}
-	args = append(args, "-c"+options.Compression.Flag())
-
-	for _, exclude := range options.Excludes {
-		args = append(args, fmt.Sprintf("--exclude=%s", exclude))
+	for _, f := range filter {
+		args = append(args, "-c"+compression.Flag(), f)
 	}
-
-	if !options.Recursive {
-		args = append(args, "--no-recursion")
-	}
-
-	files := ""
-	for _, f := range options.Includes {
-		files = files + escapeName(f) + "\n"
-	}
-
-	tmpDir := ""
-
-	if options.CreateFiles != nil {
-		var err error // Can't use := here or we override the outer tmpDir
-		tmpDir, err = ioutil.TempDir("", "docker-tar")
-		if err != nil {
-			return nil, err
-		}
-
-		files = files + "-C" + tmpDir + "\n"
-		for _, f := range options.CreateFiles {
-			path := filepath.Join(tmpDir, f)
-			err := os.MkdirAll(filepath.Dir(path), 0600)
-			if err != nil {
-				return nil, err
-			}
-
-			if file, err := os.OpenFile(path, os.O_CREATE, 0600); err != nil {
-				return nil, err
-			} else {
-				file.Close()
-			}
-			files = files + escapeName(f) + "\n"
-		}
-	}
-
-	return CmdStream(exec.Command(args[0], args[1:]...), &files, func() {
-		if tmpDir != "" {
-			_ = os.RemoveAll(tmpDir)
-		}
-	})
+	return CmdStream(exec.Command(args[0], args[1:]...))
 }

 // Untar reads a stream of bytes from `archive`, parses it as a tar archive,
@@ -167,7 +101,7 @@ func TarFilter(path string, options *TarOptions) (io.Reader, error) {
 // The archive may be compressed with one of the following algorithms:
 //  identity (uncompressed), gzip, bzip2, xz.
 // FIXME: specify behavior when target path exists vs. doesn't exist.
-func Untar(archive io.Reader, path string, options *TarOptions) error {
+func Untar(archive io.Reader, path string) error {
 	if archive == nil {
 		return fmt.Errorf("Empty archive")
 	}
@@ -175,29 +109,21 @@ func Untar(archive io.Reader, path string, options *TarOptions) error {
 	buf := make([]byte, 10)
 	totalN := 0
 	for totalN < 10 {
-		n, err := archive.Read(buf[totalN:])
-		if err != nil {
+		if n, err := archive.Read(buf[totalN:]); err != nil {
 			if err == io.EOF {
 				return fmt.Errorf("Tarball too short")
 			}
 			return err
+		} else {
+			totalN += n
+			utils.Debugf("[tar autodetect] n: %d", n)
 		}
-		totalN += n
-		utils.Debugf("[tar autodetect] n: %d", n)
 	}
-
 	compression := DetectCompression(buf)

 	utils.Debugf("Archive compression detected: %s", compression.Extension())
-	args := []string{"--numeric-owner", "-f", "-", "-C", path, "-x" + compression.Flag()}

-	if options != nil {
-		for _, exclude := range options.Excludes {
-			args = append(args, fmt.Sprintf("--exclude=%s", exclude))
-		}
-	}
-
-	cmd := exec.Command("tar", args...)
+	cmd := exec.Command("tar", "--numeric-owner", "-f", "-", "-C", path, "-x"+compression.Flag())
 	cmd.Stdin = io.MultiReader(bytes.NewReader(buf), archive)
 	// Hardcode locale environment for predictable outcome regardless of host configuration.
 	//   (see https://github.com/dotcloud/docker/issues/355)
@@ -214,11 +140,11 @@ func Untar(archive io.Reader, path string, options *TarOptions) error {
 // TarUntar aborts and returns the error.
 func TarUntar(src string, filter []string, dst string) error {
 	utils.Debugf("TarUntar(%s %s %s)", src, filter, dst)
-	archive, err := TarFilter(src, &TarOptions{Compression: Uncompressed, Includes: filter, Recursive: true})
+	archive, err := TarFilter(src, Uncompressed, filter)
 	if err != nil {
 		return err
 	}
-	return Untar(archive, dst, nil)
+	return Untar(archive, dst)
 }

 // UntarPath is a convenience function which looks for an archive
@@ -226,7 +152,7 @@ func TarUntar(src string, filter []string, dst string) error {
 func UntarPath(src, dst string) error {
 	if archive, err := os.Open(src); err != nil {
 		return err
-	} else if err := Untar(archive, dst, nil); err != nil {
+	} else if err := Untar(archive, dst); err != nil {
 		return err
 	}
 	return nil
@@ -295,39 +221,19 @@ func CopyFileWithTar(src, dst string) error {
 		return err
 	}
 	tw.Close()
-	return Untar(buf, filepath.Dir(dst), nil)
+	return Untar(buf, filepath.Dir(dst))
 }

 // CmdStream executes a command, and returns its stdout as a stream.
 // If the command fails to run or doesn't complete successfully, an error
 // will be returned, including anything written on stderr.
-func CmdStream(cmd *exec.Cmd, input *string, atEnd func()) (io.Reader, error) {
-	if input != nil {
-		stdin, err := cmd.StdinPipe()
-		if err != nil {
-			if atEnd != nil {
-				atEnd()
-			}
-			return nil, err
-		}
-		// Write stdin if any
-		go func() {
-			_, _ = stdin.Write([]byte(*input))
-			stdin.Close()
-		}()
-	}
+func CmdStream(cmd *exec.Cmd) (io.Reader, error) {
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
-		if atEnd != nil {
-			atEnd()
-		}
 		return nil, err
 	}
 	stderr, err := cmd.StderrPipe()
 	if err != nil {
-		if atEnd != nil {
-			atEnd()
-		}
 		return nil, err
 	}
 	pipeR, pipeW := io.Pipe()
@@ -352,9 +258,6 @@ func CmdStream(cmd *exec.Cmd, input *string, atEnd func()) (io.Reader, error) {
 		} else {
 			pipeW.Close()
 		}
-		if atEnd != nil {
-			atEnd()
-		}
 	}()
 	// Run the command and return the pipe
 	if err := cmd.Start(); err != nil {
@@ -1,317 +0,0 @@
-package archive
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"syscall"
-)
-
-type ChangeType int
-
-const (
-	ChangeModify = iota
-	ChangeAdd
-	ChangeDelete
-)
-
-type Change struct {
-	Path string
-	Kind ChangeType
-}
-
-func (change *Change) String() string {
-	var kind string
-	switch change.Kind {
-	case ChangeModify:
-		kind = "C"
-	case ChangeAdd:
-		kind = "A"
-	case ChangeDelete:
-		kind = "D"
-	}
-	return fmt.Sprintf("%s %s", kind, change.Path)
-}
-
-func Changes(layers []string, rw string) ([]Change, error) {
-	var changes []Change
-	err := filepath.Walk(rw, func(path string, f os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-
-		// Rebase path
-		path, err = filepath.Rel(rw, path)
-		if err != nil {
-			return err
-		}
-		path = filepath.Join("/", path)
-
-		// Skip root
-		if path == "/" {
-			return nil
-		}
-
-		// Skip AUFS metadata
-		if matched, err := filepath.Match("/.wh..wh.*", path); err != nil || matched {
-			return err
-		}
-
-		change := Change{
-			Path: path,
-		}
-
-		// Find out what kind of modification happened
-		file := filepath.Base(path)
-		// If there is a whiteout, then the file was removed
-		if strings.HasPrefix(file, ".wh.") {
-			originalFile := file[len(".wh."):]
-			change.Path = filepath.Join(filepath.Dir(path), originalFile)
-			change.Kind = ChangeDelete
-		} else {
-			// Otherwise, the file was added
-			change.Kind = ChangeAdd
-
-			// ...Unless it already existed in a top layer, in which case, it's a modification
-			for _, layer := range layers {
-				stat, err := os.Stat(filepath.Join(layer, path))
-				if err != nil && !os.IsNotExist(err) {
-					return err
-				}
-				if err == nil {
-					// The file existed in the top layer, so that's a modification
-
-					// However, if it's a directory, maybe it wasn't actually modified.
-					// If you modify /foo/bar/baz, then /foo will be part of the changed files only because it's the parent of bar
-					if stat.IsDir() && f.IsDir() {
-						if f.Size() == stat.Size() && f.Mode() == stat.Mode() && f.ModTime() == stat.ModTime() {
-							// Both directories are the same, don't record the change
-							return nil
-						}
-					}
-					change.Kind = ChangeModify
-					break
-				}
-			}
-		}
-
-		// Record change
-		changes = append(changes, change)
-		return nil
-	})
-	if err != nil && !os.IsNotExist(err) {
-		return nil, err
-	}
-	return changes, nil
-}
-
-type FileInfo struct {
-	parent   *FileInfo
-	name     string
-	stat     syscall.Stat_t
-	children map[string]*FileInfo
-}
-
-func (root *FileInfo) LookUp(path string) *FileInfo {
-	parent := root
-	if path == "/" {
-		return root
-	}
-
-	pathElements := strings.Split(path, "/")
-	for _, elem := range pathElements {
-		if elem != "" {
-			child := parent.children[elem]
-			if child == nil {
-				return nil
-			}
-			parent = child
-		}
-	}
-	return parent
-}
-
-func (info *FileInfo) path() string {
-	if info.parent == nil {
-		return "/"
-	}
-	return filepath.Join(info.parent.path(), info.name)
-}
-
-func (info *FileInfo) isDir() bool {
-	return info.parent == nil || info.stat.Mode&syscall.S_IFDIR == syscall.S_IFDIR
-}
-
-func (info *FileInfo) addChanges(oldInfo *FileInfo, changes *[]Change) {
-	if oldInfo == nil {
-		// add
-		change := Change{
-			Path: info.path(),
-			Kind: ChangeAdd,
-		}
-		*changes = append(*changes, change)
-	}
-
-	// We make a copy so we can modify it to detect additions
-	// also, we only recurse on the old dir if the new info is a directory
-	// otherwise any previous delete/change is considered recursive
-	oldChildren := make(map[string]*FileInfo)
-	if oldInfo != nil && info.isDir() {
-		for k, v := range oldInfo.children {
-			oldChildren[k] = v
-		}
-	}
-
-	for name, newChild := range info.children {
-		oldChild, _ := oldChildren[name]
-		if oldChild != nil {
-			// change?
-			oldStat := &oldChild.stat
-			newStat := &newChild.stat
-			// Note: We can't compare inode or ctime or blocksize here, because these change
-			// when copying a file into a container. However, that is not generally a problem
-			// because any content change will change mtime, and any status change should
-			// be visible when actually comparing the stat fields. The only time this
-			// breaks down is if some code intentionally hides a change by setting
-			// back mtime
-			if oldStat.Mode != newStat.Mode ||
-				oldStat.Uid != newStat.Uid ||
-				oldStat.Gid != newStat.Gid ||
-				oldStat.Rdev != newStat.Rdev ||
-				// Don't look at size for dirs, its not a good measure of change
-				(oldStat.Size != newStat.Size && oldStat.Mode&syscall.S_IFDIR != syscall.S_IFDIR) ||
-				oldStat.Mtim != newStat.Mtim {
-				change := Change{
-					Path: newChild.path(),
-					Kind: ChangeModify,
-				}
-				*changes = append(*changes, change)
-			}
-
-			// Remove from copy so we can detect deletions
-			delete(oldChildren, name)
-		}
-
-		newChild.addChanges(oldChild, changes)
-	}
-	for _, oldChild := range oldChildren {
-		// delete
-		change := Change{
-			Path: oldChild.path(),
-			Kind: ChangeDelete,
-		}
-		*changes = append(*changes, change)
-	}
-
-}
-
-func (info *FileInfo) Changes(oldInfo *FileInfo) []Change {
-	var changes []Change
-
-	info.addChanges(oldInfo, &changes)
-
-	return changes
-}
-
-func newRootFileInfo() *FileInfo {
-	root := &FileInfo{
-		name:     "/",
-		children: make(map[string]*FileInfo),
-	}
-	return root
-}
-
-func collectFileInfo(sourceDir string) (*FileInfo, error) {
-	root := newRootFileInfo()
-
-	err := filepath.Walk(sourceDir, func(path string, f os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-
-		// Rebase path
-		relPath, err := filepath.Rel(sourceDir, path)
-		if err != nil {
-			return err
-		}
-		relPath = filepath.Join("/", relPath)
-
-		if relPath == "/" {
-			return nil
-		}
-
-		parent := root.LookUp(filepath.Dir(relPath))
-		if parent == nil {
-			return fmt.Errorf("collectFileInfo: Unexpectedly no parent for %s", relPath)
-		}
-
-		info := &FileInfo{
-			name:     filepath.Base(relPath),
-			children: make(map[string]*FileInfo),
-			parent:   parent,
-		}
-
-		if err := syscall.Lstat(path, &info.stat); err != nil {
-			return err
-		}
-
-		parent.children[info.name] = info
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return root, nil
-}
-
-// Compare two directories and generate an array of Change objects describing the changes
-func ChangesDirs(newDir, oldDir string) ([]Change, error) {
-	oldRoot, err := collectFileInfo(oldDir)
-	if err != nil {
-		return nil, err
-	}
-	newRoot, err := collectFileInfo(newDir)
-	if err != nil {
-		return nil, err
-	}
-
-	return newRoot.Changes(oldRoot), nil
-}
-
-func ChangesSize(newDir string, changes []Change) int64 {
-	var size int64
-	for _, change := range changes {
-		if change.Kind == ChangeModify || change.Kind == ChangeAdd {
-			file := filepath.Join(newDir, change.Path)
-			fileInfo, _ := os.Lstat(file)
-			if fileInfo != nil && !fileInfo.IsDir() {
-				size += fileInfo.Size()
-			}
-		}
-	}
-	return size
-}
-
-func ExportChanges(dir string, changes []Change) (Archive, error) {
-	files := make([]string, 0)
-	deletions := make([]string, 0)
-	for _, change := range changes {
-		if change.Kind == ChangeModify || change.Kind == ChangeAdd {
-			files = append(files, change.Path)
-		}
-		if change.Kind == ChangeDelete {
-			base := filepath.Base(change.Path)
-			dir := filepath.Dir(change.Path)
-			deletions = append(deletions, filepath.Join(dir, ".wh."+base))
-		}
-	}
-	// FIXME: Why do we create whiteout files inside Tar code ?
-	return TarFilter(dir, &TarOptions{
-		Compression: Uncompressed,
-		Includes:    files,
-		Recursive:   false,
-		CreateFiles: deletions,
-	})
-}
@@ -1,298 +0,0 @@
-package archive
-
-import (
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path"
-	"sort"
-	"testing"
-	"time"
-)
-
-func max(x, y int) int {
-	if x >= y {
-		return x
-	}
-	return y
-}
-
-func copyDir(src, dst string) error {
-	cmd := exec.Command("cp", "-a", src, dst)
-	if err := cmd.Run(); err != nil {
-		return err
-	}
-	return nil
-}
-
-// Helper to sort []Change by path
-type byPath struct{ changes []Change }
-
-func (b byPath) Less(i, j int) bool { return b.changes[i].Path < b.changes[j].Path }
-func (b byPath) Len() int           { return len(b.changes) }
-func (b byPath) Swap(i, j int)      { b.changes[i], b.changes[j] = b.changes[j], b.changes[i] }
-
-type FileType uint32
-
-const (
-	Regular FileType = iota
-	Dir
-	Symlink
-)
-
-type FileData struct {
-	filetype    FileType
-	path        string
-	contents    string
-	permissions os.FileMode
-}
-
-func createSampleDir(t *testing.T, root string) {
-	files := []FileData{
-		{Regular, "file1", "file1\n", 0600},
-		{Regular, "file2", "file2\n", 0666},
-		{Regular, "file3", "file3\n", 0404},
-		{Regular, "file4", "file4\n", 0600},
-		{Regular, "file5", "file5\n", 0600},
-		{Regular, "file6", "file6\n", 0600},
-		{Regular, "file7", "file7\n", 0600},
-		{Dir, "dir1", "", 0740},
-		{Regular, "dir1/file1-1", "file1-1\n", 01444},
-		{Regular, "dir1/file1-2", "file1-2\n", 0666},
-		{Dir, "dir2", "", 0700},
-		{Regular, "dir2/file2-1", "file2-1\n", 0666},
-		{Regular, "dir2/file2-2", "file2-2\n", 0666},
-		{Dir, "dir3", "", 0700},
-		{Regular, "dir3/file3-1", "file3-1\n", 0666},
-		{Regular, "dir3/file3-2", "file3-2\n", 0666},
-		{Dir, "dir4", "", 0700},
-		{Regular, "dir4/file3-1", "file4-1\n", 0666},
-		{Regular, "dir4/file3-2", "file4-2\n", 0666},
-		{Symlink, "symlink1", "target1", 0666},
-		{Symlink, "symlink2", "target2", 0666},
-	}
-	for _, info := range files {
-		if info.filetype == Dir {
-			if err := os.MkdirAll(path.Join(root, info.path), info.permissions); err != nil {
-				t.Fatal(err)
-			}
-		} else if info.filetype == Regular {
-			if err := ioutil.WriteFile(path.Join(root, info.path), []byte(info.contents), info.permissions); err != nil {
-				t.Fatal(err)
-			}
-		} else if info.filetype == Symlink {
-			if err := os.Symlink(info.contents, path.Join(root, info.path)); err != nil {
-				t.Fatal(err)
-			}
-		}
-	}
-}
-
-// Create an directory, copy it, make sure we report no changes between the two
-func TestChangesDirsEmpty(t *testing.T) {
-	src, err := ioutil.TempDir("", "docker-changes-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	createSampleDir(t, src)
-	dst := src + "-copy"
-	if err := copyDir(src, dst); err != nil {
-		t.Fatal(err)
-	}
-	changes, err := ChangesDirs(dst, src)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(changes) != 0 {
-		t.Fatalf("Reported changes for identical dirs: %v", changes)
-	}
-	os.RemoveAll(src)
-	os.RemoveAll(dst)
-}
-
-func mutateSampleDir(t *testing.T, root string) {
-	// Remove a regular file
-	if err := os.RemoveAll(path.Join(root, "file1")); err != nil {
-		t.Fatal(err)
-	}
-
-	// Remove a directory
-	if err := os.RemoveAll(path.Join(root, "dir1")); err != nil {
-		t.Fatal(err)
-	}
-
-	// Remove a symlink
-	if err := os.RemoveAll(path.Join(root, "symlink1")); err != nil {
-		t.Fatal(err)
-	}
-
-	// Rewrite a file
-	if err := ioutil.WriteFile(path.Join(root, "file2"), []byte("fileN\n"), 0777); err != nil {
-		t.Fatal(err)
-	}
-
-	// Replace a file
-	if err := os.RemoveAll(path.Join(root, "file3")); err != nil {
-		t.Fatal(err)
-	}
-	if err := ioutil.WriteFile(path.Join(root, "file3"), []byte("fileM\n"), 0404); err != nil {
-		t.Fatal(err)
-	}
-
-	// Touch file
-	if err := os.Chtimes(path.Join(root, "file4"), time.Now(), time.Now()); err != nil {
-		t.Fatal(err)
-	}
-
-	// Replace file with dir
-	if err := os.RemoveAll(path.Join(root, "file5")); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.MkdirAll(path.Join(root, "file5"), 0666); err != nil {
-		t.Fatal(err)
-	}
-
-	// Create new file
-	if err := ioutil.WriteFile(path.Join(root, "filenew"), []byte("filenew\n"), 0777); err != nil {
-		t.Fatal(err)
-	}
-
-	// Create new dir
-	if err := os.MkdirAll(path.Join(root, "dirnew"), 0766); err != nil {
-		t.Fatal(err)
-	}
-
-	// Create a new symlink
-	if err := os.Symlink("targetnew", path.Join(root, "symlinknew")); err != nil {
-		t.Fatal(err)
-	}
-
-	// Change a symlink
-	if err := os.RemoveAll(path.Join(root, "symlink2")); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink("target2change", path.Join(root, "symlink2")); err != nil {
-		t.Fatal(err)
-	}
-
-	// Replace dir with file
-	if err := os.RemoveAll(path.Join(root, "dir2")); err != nil {
-		t.Fatal(err)
-	}
-	if err := ioutil.WriteFile(path.Join(root, "dir2"), []byte("dir2\n"), 0777); err != nil {
-		t.Fatal(err)
-	}
-
-	// Touch dir
-	if err := os.Chtimes(path.Join(root, "dir3"), time.Now(), time.Now()); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestChangesDirsMutated(t *testing.T) {
-	src, err := ioutil.TempDir("", "docker-changes-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	createSampleDir(t, src)
-	dst := src + "-copy"
-	if err := copyDir(src, dst); err != nil {
-		t.Fatal(err)
-	}
-	mutateSampleDir(t, dst)
-
-	changes, err := ChangesDirs(dst, src)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	sort.Sort(byPath{changes})
-
-	expectedChanges := []Change{
-		{"/dir1", ChangeDelete},
-		{"/dir2", ChangeModify},
-		{"/dir3", ChangeModify},
-		{"/dirnew", ChangeAdd},
-		{"/file1", ChangeDelete},
-		{"/file2", ChangeModify},
-		{"/file3", ChangeModify},
-		{"/file4", ChangeModify},
-		{"/file5", ChangeModify},
-		{"/filenew", ChangeAdd},
-		{"/symlink1", ChangeDelete},
-		{"/symlink2", ChangeModify},
-		{"/symlinknew", ChangeAdd},
-	}
-
-	i := 0
-	for ; i < max(len(changes), len(expectedChanges)); i++ {
-		if i >= len(expectedChanges) {
-			t.Fatalf("unexpected change %s\n", changes[i].String())
-		}
-		if i >= len(changes) {
-			t.Fatalf("no change for expected change %s\n", expectedChanges[i].String())
-		}
-		if changes[i].Path == expectedChanges[i].Path {
-			if changes[i] != expectedChanges[i] {
-				t.Fatalf("Wrong change for %s, expected %s, got %d\n", changes[i].Path, changes[i].String(), expectedChanges[i].String())
-			}
-		} else if changes[i].Path < expectedChanges[i].Path {
-			t.Fatalf("unexpected change %s\n", changes[i].String())
-		} else {
-			t.Fatalf("no change for expected change %s\n", expectedChanges[i].String())
-		}
-	}
-	for ; i < len(expectedChanges); i++ {
-	}
-
-	os.RemoveAll(src)
-	os.RemoveAll(dst)
-}
-
-func TestApplyLayer(t *testing.T) {
-	t.Skip("Skipping TestApplyLayer due to known failures") // Disable this for now as it is broken
-	return
-
-	src, err := ioutil.TempDir("", "docker-changes-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	createSampleDir(t, src)
-	dst := src + "-copy"
-	if err := copyDir(src, dst); err != nil {
-		t.Fatal(err)
-	}
-	mutateSampleDir(t, dst)
-
-	changes, err := ChangesDirs(dst, src)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	layer, err := ExportChanges(dst, changes)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	layerCopy, err := NewTempArchive(layer, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := ApplyLayer(src, layerCopy); err != nil {
-		t.Fatal(err)
-	}
-
-	changes2, err := ChangesDirs(src, dst)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(changes2) != 0 {
-		t.Fatalf("Unexpected differences after re applying mutation: %v", changes)
-	}
-
-	os.RemoveAll(src)
-	os.RemoveAll(dst)
-}
@@ -1,95 +0,0 @@
-package archive
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"syscall"
-	"time"
-)
-
-// ApplyLayer parses a diff in the standard layer format from `layer`, and
-// applies it to the directory `dest`.
-func ApplyLayer(dest string, layer Archive) error {
-	// Poor man's diff applyer in 2 steps:
-
-	// Step 1: untar everything in place
-	if err := Untar(layer, dest, nil); err != nil {
-		return err
-	}
-
-	modifiedDirs := make(map[string]*syscall.Stat_t)
-	addDir := func(file string) {
-		d := filepath.Dir(file)
-		if _, exists := modifiedDirs[d]; !exists {
-			if s, err := os.Lstat(d); err == nil {
-				if sys := s.Sys(); sys != nil {
-					if stat, ok := sys.(*syscall.Stat_t); ok {
-						modifiedDirs[d] = stat
-					}
-				}
-			}
-		}
-	}
-
-	// Step 2: walk for whiteouts and apply them, removing them in the process
-	err := filepath.Walk(dest, func(fullPath string, f os.FileInfo, err error) error {
-		if err != nil {
-			if os.IsNotExist(err) {
-				// This happens in the case of whiteouts in parent dir removing a directory
-				// We just ignore it
-				return filepath.SkipDir
-			}
-			return err
-		}
-
-		// Rebase path
-		path, err := filepath.Rel(dest, fullPath)
-		if err != nil {
-			return err
-		}
-		path = filepath.Join("/", path)
-
-		// Skip AUFS metadata
-		if matched, err := filepath.Match("/.wh..wh.*", path); err != nil {
-			return err
-		} else if matched {
-			addDir(fullPath)
-			if err := os.RemoveAll(fullPath); err != nil {
-				return err
-			}
-		}
-
-		filename := filepath.Base(path)
-		if strings.HasPrefix(filename, ".wh.") {
-			rmTargetName := filename[len(".wh."):]
-			rmTargetPath := filepath.Join(filepath.Dir(fullPath), rmTargetName)
-
-			// Remove the file targeted by the whiteout
-			addDir(rmTargetPath)
-			if err := os.RemoveAll(rmTargetPath); err != nil {
-				return err
-			}
-			// Remove the whiteout itself
-			addDir(fullPath)
-			if err := os.RemoveAll(fullPath); err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-
-	for k, v := range modifiedDirs {
-		aTime := time.Unix(v.Atim.Unix())
-		mTime := time.Unix(v.Mtim.Unix())
-
-		if err := os.Chtimes(k, aTime, mTime); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
@@ -1,4 +1,4 @@
-package archive
+package docker

 import (
 	"bytes"
@@ -14,7 +14,7 @@ import (

 func TestCmdStreamLargeStderr(t *testing.T) {
 	cmd := exec.Command("/bin/sh", "-c", "dd if=/dev/zero bs=1k count=1000 of=/dev/stderr; echo hello")
-	out, err := CmdStream(cmd, nil, nil)
+	out, err := CmdStream(cmd)
 	if err != nil {
 		t.Fatalf("Failed to start command: %s", err)
 	}
@@ -35,7 +35,7 @@ func TestCmdStreamLargeStderr(t *testing.T) {

 func TestCmdStreamBad(t *testing.T) {
 	badCmd := exec.Command("/bin/sh", "-c", "echo hello; echo >&2 error couldn\\'t reverse the phase pulser; exit 1")
-	out, err := CmdStream(badCmd, nil, nil)
+	out, err := CmdStream(badCmd)
 	if err != nil {
 		t.Fatalf("Failed to start command: %s", err)
 	}
@@ -50,7 +50,7 @@ func TestCmdStreamBad(t *testing.T) {

 func TestCmdStreamGood(t *testing.T) {
 	cmd := exec.Command("/bin/sh", "-c", "echo hello; exit 0")
-	out, err := CmdStream(cmd, nil, nil)
+	out, err := CmdStream(cmd)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -83,7 +83,7 @@ func tarUntar(t *testing.T, origin string, compression Compression) error {
 		return err
 	}
 	defer os.RemoveAll(tmp)
-	if err := Untar(archive, tmp, nil); err != nil {
+	if err := Untar(archive, tmp); err != nil {
 		return err
 	}
 	if _, err := os.Stat(tmp); err != nil {
@@ -196,9 +196,10 @@ func Login(authConfig *AuthConfig, factory *utils.HTTPRequestFactory) (string, e
 		if loginAgainstOfficialIndex {
 			return "", fmt.Errorf("Login: Your account hasn't been activated. " +
 				"Please check your e-mail for a confirmation link.")
+		} else {
+			return "", fmt.Errorf("Login: Your account hasn't been activated. " +
+				"Please see the documentation of the registry " + serverAddress + " for instructions how to activate it.")
 		}
-		return "", fmt.Errorf("Login: Your account hasn't been activated. " +
-			"Please see the documentation of the registry " + serverAddress + " for instructions how to activate it.")
 	} else if reqStatusCode == 400 {
 		if string(reqBody) == "\"Username or email already exists\"" {
 			req, err := factory.NewRequest("GET", serverAddress+"users/", nil)
@@ -1,8 +1,11 @@
 package auth

 import (
+	"crypto/rand"
+	"encoding/hex"
 	"io/ioutil"
 	"os"
+	"strings"
 	"testing"
 )

@@ -26,33 +29,67 @@ func TestEncodeAuth(t *testing.T) {
 	}
 }

-func setupTempConfigFile() (*ConfigFile, error) {
-	root, err := ioutil.TempDir("", "docker-test-auth")
-	if err != nil {
-		return nil, err
-	}
-	configFile := &ConfigFile{
-		rootPath: root,
-		Configs:  make(map[string]AuthConfig),
-	}
-
-	for _, registry := range []string{"testIndex", IndexServerAddress()} {
-		configFile.Configs[registry] = AuthConfig{
-			Username: "docker-user",
-			Password: "docker-pass",
-			Email:    "docker@docker.io",
-		}
-	}
-
-	return configFile, nil
-}
-
-func TestSameAuthDataPostSave(t *testing.T) {
-	configFile, err := setupTempConfigFile()
+func TestLogin(t *testing.T) {
+	os.Setenv("DOCKER_INDEX_URL", "https://indexstaging-docker.dotcloud.com")
+	defer os.Setenv("DOCKER_INDEX_URL", "")
+	authConfig := &AuthConfig{Username: "unittester", Password: "surlautrerivejetattendrai", Email: "noise+unittester@dotcloud.com"}
+	status, err := Login(authConfig, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer os.RemoveAll(configFile.rootPath)
+	if status != "Login Succeeded" {
+		t.Fatalf("Expected status \"Login Succeeded\", found \"%s\" instead", status)
+	}
+}
+
+func TestCreateAccount(t *testing.T) {
+	os.Setenv("DOCKER_INDEX_URL", "https://indexstaging-docker.dotcloud.com")
+	defer os.Setenv("DOCKER_INDEX_URL", "")
+	tokenBuffer := make([]byte, 16)
+	_, err := rand.Read(tokenBuffer)
+	if err != nil {
+		t.Fatal(err)
+	}
+	token := hex.EncodeToString(tokenBuffer)[:12]
+	username := "ut" + token
+	authConfig := &AuthConfig{Username: username, Password: "test42", Email: "docker-ut+" + token + "@example.com"}
+	status, err := Login(authConfig, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expectedStatus := "Account created. Please use the confirmation link we sent" +
+		" to your e-mail to activate it."
+	if status != expectedStatus {
+		t.Fatalf("Expected status: \"%s\", found \"%s\" instead.", expectedStatus, status)
+	}
+
+	status, err = Login(authConfig, nil)
+	if err == nil {
+		t.Fatalf("Expected error but found nil instead")
+	}
+
+	expectedError := "Login: Account is not Active"
+
+	if !strings.Contains(err.Error(), expectedError) {
+		t.Fatalf("Expected message \"%s\" but found \"%s\" instead", expectedError, err)
+	}
+}
+
+func TestSameAuthDataPostSave(t *testing.T) {
+	root, err := ioutil.TempDir("", "docker-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	configFile := &ConfigFile{
+		rootPath: root,
+		Configs:  make(map[string]AuthConfig, 1),
+	}
+
+	configFile.Configs["testIndex"] = AuthConfig{
+		Username: "docker-user",
+		Password: "docker-pass",
+		Email:    "docker@docker.io",
+	}

 	err = SaveConfig(configFile)
 	if err != nil {
@@ -73,70 +110,3 @@ func TestSameAuthDataPostSave(t *testing.T) {
 		t.Fail()
 	}
 }
-
-func TestResolveAuthConfigIndexServer(t *testing.T) {
-	configFile, err := setupTempConfigFile()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(configFile.rootPath)
-
-	for _, registry := range []string{"", IndexServerAddress()} {
-		resolved := configFile.ResolveAuthConfig(registry)
-		if resolved != configFile.Configs[IndexServerAddress()] {
-			t.Fail()
-		}
-	}
-}
-
-func TestResolveAuthConfigFullURL(t *testing.T) {
-	configFile, err := setupTempConfigFile()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(configFile.rootPath)
-
-	registryAuth := AuthConfig{
-		Username: "foo-user",
-		Password: "foo-pass",
-		Email:    "foo@example.com",
-	}
-	localAuth := AuthConfig{
-		Username: "bar-user",
-		Password: "bar-pass",
-		Email:    "bar@example.com",
-	}
-	configFile.Configs["https://registry.example.com/v1/"] = registryAuth
-	configFile.Configs["http://localhost:8000/v1/"] = localAuth
-
-	validRegistries := map[string][]string{
-		"https://registry.example.com/v1/": {
-			"https://registry.example.com/v1/",
-			"http://registry.example.com/v1/",
-			"registry.example.com",
-			"registry.example.com/v1/",
-		},
-		"http://localhost:8000/v1/": {
-			"https://localhost:8000/v1/",
-			"http://localhost:8000/v1/",
-			"localhost:8000",
-			"localhost:8000/v1/",
-		},
-	}
-
-	for configKey, registries := range validRegistries {
-		for _, registry := range registries {
-			var (
-				configured AuthConfig
-				ok         bool
-			)
-			resolved := configFile.ResolveAuthConfig(registry)
-			if configured, ok = configFile.Configs[configKey]; !ok {
-				t.Fail()
-			}
-			if resolved.Email != configured.Email {
-				t.Errorf("%s -> %q != %q\n", registry, resolved.Email, configured.Email)
-			}
-		}
-	}
-}
@@ -3,7 +3,6 @@ package docker
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/dotcloud/docker/archive"
 	"github.com/dotcloud/docker/utils"
 	"io"
 	"io/ioutil"
@@ -65,9 +64,6 @@ func (b *buildFile) CmdFrom(name string) error {
 	}
 	b.image = image.ID
 	b.config = &Config{}
-	if image.Config != nil {
-		b.config = image.Config
-	}
 	if b.config.Env == nil || len(b.config.Env) == 0 {
 		b.config.Env = append(b.config.Env, "HOME=/", "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
 	}
@@ -191,6 +187,9 @@ func (b *buildFile) CmdCmd(args string) error {
 }

 func (b *buildFile) CmdExpose(args string) error {
+	if strings.Contains(args, ":") {
+		return fmt.Errorf("EXPOSE cannot be used to bind to a host ip or port")
+	}
 	ports := strings.Split(args, " ")
 	b.config.PortSpecs = append(ports, b.config.PortSpecs...)
 	return b.commit("", b.config.Cmd, fmt.Sprintf("EXPOSE %v", ports))
@@ -295,17 +294,17 @@ func (b *buildFile) addContext(container *Container, orig, dest string) error {
 		return fmt.Errorf("%s: no such file or directory", orig)
 	}
 	if fi.IsDir() {
-		if err := archive.CopyWithTar(origPath, destPath); err != nil {
+		if err := CopyWithTar(origPath, destPath); err != nil {
 			return err
 		}
 		// First try to unpack the source as an archive
-	} else if err := archive.UntarPath(origPath, destPath); err != nil {
+	} else if err := UntarPath(origPath, destPath); err != nil {
 		utils.Debugf("Couldn't untar %s to %s: %s", origPath, destPath, err)
 		// If that fails, just copy it as a regular file
 		if err := os.MkdirAll(path.Dir(destPath), 0755); err != nil {
 			return err
 		}
-		if err := archive.CopyWithTar(origPath, destPath); err != nil {
+		if err := CopyWithTar(origPath, destPath); err != nil {
 			return err
 		}
 	}
@@ -336,7 +335,7 @@ func (b *buildFile) CmdAdd(args string) error {

 	b.config.Image = b.image
 	// Create the container and start it
-	container, _, err := b.runtime.Create(b.config, "")
+	container, _, err := b.runtime.Create(b.config)
 	if err != nil {
 		return err
 	}
@@ -371,7 +370,7 @@ func (b *buildFile) run() (string, error) {
 	b.config.Image = b.image

 	// Create the container and start it
-	c, _, err := b.runtime.Create(b.config, "")
+	c, _, err := b.runtime.Create(b.config)
 	if err != nil {
 		return "", err
 	}
@@ -382,21 +381,15 @@ func (b *buildFile) run() (string, error) {
 	c.Path = b.config.Cmd[0]
 	c.Args = b.config.Cmd[1:]

-	var errCh chan error
-
-	if b.verbose {
-		errCh = utils.Go(func() error {
-			return <-c.Attach(nil, nil, b.out, b.out)
-		})
-	}
-
 	//start the container
-	if err := c.Start(); err != nil {
+	hostConfig := &HostConfig{}
+	if err := c.Start(hostConfig); err != nil {
 		return "", err
 	}

-	if errCh != nil {
-		if err := <-errCh; err != nil {
+	if b.verbose {
+		err = <-c.Attach(nil, nil, b.out, b.out)
+		if err != nil {
 			return "", err
 		}
 	}
@@ -433,13 +426,10 @@ func (b *buildFile) commit(id string, autoCmd []string, comment string) error {
 			}
 		}

-		container, warnings, err := b.runtime.Create(b.config, "")
+		container, _, err := b.runtime.Create(b.config)
 		if err != nil {
 			return err
 		}
-		for _, warning := range warnings {
-			fmt.Fprintf(b.out, " ---> [Warning] %s\n", warning)
-		}
 		b.tmpContainers[container.ID] = struct{}{}
 		fmt.Fprintf(b.out, " ---> Running in %s\n", utils.TruncateID(container.ID))
 		id = container.ID
@@ -471,12 +461,13 @@ func (b *buildFile) commit(id string, autoCmd []string, comment string) error {
 var lineContinuation = regexp.MustCompile(`\s*\\\s*\n`)

 func (b *buildFile) Build(context io.Reader) (string, error) {
+	// FIXME: @creack any reason for using /tmp instead of ""?
 	// FIXME: @creack "name" is a terrible variable name
-	name, err := ioutil.TempDir("", "docker-build")
+	name, err := ioutil.TempDir("/tmp", "docker-build")
 	if err != nil {
 		return "", err
 	}
-	if err := archive.Untar(context, name, nil); err != nil {
+	if err := Untar(context, name); err != nil {
 		return "", err
 	}
 	defer os.RemoveAll(name)
@@ -2,9 +2,6 @@ package docker

 import (
 	"fmt"
-	"github.com/dotcloud/docker"
-	"github.com/dotcloud/docker/archive"
-	"github.com/dotcloud/docker/engine"
 	"io/ioutil"
 	"net"
 	"net/http"
@@ -15,8 +12,8 @@ import (

 // mkTestContext generates a build context from the contents of the provided dockerfile.
 // This context is suitable for use as an argument to BuildFile.Build()
-func mkTestContext(dockerfile string, files [][2]string, t *testing.T) archive.Archive {
-	context, err := docker.MkBuildContext(dockerfile, files)
+func mkTestContext(dockerfile string, files [][2]string, t *testing.T) Archive {
+	context, err := mkBuildContext(dockerfile, files)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -230,15 +227,20 @@ func TestBuild(t *testing.T) {
 	}
 }

-func buildImage(context testContextTemplate, t *testing.T, eng *engine.Engine, useCache bool) *docker.Image {
-	if eng == nil {
-		eng = NewTestEngine(t)
-		runtime := mkRuntimeFromEngine(eng, t)
-		// FIXME: we might not need runtime, why not simply nuke
-		// the engine?
+func buildImage(context testContextTemplate, t *testing.T, srv *Server, useCache bool) *Image {
+	if srv == nil {
+		runtime, err := newTestRuntime()
+		if err != nil {
+			t.Fatal(err)
+		}
 		defer nuke(runtime)
+
+		srv = &Server{
+			runtime:     runtime,
+			pullingPool: make(map[string]struct{}),
+			pushingPool: make(map[string]struct{}),
+		}
 	}
-	srv := mkServerFromEngine(eng, t)

 	httpServer, err := mkTestingFileServer(context.remoteFiles)
 	if err != nil {
@@ -252,17 +254,10 @@ func buildImage(context testContextTemplate, t *testing.T, eng *engine.Engine, u
 	}
 	port := httpServer.URL[idx+1:]

-	iIP := eng.Hack_GetGlobalVar("httpapi.bridgeIP")
-	if iIP == nil {
-		t.Fatal("Legacy bridgeIP field not set in engine")
-	}
-	ip, ok := iIP.(net.IP)
-	if !ok {
-		panic("Legacy bridgeIP field in engine does not cast to net.IP")
-	}
+	ip := srv.runtime.networkManager.bridgeNetwork.IP
 	dockerfile := constructDockerfile(context.dockerfile, ip, port)

-	buildfile := docker.NewBuildFile(srv, ioutil.Discard, false, useCache, false)
+	buildfile := NewBuildFile(srv, ioutil.Discard, false, useCache, false)
 	id, err := buildfile.Build(mkTestContext(dockerfile, context.files, t))
 	if err != nil {
 		t.Fatal(err)
@@ -375,14 +370,23 @@ func TestBuildEntrypoint(t *testing.T) {
 // testing #1405 - config.Cmd does not get cleaned up if
 // utilizing cache
 func TestBuildEntrypointRunCleanup(t *testing.T) {
-	eng := NewTestEngine(t)
-	defer nuke(mkRuntimeFromEngine(eng, t))
+	runtime, err := newTestRuntime()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(runtime)
+
+	srv := &Server{
+		runtime:     runtime,
+		pullingPool: make(map[string]struct{}),
+		pushingPool: make(map[string]struct{}),
+	}

 	img := buildImage(testContextTemplate{`
        from {IMAGE}
        run echo "hello"
        `,
-		nil, nil}, t, eng, true)
+		nil, nil}, t, srv, true)

 	img = buildImage(testContextTemplate{`
        from {IMAGE}
@@ -390,7 +394,7 @@ func TestBuildEntrypointRunCleanup(t *testing.T) {
        add foo /foo
        entrypoint ["/bin/echo"]
        `,
-		[][2]string{{"foo", "HEYO"}}, nil}, t, eng, true)
+		[][2]string{{"foo", "HEYO"}}, nil}, t, srv, true)

 	if len(img.Config.Cmd) != 0 {
 		t.Fail()
@@ -398,8 +402,17 @@ func TestBuildEntrypointRunCleanup(t *testing.T) {
 }

 func TestBuildImageWithCache(t *testing.T) {
-	eng := NewTestEngine(t)
-	defer nuke(mkRuntimeFromEngine(eng, t))
+	runtime, err := newTestRuntime()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(runtime)
+
+	srv := &Server{
+		runtime:     runtime,
+		pullingPool: make(map[string]struct{}),
+		pushingPool: make(map[string]struct{}),
+	}

 	template := testContextTemplate{`
        from {IMAGE}
@@ -407,11 +420,11 @@ func TestBuildImageWithCache(t *testing.T) {
        `,
 		nil, nil}

-	img := buildImage(template, t, eng, true)
+	img := buildImage(template, t, srv, true)
 	imageId := img.ID

 	img = nil
-	img = buildImage(template, t, eng, true)
+	img = buildImage(template, t, srv, true)

 	if imageId != img.ID {
 		t.Logf("Image ids should match: %s != %s", imageId, img.ID)
@@ -420,8 +433,17 @@ func TestBuildImageWithCache(t *testing.T) {
 }

 func TestBuildImageWithoutCache(t *testing.T) {
-	eng := NewTestEngine(t)
-	defer nuke(mkRuntimeFromEngine(eng, t))
+	runtime, err := newTestRuntime()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(runtime)
+
+	srv := &Server{
+		runtime:     runtime,
+		pullingPool: make(map[string]struct{}),
+		pushingPool: make(map[string]struct{}),
+	}

 	template := testContextTemplate{`
        from {IMAGE}
@@ -429,11 +451,11 @@ func TestBuildImageWithoutCache(t *testing.T) {
        `,
 		nil, nil}

-	img := buildImage(template, t, eng, true)
+	img := buildImage(template, t, srv, true)
 	imageId := img.ID

 	img = nil
-	img = buildImage(template, t, eng, false)
+	img = buildImage(template, t, srv, false)

 	if imageId == img.ID {
 		t.Logf("Image ids should not match: %s == %s", imageId, img.ID)
@@ -442,9 +464,17 @@ func TestBuildImageWithoutCache(t *testing.T) {
 }

 func TestForbiddenContextPath(t *testing.T) {
-	eng := NewTestEngine(t)
-	defer nuke(mkRuntimeFromEngine(eng, t))
-	srv := mkServerFromEngine(eng, t)
+	runtime, err := newTestRuntime()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(runtime)
+
+	srv := &Server{
+		runtime:     runtime,
+		pullingPool: make(map[string]struct{}),
+		pushingPool: make(map[string]struct{}),
+	}

 	context := testContextTemplate{`
        from {IMAGE}
@@ -465,17 +495,10 @@ func TestForbiddenContextPath(t *testing.T) {
 	}
 	port := httpServer.URL[idx+1:]

-	iIP := eng.Hack_GetGlobalVar("httpapi.bridgeIP")
-	if iIP == nil {
-		t.Fatal("Legacy bridgeIP field not set in engine")
-	}
-	ip, ok := iIP.(net.IP)
-	if !ok {
-		panic("Legacy bridgeIP field in engine does not cast to net.IP")
-	}
+	ip := srv.runtime.networkManager.bridgeNetwork.IP
 	dockerfile := constructDockerfile(context.dockerfile, ip, port)

-	buildfile := docker.NewBuildFile(srv, ioutil.Discard, false, true, false)
+	buildfile := NewBuildFile(srv, ioutil.Discard, false, true, false)
 	_, err = buildfile.Build(mkTestContext(dockerfile, context.files, t))

 	if err == nil {
@@ -490,8 +513,17 @@ func TestForbiddenContextPath(t *testing.T) {
 }

 func TestBuildADDFileNotFound(t *testing.T) {
-	eng := NewTestEngine(t)
-	defer nuke(mkRuntimeFromEngine(eng, t))
+	runtime, err := newTestRuntime()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(runtime)
+
+	srv := &Server{
+		runtime:     runtime,
+		pullingPool: make(map[string]struct{}),
+		pushingPool: make(map[string]struct{}),
+	}

 	context := testContextTemplate{`
        from {IMAGE}
@@ -511,17 +543,10 @@ func TestBuildADDFileNotFound(t *testing.T) {
 	}
 	port := httpServer.URL[idx+1:]

-	iIP := eng.Hack_GetGlobalVar("httpapi.bridgeIP")
-	if iIP == nil {
-		t.Fatal("Legacy bridgeIP field not set in engine")
-	}
-	ip, ok := iIP.(net.IP)
-	if !ok {
-		panic("Legacy bridgeIP field in engine does not cast to net.IP")
-	}
+	ip := srv.runtime.networkManager.bridgeNetwork.IP
 	dockerfile := constructDockerfile(context.dockerfile, ip, port)

-	buildfile := docker.NewBuildFile(mkServerFromEngine(eng, t), ioutil.Discard, false, true, false)
+	buildfile := NewBuildFile(srv, ioutil.Discard, false, true, false)
 	_, err = buildfile.Build(mkTestContext(dockerfile, context.files, t))

 	if err == nil {
@@ -534,30 +559,3 @@ func TestBuildADDFileNotFound(t *testing.T) {
 		t.Fail()
 	}
 }
-
-func TestBuildInheritance(t *testing.T) {
-	eng := NewTestEngine(t)
-	defer nuke(mkRuntimeFromEngine(eng, t))
-
-	img := buildImage(testContextTemplate{`
-            from {IMAGE}
-            expose 4243
-            `,
-		nil, nil}, t, eng, true)
-
-	img2 := buildImage(testContextTemplate{fmt.Sprintf(`
-            from %s
-            entrypoint ["/bin/echo"]
-            `, img.ID),
-		nil, nil}, t, eng, true)
-
-	// from child
-	if img2.Config.Entrypoint[0] != "/bin/echo" {
-		t.Fail()
-	}
-
-	// from parent
-	if img.Config.PortSpecs[0] != "4243" {
-		t.Fail()
-	}
-}
@@ -0,0 +1,106 @@
+package docker
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type ChangeType int
+
+const (
+	ChangeModify = iota
+	ChangeAdd
+	ChangeDelete
+)
+
+type Change struct {
+	Path string
+	Kind ChangeType
+}
+
+func (change *Change) String() string {
+	var kind string
+	switch change.Kind {
+	case ChangeModify:
+		kind = "C"
+	case ChangeAdd:
+		kind = "A"
+	case ChangeDelete:
+		kind = "D"
+	}
+	return fmt.Sprintf("%s %s", kind, change.Path)
+}
+
+func Changes(layers []string, rw string) ([]Change, error) {
+	var changes []Change
+	err := filepath.Walk(rw, func(path string, f os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Rebase path
+		path, err = filepath.Rel(rw, path)
+		if err != nil {
+			return err
+		}
+		path = filepath.Join("/", path)
+
+		// Skip root
+		if path == "/" {
+			return nil
+		}
+
+		// Skip AUFS metadata
+		if matched, err := filepath.Match("/.wh..wh.*", path); err != nil || matched {
+			return err
+		}
+
+		change := Change{
+			Path: path,
+		}
+
+		// Find out what kind of modification happened
+		file := filepath.Base(path)
+		// If there is a whiteout, then the file was removed
+		if strings.HasPrefix(file, ".wh.") {
+			originalFile := file[len(".wh."):]
+			change.Path = filepath.Join(filepath.Dir(path), originalFile)
+			change.Kind = ChangeDelete
+		} else {
+			// Otherwise, the file was added
+			change.Kind = ChangeAdd
+
+			// ...Unless it already existed in a top layer, in which case, it's a modification
+			for _, layer := range layers {
+				stat, err := os.Stat(filepath.Join(layer, path))
+				if err != nil && !os.IsNotExist(err) {
+					return err
+				}
+				if err == nil {
+					// The file existed in the top layer, so that's a modification
+
+					// However, if it's a directory, maybe it wasn't actually modified.
+					// If you modify /foo/bar/baz, then /foo will be part of the changed files only because it's the parent of bar
+					if stat.IsDir() && f.IsDir() {
+						if f.Size() == stat.Size() && f.Mode() == stat.Mode() && f.ModTime() == stat.ModTime() {
+							// Both directories are the same, don't record the change
+							return nil
+						}
+					}
+					change.Kind = ChangeModify
+					break
+				}
+			}
+		}
+
+		// Record change
+		changes = append(changes, change)
+		return nil
+	})
+	if err != nil && !os.IsNotExist(err) {
+		return nil, err
+	}
+	return changes, nil
+}
@@ -3,14 +3,9 @@ package docker
 import (
 	"bufio"
 	"fmt"
-	"github.com/dotcloud/docker"
-	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/utils"
 	"io"
 	"io/ioutil"
-	"os"
-	"path"
-	"regexp"
 	"strings"
 	"testing"
 	"time"
@@ -68,8 +63,8 @@ func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error
 func TestRunHostname(t *testing.T) {
 	stdout, stdoutPipe := io.Pipe()

-	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	c := make(chan struct{})
 	go func() {
@@ -89,32 +84,18 @@ func TestRunHostname(t *testing.T) {
 		}
 	})

-	container := globalRuntime.List()[0]
-
-	setTimeout(t, "CmdRun timed out", 10*time.Second, func() {
+	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
 		<-c
-
-		go func() {
-			cli.CmdWait(container.ID)
-		}()
-
-		if _, err := bufio.NewReader(stdout).ReadString('\n'); err != nil {
-			t.Fatal(err)
-		}
 	})

-	// Cleanup pipes
-	if err := closeWrap(stdout, stdoutPipe); err != nil {
-		t.Fatal(err)
-	}
 }

 // TestRunWorkdir checks that 'docker run -w' correctly sets a custom working directory
 func TestRunWorkdir(t *testing.T) {
 	stdout, stdoutPipe := io.Pipe()

-	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	c := make(chan struct{})
 	go func() {
@@ -134,32 +115,18 @@ func TestRunWorkdir(t *testing.T) {
 		}
 	})

-	container := globalRuntime.List()[0]
-
-	setTimeout(t, "CmdRun timed out", 10*time.Second, func() {
+	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
 		<-c
-
-		go func() {
-			cli.CmdWait(container.ID)
-		}()
-
-		if _, err := bufio.NewReader(stdout).ReadString('\n'); err != nil {
-			t.Fatal(err)
-		}
 	})

-	// Cleanup pipes
-	if err := closeWrap(stdout, stdoutPipe); err != nil {
-		t.Fatal(err)
-	}
 }

 // TestRunWorkdirExists checks that 'docker run -w' correctly sets a custom working directory, even if it exists
 func TestRunWorkdirExists(t *testing.T) {
 	stdout, stdoutPipe := io.Pipe()

-	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	c := make(chan struct{})
 	go func() {
@@ -179,32 +146,18 @@ func TestRunWorkdirExists(t *testing.T) {
 		}
 	})

-	container := globalRuntime.List()[0]
-
 	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
 		<-c
-
-		go func() {
-			cli.CmdWait(container.ID)
-		}()
-
-		if _, err := bufio.NewReader(stdout).ReadString('\n'); err != nil {
-			t.Fatal(err)
-		}
 	})

-	// Cleanup pipes
-	if err := closeWrap(stdout, stdoutPipe); err != nil {
-		t.Fatal(err)
-	}
 }

 func TestRunExit(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()

-	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	c1 := make(chan struct{})
 	go func() {
@@ -256,8 +209,8 @@ func TestRunDisconnect(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()

-	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	c1 := make(chan struct{})
 	go func() {
@@ -289,7 +242,7 @@ func TestRunDisconnect(t *testing.T) {
 	setTimeout(t, "Waiting for /bin/cat to exit timed out", 2*time.Second, func() {
 		container := globalRuntime.List()[0]
 		container.Wait()
-		if container.State.IsRunning() {
+		if container.State.Running {
 			t.Fatalf("/bin/cat is still running after closing stdin")
 		}
 	})
@@ -301,15 +254,15 @@ func TestRunDisconnectTty(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()

-	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	c1 := make(chan struct{})
 	go func() {
 		// We're simulating a disconnect so the return value doesn't matter. What matters is the
 		// fact that CmdRun returns.
 		if err := cli.CmdRun("-i", "-t", unitTestImageID, "/bin/cat"); err != nil {
-			utils.Debugf("Error CmdRun: %s", err)
+			utils.Debugf("Error CmdRun: %s\n", err)
 		}

 		close(c1)
@@ -319,7 +272,7 @@ func TestRunDisconnectTty(t *testing.T) {
 		for {
 			// Client disconnect after run -i should keep stdin out in TTY mode
 			l := globalRuntime.List()
-			if len(l) == 1 && l[0].State.IsRunning() {
+			if len(l) == 1 && l[0].State.Running {
 				break
 			}
 			time.Sleep(10 * time.Millisecond)
@@ -329,7 +282,7 @@ func TestRunDisconnectTty(t *testing.T) {
 	// Client disconnect after run -i should keep stdin out in TTY mode
 	container := globalRuntime.List()[0]

-	setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
+	setTimeout(t, "Read/Write assertion timed out", 2000*time.Second, func() {
 		if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
 			t.Fatal(err)
 		}
@@ -345,7 +298,7 @@ func TestRunDisconnectTty(t *testing.T) {

 	// Give some time to monitor to do his thing
 	container.WaitTimeout(500 * time.Millisecond)
-	if !container.State.IsRunning() {
+	if !container.State.Running {
 		t.Fatalf("/bin/cat should  still be running after closing stdin (tty mode)")
 	}
 }
@@ -358,8 +311,8 @@ func TestRunAttachStdin(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()

-	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	ch := make(chan struct{})
 	go func() {
@@ -385,8 +338,8 @@ func TestRunAttachStdin(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		if cmdOutput != container.ID+"\n" {
-			t.Fatalf("Wrong output: should be '%s', not '%s'\n", container.ID+"\n", cmdOutput)
+		if cmdOutput != container.ShortID()+"\n" {
+			t.Fatalf("Wrong output: should be '%s', not '%s'\n", container.ShortID()+"\n", cmdOutput)
 		}
 	})

@@ -422,8 +375,8 @@ func TestRunDetach(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()

-	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	ch := make(chan struct{})
 	go func() {
@@ -440,116 +393,35 @@ func TestRunDetach(t *testing.T) {
 	container := globalRuntime.List()[0]

 	setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {
-		stdinPipe.Write([]byte{16, 17})
+		stdinPipe.Write([]byte{'', ''})
 		if err := stdinPipe.Close(); err != nil {
 			t.Fatal(err)
 		}
 	})

-	closeWrap(stdin, stdinPipe, stdout, stdoutPipe)
-
 	// wait for CmdRun to return
-	setTimeout(t, "Waiting for CmdRun timed out", 15*time.Second, func() {
+	setTimeout(t, "Waiting for CmdRun timed out", 5*time.Second, func() {
 		<-ch
 	})

 	time.Sleep(500 * time.Millisecond)
-	if !container.State.IsRunning() {
+	if !container.State.Running {
 		t.Fatal("The detached container should be still running")
 	}

 	setTimeout(t, "Waiting for container to die timed out", 20*time.Second, func() {
 		container.Kill()
+		container.Wait()
 	})
 }

-// TestAttachDetach checks that attach in tty mode can be detached using the long container ID
+// TestAttachDetach checks that attach in tty mode can be detached
 func TestAttachDetach(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()

-	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
-
-	ch := make(chan struct{})
-	go func() {
-		defer close(ch)
-		if err := cli.CmdRun("-i", "-t", "-d", unitTestImageID, "cat"); err != nil {
-			t.Fatal(err)
-		}
-	}()
-
-	var container *docker.Container
-
-	setTimeout(t, "Reading container's id timed out", 10*time.Second, func() {
-		buf := make([]byte, 1024)
-		n, err := stdout.Read(buf)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		container = globalRuntime.List()[0]
-
-		if strings.Trim(string(buf[:n]), " \r\n") != container.ID {
-			t.Fatalf("Wrong ID received. Expect %s, received %s", container.ID, buf[:n])
-		}
-	})
-	setTimeout(t, "Starting container timed out", 10*time.Second, func() {
-		<-ch
-	})
-
-	stdin, stdinPipe = io.Pipe()
-	stdout, stdoutPipe = io.Pipe()
-	cli = docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-
-	ch = make(chan struct{})
-	go func() {
-		defer close(ch)
-		if err := cli.CmdAttach(container.ID); err != nil {
-			if err != io.ErrClosedPipe {
-				t.Fatal(err)
-			}
-		}
-	}()
-
-	setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
-		if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
-			if err != io.ErrClosedPipe {
-				t.Fatal(err)
-			}
-		}
-	})
-
-	setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {
-		stdinPipe.Write([]byte{16, 17})
-		if err := stdinPipe.Close(); err != nil {
-			t.Fatal(err)
-		}
-	})
-	closeWrap(stdin, stdinPipe, stdout, stdoutPipe)
-
-	// wait for CmdRun to return
-	setTimeout(t, "Waiting for CmdAttach timed out", 15*time.Second, func() {
-		<-ch
-	})
-
-	time.Sleep(500 * time.Millisecond)
-	if !container.State.IsRunning() {
-		t.Fatal("The detached container should be still running")
-	}
-
-	setTimeout(t, "Waiting for container to die timedout", 5*time.Second, func() {
-		container.Kill()
-	})
-}
-
-// TestAttachDetachTruncatedID checks that attach in tty mode can be detached
-func TestAttachDetachTruncatedID(t *testing.T) {
-	stdin, stdinPipe := io.Pipe()
-	stdout, stdoutPipe := io.Pipe()
-
-	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	go stdout.Read(make([]byte, 1024))
 	setTimeout(t, "Starting container timed out", 2*time.Second, func() {
@@ -562,46 +434,42 @@ func TestAttachDetachTruncatedID(t *testing.T) {

 	stdin, stdinPipe = io.Pipe()
 	stdout, stdoutPipe = io.Pipe()
-	cli = docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	cli = NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)

 	ch := make(chan struct{})
 	go func() {
 		defer close(ch)
-		if err := cli.CmdAttach(utils.TruncateID(container.ID)); err != nil {
-			if err != io.ErrClosedPipe {
-				t.Fatal(err)
-			}
+		if err := cli.CmdAttach(container.ShortID()); err != nil {
+			t.Fatal(err)
 		}
 	}()

 	setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
 		if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
-			if err != io.ErrClosedPipe {
-				t.Fatal(err)
-			}
+			t.Fatal(err)
 		}
 	})

 	setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {
-		stdinPipe.Write([]byte{16, 17})
+		stdinPipe.Write([]byte{'', ''})
 		if err := stdinPipe.Close(); err != nil {
 			t.Fatal(err)
 		}
 	})
-	closeWrap(stdin, stdinPipe, stdout, stdoutPipe)

 	// wait for CmdRun to return
-	setTimeout(t, "Waiting for CmdAttach timed out", 15*time.Second, func() {
+	setTimeout(t, "Waiting for CmdAttach timed out", 5*time.Second, func() {
 		<-ch
 	})

 	time.Sleep(500 * time.Millisecond)
-	if !container.State.IsRunning() {
+	if !container.State.Running {
 		t.Fatal("The detached container should be still running")
 	}

 	setTimeout(t, "Waiting for container to die timedout", 5*time.Second, func() {
 		container.Kill()
+		container.Wait()
 	})
 }

@@ -610,13 +478,13 @@ func TestAttachDisconnect(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()

-	cli := docker.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	go func() {
 		// Start a process in daemon mode
 		if err := cli.CmdRun("-d", "-i", unitTestImageID, "/bin/cat"); err != nil {
-			utils.Debugf("Error CmdRun: %s", err)
+			utils.Debugf("Error CmdRun: %s\n", err)
 		}
 	}()

@@ -629,7 +497,7 @@ func TestAttachDisconnect(t *testing.T) {
 	setTimeout(t, "Waiting for the container to be started timed out", 10*time.Second, func() {
 		for {
 			l := globalRuntime.List()
-			if len(l) == 1 && l[0].State.IsRunning() {
+			if len(l) == 1 && l[0].State.Running {
 				break
 			}
 			time.Sleep(10 * time.Millisecond)
@@ -665,7 +533,7 @@ func TestAttachDisconnect(t *testing.T) {
 	// We closed stdin, expect /bin/cat to still be running
 	// Wait a little bit to make sure container.monitor() did his thing
 	err := container.WaitTimeout(500 * time.Millisecond)
-	if err == nil || !container.State.IsRunning() {
+	if err == nil || !container.State.Running {
 		t.Fatalf("/bin/cat is not running after closing stdin")
 	}

@@ -677,10 +545,9 @@ func TestAttachDisconnect(t *testing.T) {

 // Expected behaviour: container gets deleted automatically after exit
 func TestRunAutoRemove(t *testing.T) {
-	t.Skip("Fixme. Skipping test for now, race condition")
 	stdout, stdoutPipe := io.Pipe()
-	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
+	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)

 	c := make(chan struct{})
 	go func() {
@@ -702,7 +569,7 @@ func TestRunAutoRemove(t *testing.T) {
 		}
 	})

-	setTimeout(t, "CmdRun timed out", 10*time.Second, func() {
+	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
 		<-c
 	})

@@ -712,231 +579,3 @@ func TestRunAutoRemove(t *testing.T) {
 		t.Fatalf("failed to remove container automatically: container %s still exists", temporaryContainerID)
 	}
 }
-
-func TestCmdLogs(t *testing.T) {
-	cli := docker.NewDockerCli(nil, ioutil.Discard, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
-
-	if err := cli.CmdRun(unitTestImageID, "sh", "-c", "ls -l"); err != nil {
-		t.Fatal(err)
-	}
-	if err := cli.CmdRun("-t", unitTestImageID, "sh", "-c", "ls -l"); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := cli.CmdLogs(globalRuntime.List()[0].ID); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Expected behaviour: using / as a bind mount source should throw an error
-func TestRunErrorBindMountRootSource(t *testing.T) {
-
-	cli := docker.NewDockerCli(nil, nil, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
-
-	c := make(chan struct{})
-	go func() {
-		defer close(c)
-		if err := cli.CmdRun("-v", "/:/tmp", unitTestImageID, "echo 'should fail'"); err == nil {
-			t.Fatal("should have failed to run when using / as a source for the bind mount")
-		}
-	}()
-
-	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
-		<-c
-	})
-}
-
-// Expected behaviour: error out when attempting to bind mount non-existing source paths
-func TestRunErrorBindNonExistingSource(t *testing.T) {
-
-	cli := docker.NewDockerCli(nil, nil, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
-
-	c := make(chan struct{})
-	go func() {
-		defer close(c)
-		if err := cli.CmdRun("-v", "/i/dont/exist:/tmp", unitTestImageID, "echo 'should fail'"); err == nil {
-			t.Fatal("should have failed to run when using /i/dont/exist as a source for the bind mount")
-		}
-	}()
-
-	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
-		<-c
-	})
-}
-
-func TestImagesViz(t *testing.T) {
-	stdout, stdoutPipe := io.Pipe()
-
-	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
-
-	image := buildTestImages(t, globalEngine)
-
-	c := make(chan struct{})
-	go func() {
-		defer close(c)
-		if err := cli.CmdImages("-viz"); err != nil {
-			t.Fatal(err)
-		}
-		stdoutPipe.Close()
-	}()
-
-	setTimeout(t, "Reading command output time out", 2*time.Second, func() {
-		cmdOutputBytes, err := ioutil.ReadAll(bufio.NewReader(stdout))
-		if err != nil {
-			t.Fatal(err)
-		}
-		cmdOutput := string(cmdOutputBytes)
-
-		regexpStrings := []string{
-			"digraph docker {",
-			fmt.Sprintf("base -> \"%s\" \\[style=invis]", unitTestImageIDShort),
-			fmt.Sprintf("label=\"%s\\\\n%s:latest\"", unitTestImageIDShort, unitTestImageName),
-			fmt.Sprintf("label=\"%s\\\\n%s:%s\"", utils.TruncateID(image.ID), "test", "latest"),
-			"base \\[style=invisible]",
-		}
-
-		compiledRegexps := []*regexp.Regexp{}
-		for _, regexpString := range regexpStrings {
-			regexp, err := regexp.Compile(regexpString)
-			if err != nil {
-				fmt.Println("Error in regex string: ", err)
-				return
-			}
-			compiledRegexps = append(compiledRegexps, regexp)
-		}
-
-		for _, regexp := range compiledRegexps {
-			if !regexp.MatchString(cmdOutput) {
-				t.Fatalf("images -viz content '%s' did not match regexp '%s'", cmdOutput, regexp)
-			}
-		}
-	})
-}
-
-func TestImagesTree(t *testing.T) {
-	stdout, stdoutPipe := io.Pipe()
-
-	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
-
-	image := buildTestImages(t, globalEngine)
-
-	c := make(chan struct{})
-	go func() {
-		defer close(c)
-		if err := cli.CmdImages("-tree"); err != nil {
-			t.Fatal(err)
-		}
-		stdoutPipe.Close()
-	}()
-
-	setTimeout(t, "Reading command output time out", 2*time.Second, func() {
-		cmdOutputBytes, err := ioutil.ReadAll(bufio.NewReader(stdout))
-		if err != nil {
-			t.Fatal(err)
-		}
-		cmdOutput := string(cmdOutputBytes)
-		regexpStrings := []string{
-			fmt.Sprintf("└─%s Size: (\\d+.\\d+ MB) \\(virtual \\d+.\\d+ MB\\) Tags: %s:latest", unitTestImageIDShort, unitTestImageName),
-			"(?m)   └─[0-9a-f]+.*",
-			"(?m)    └─[0-9a-f]+.*",
-			"(?m)      └─[0-9a-f]+.*",
-			fmt.Sprintf("(?m)^        └─%s Size: \\d+.\\d+ MB \\(virtual \\d+.\\d+ MB\\) Tags: test:latest", utils.TruncateID(image.ID)),
-		}
-
-		compiledRegexps := []*regexp.Regexp{}
-		for _, regexpString := range regexpStrings {
-			regexp, err := regexp.Compile(regexpString)
-			if err != nil {
-				fmt.Println("Error in regex string: ", err)
-				return
-			}
-			compiledRegexps = append(compiledRegexps, regexp)
-		}
-
-		for _, regexp := range compiledRegexps {
-			if !regexp.MatchString(cmdOutput) {
-				t.Fatalf("images -tree content '%s' did not match regexp '%s'", cmdOutput, regexp)
-			}
-		}
-	})
-}
-
-func buildTestImages(t *testing.T, eng *engine.Engine) *docker.Image {
-
-	var testBuilder = testContextTemplate{
-		`
-from   {IMAGE}
-run    sh -c 'echo root:testpass > /tmp/passwd'
-run    mkdir -p /var/run/sshd
-run    [ "$(cat /tmp/passwd)" = "root:testpass" ]
-run    [ "$(ls -d /var/run/sshd)" = "/var/run/sshd" ]
-`,
-		nil,
-		nil,
-	}
-	image := buildImage(testBuilder, t, eng, true)
-
-	err := mkServerFromEngine(eng, t).ContainerTag(image.ID, "test", "latest", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return image
-}
-
-// #2098 - Docker cidFiles only contain short version of the containerId
-//sudo docker run -cidfile /tmp/docker_test.cid ubuntu echo "test"
-// TestRunCidFile tests that run -cidfile returns the longid
-func TestRunCidFile(t *testing.T) {
-	stdout, stdoutPipe := io.Pipe()
-
-	tmpDir, err := ioutil.TempDir("", "TestRunCidFile")
-	if err != nil {
-		t.Fatal(err)
-	}
-	tmpCidFile := path.Join(tmpDir, "cid")
-
-	cli := docker.NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
-	defer cleanup(globalEngine, t)
-
-	c := make(chan struct{})
-	go func() {
-		defer close(c)
-		if err := cli.CmdRun("-cidfile", tmpCidFile, unitTestImageID, "ls"); err != nil {
-			t.Fatal(err)
-		}
-	}()
-
-	defer os.RemoveAll(tmpDir)
-	setTimeout(t, "Reading command output time out", 2*time.Second, func() {
-		cmdOutput, err := bufio.NewReader(stdout).ReadString('\n')
-		if err != nil {
-			t.Fatal(err)
-		}
-		if len(cmdOutput) < 1 {
-			t.Fatalf("'ls' should return something , not '%s'", cmdOutput)
-		}
-		//read the tmpCidFile
-		buffer, err := ioutil.ReadFile(tmpCidFile)
-		if err != nil {
-			t.Fatal(err)
-		}
-		id := string(buffer)
-
-		if len(id) != len("2bf44ea18873287bd9ace8a4cb536a7cbe134bed67e805fdf2f58a57f69b320c") {
-			t.Fatalf("-cidfile should be a long id, not '%s'", id)
-		}
-		//test that its a valid cid? (though the container is gone..)
-		//remove the file and dir.
-	})
-
-	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
-		<-c
-	})
-
-}
@@ -1,43 +1,17 @@
 package docker

 import (
-	"github.com/dotcloud/docker/engine"
 	"net"
 )

-// FIXME: separate runtime configuration from http api configuration
 type DaemonConfig struct {
-	Pidfile                     string
-	Root                        string
-	AutoRestart                 bool
-	EnableCors                  bool
-	Dns                         []string
-	EnableIptables              bool
-	BridgeIface                 string
-	DefaultIp                   net.IP
-	InterContainerCommunication bool
-	GraphDriver                 string
-}
-
-// ConfigFromJob creates and returns a new DaemonConfig object
-// by parsing the contents of a job's environment.
-func ConfigFromJob(job *engine.Job) *DaemonConfig {
-	var config DaemonConfig
-	config.Pidfile = job.Getenv("Pidfile")
-	config.Root = job.Getenv("Root")
-	config.AutoRestart = job.GetenvBool("AutoRestart")
-	config.EnableCors = job.GetenvBool("EnableCors")
-	if dns := job.Getenv("Dns"); dns != "" {
-		config.Dns = []string{dns}
-	}
-	config.EnableIptables = job.GetenvBool("EnableIptables")
-	if br := job.Getenv("BridgeIface"); br != "" {
-		config.BridgeIface = br
-	} else {
-		config.BridgeIface = DefaultNetworkBridge
-	}
-	config.DefaultIp = net.ParseIP(job.Getenv("DefaultIp"))
-	config.InterContainerCommunication = job.GetenvBool("InterContainerCommunication")
-	config.GraphDriver = job.Getenv("GraphDriver")
-	return &config
+	Pidfile        string
+	GraphPath      string
+	ProtoAddresses []string
+	AutoRestart    bool
+	EnableCors     bool
+	Dns            []string
+	EnableIptables bool
+	BridgeIface    string
+	DefaultIp      net.IP
 }
@@ -1,149 +0,0 @@
-package docker
-
-import (
-	"testing"
-)
-
-func TestCompareConfig(t *testing.T) {
-	volumes1 := make(map[string]struct{})
-	volumes1["/test1"] = struct{}{}
-	config1 := Config{
-		Dns:         []string{"1.1.1.1", "2.2.2.2"},
-		PortSpecs:   []string{"1111:1111", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "11111111",
-		Volumes:     volumes1,
-	}
-	config2 := Config{
-		Dns:         []string{"0.0.0.0", "2.2.2.2"},
-		PortSpecs:   []string{"1111:1111", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "11111111",
-		Volumes:     volumes1,
-	}
-	config3 := Config{
-		Dns:         []string{"1.1.1.1", "2.2.2.2"},
-		PortSpecs:   []string{"0000:0000", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "11111111",
-		Volumes:     volumes1,
-	}
-	config4 := Config{
-		Dns:         []string{"1.1.1.1", "2.2.2.2"},
-		PortSpecs:   []string{"0000:0000", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "22222222",
-		Volumes:     volumes1,
-	}
-	volumes2 := make(map[string]struct{})
-	volumes2["/test2"] = struct{}{}
-	config5 := Config{
-		Dns:         []string{"1.1.1.1", "2.2.2.2"},
-		PortSpecs:   []string{"0000:0000", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "11111111",
-		Volumes:     volumes2,
-	}
-	if CompareConfig(&config1, &config2) {
-		t.Fatalf("CompareConfig should return false, Dns are different")
-	}
-	if CompareConfig(&config1, &config3) {
-		t.Fatalf("CompareConfig should return false, PortSpecs are different")
-	}
-	if CompareConfig(&config1, &config4) {
-		t.Fatalf("CompareConfig should return false, VolumesFrom are different")
-	}
-	if CompareConfig(&config1, &config5) {
-		t.Fatalf("CompareConfig should return false, Volumes are different")
-	}
-	if !CompareConfig(&config1, &config1) {
-		t.Fatalf("CompareConfig should return true")
-	}
-}
-
-func TestMergeConfig(t *testing.T) {
-	volumesImage := make(map[string]struct{})
-	volumesImage["/test1"] = struct{}{}
-	volumesImage["/test2"] = struct{}{}
-	configImage := &Config{
-		Dns:         []string{"1.1.1.1", "2.2.2.2"},
-		PortSpecs:   []string{"1111:1111", "2222:2222"},
-		Env:         []string{"VAR1=1", "VAR2=2"},
-		VolumesFrom: "1111",
-		Volumes:     volumesImage,
-	}
-
-	volumesUser := make(map[string]struct{})
-	volumesUser["/test3"] = struct{}{}
-	configUser := &Config{
-		Dns:       []string{"3.3.3.3"},
-		PortSpecs: []string{"3333:2222", "3333:3333"},
-		Env:       []string{"VAR2=3", "VAR3=3"},
-		Volumes:   volumesUser,
-	}
-
-	if err := MergeConfig(configUser, configImage); err != nil {
-		t.Error(err)
-	}
-
-	if len(configUser.Dns) != 3 {
-		t.Fatalf("Expected 3 dns, 1.1.1.1, 2.2.2.2 and 3.3.3.3, found %d", len(configUser.Dns))
-	}
-	for _, dns := range configUser.Dns {
-		if dns != "1.1.1.1" && dns != "2.2.2.2" && dns != "3.3.3.3" {
-			t.Fatalf("Expected 1.1.1.1 or 2.2.2.2 or 3.3.3.3, found %s", dns)
-		}
-	}
-
-	if len(configUser.ExposedPorts) != 3 {
-		t.Fatalf("Expected 3 ExposedPorts, 1111, 2222 and 3333, found %d", len(configUser.ExposedPorts))
-	}
-	for portSpecs := range configUser.ExposedPorts {
-		if portSpecs.Port() != "1111" && portSpecs.Port() != "2222" && portSpecs.Port() != "3333" {
-			t.Fatalf("Expected 1111 or 2222 or 3333, found %s", portSpecs)
-		}
-	}
-	if len(configUser.Env) != 3 {
-		t.Fatalf("Expected 3 env var, VAR1=1, VAR2=3 and VAR3=3, found %d", len(configUser.Env))
-	}
-	for _, env := range configUser.Env {
-		if env != "VAR1=1" && env != "VAR2=3" && env != "VAR3=3" {
-			t.Fatalf("Expected VAR1=1 or VAR2=3 or VAR3=3, found %s", env)
-		}
-	}
-
-	if len(configUser.Volumes) != 3 {
-		t.Fatalf("Expected 3 volumes, /test1, /test2 and /test3, found %d", len(configUser.Volumes))
-	}
-	for v := range configUser.Volumes {
-		if v != "/test1" && v != "/test2" && v != "/test3" {
-			t.Fatalf("Expected /test1 or /test2 or /test3, found %s", v)
-		}
-	}
-
-	if configUser.VolumesFrom != "1111" {
-		t.Fatalf("Expected VolumesFrom to be 1111, found %s", configUser.VolumesFrom)
-	}
-
-	ports, _, err := parsePortSpecs([]string{"0000"})
-	if err != nil {
-		t.Error(err)
-	}
-	configImage2 := &Config{
-		ExposedPorts: ports,
-	}
-
-	if err := MergeConfig(configUser, configImage2); err != nil {
-		t.Error(err)
-	}
-
-	if len(configUser.ExposedPorts) != 4 {
-		t.Fatalf("Expected 4 ExposedPorts, 0000, 1111, 2222 and 3333, found %d", len(configUser.ExposedPorts))
-	}
-	for portSpecs := range configUser.ExposedPorts {
-		if portSpecs.Port() != "0000" && portSpecs.Port() != "1111" && portSpecs.Port() != "2222" && portSpecs.Port() != "3333" {
-			t.Fatalf("Expected 0000 or 1111 or 2222 or 3333, found %s", portSpecs)
-		}
-	}
-
-}
@@ -1,161 +0,0 @@
-package docker
-
-import (
-	"testing"
-)
-
-func TestParseLxcConfOpt(t *testing.T) {
-	opts := []string{"lxc.utsname=docker", "lxc.utsname = docker "}
-
-	for _, o := range opts {
-		k, v, err := parseLxcOpt(o)
-		if err != nil {
-			t.FailNow()
-		}
-		if k != "lxc.utsname" {
-			t.Fail()
-		}
-		if v != "docker" {
-			t.Fail()
-		}
-	}
-}
-
-func TestParseNetworkOptsPrivateOnly(t *testing.T) {
-	ports, bindings, err := parsePortSpecs([]string{"192.168.1.100::80"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(ports) != 1 {
-		t.Logf("Expected 1 got %d", len(ports))
-		t.FailNow()
-	}
-	if len(bindings) != 1 {
-		t.Logf("Expected 1 got %d", len(bindings))
-		t.FailNow()
-	}
-	for k := range ports {
-		if k.Proto() != "tcp" {
-			t.Logf("Expected tcp got %s", k.Proto())
-			t.Fail()
-		}
-		if k.Port() != "80" {
-			t.Logf("Expected 80 got %s", k.Port())
-			t.Fail()
-		}
-		b, exists := bindings[k]
-		if !exists {
-			t.Log("Binding does not exist")
-			t.FailNow()
-		}
-		if len(b) != 1 {
-			t.Logf("Expected 1 got %d", len(b))
-			t.FailNow()
-		}
-		s := b[0]
-		if s.HostPort != "" {
-			t.Logf("Expected \"\" got %s", s.HostPort)
-			t.Fail()
-		}
-		if s.HostIp != "192.168.1.100" {
-			t.Fail()
-		}
-	}
-}
-
-func TestParseNetworkOptsPublic(t *testing.T) {
-	ports, bindings, err := parsePortSpecs([]string{"192.168.1.100:8080:80"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(ports) != 1 {
-		t.Logf("Expected 1 got %d", len(ports))
-		t.FailNow()
-	}
-	if len(bindings) != 1 {
-		t.Logf("Expected 1 got %d", len(bindings))
-		t.FailNow()
-	}
-	for k := range ports {
-		if k.Proto() != "tcp" {
-			t.Logf("Expected tcp got %s", k.Proto())
-			t.Fail()
-		}
-		if k.Port() != "80" {
-			t.Logf("Expected 80 got %s", k.Port())
-			t.Fail()
-		}
-		b, exists := bindings[k]
-		if !exists {
-			t.Log("Binding does not exist")
-			t.FailNow()
-		}
-		if len(b) != 1 {
-			t.Logf("Expected 1 got %d", len(b))
-			t.FailNow()
-		}
-		s := b[0]
-		if s.HostPort != "8080" {
-			t.Logf("Expected 8080 got %s", s.HostPort)
-			t.Fail()
-		}
-		if s.HostIp != "192.168.1.100" {
-			t.Fail()
-		}
-	}
-}
-
-func TestParseNetworkOptsUdp(t *testing.T) {
-	ports, bindings, err := parsePortSpecs([]string{"192.168.1.100::6000/udp"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(ports) != 1 {
-		t.Logf("Expected 1 got %d", len(ports))
-		t.FailNow()
-	}
-	if len(bindings) != 1 {
-		t.Logf("Expected 1 got %d", len(bindings))
-		t.FailNow()
-	}
-	for k := range ports {
-		if k.Proto() != "udp" {
-			t.Logf("Expected udp got %s", k.Proto())
-			t.Fail()
-		}
-		if k.Port() != "6000" {
-			t.Logf("Expected 6000 got %s", k.Port())
-			t.Fail()
-		}
-		b, exists := bindings[k]
-		if !exists {
-			t.Log("Binding does not exist")
-			t.FailNow()
-		}
-		if len(b) != 1 {
-			t.Logf("Expected 1 got %d", len(b))
-			t.FailNow()
-		}
-		s := b[0]
-		if s.HostPort != "" {
-			t.Logf("Expected \"\" got %s", s.HostPort)
-			t.Fail()
-		}
-		if s.HostIp != "192.168.1.100" {
-			t.Fail()
-		}
-	}
-}
-
-func TestGetFullName(t *testing.T) {
-	name, err := getFullName("testing")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if name != "/testing" {
-		t.Fatalf("Expected /testing got %s", name)
-	}
-	if _, err := getFullName(""); err == nil {
-		t.Fatal("Error should not be nil")
-	}
-}
@@ -1,23 +0,0 @@
-# [PackageDev] target_format: plist, ext: tmLanguage
---
-name: Dockerfile
-scopeName: source.dockerfile
-uuid: a39d8795-59d2-49af-aa00-fe74ee29576e
-
-patterns:
-# Keywords
- name: keyword.control.dockerfile
-  match: ^\s*(FROM|MAINTAINER|RUN|CMD|EXPOSE|ENV|ADD)\s
- name: keyword.operator.dockerfile
-  match: ^\s*(ENTRYPOINT|VOLUME|USER|WORKDIR)\s
-# String
- name: string.quoted.double.dockerfile
-  begin: "\""
-  end: "\""
-  patterns:
-  - name: constant.character.escaped.dockerfile
-    match: \\.
-# Comment
- name: comment.block.dockerfile
-  match: ^\s*#.*$
-...
@@ -1,50 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>name</key>
-	<string>Dockerfile</string>
-	<key>patterns</key>
-	<array>
-		<dict>
-			<key>match</key>
-			<string>^\s*(FROM|MAINTAINER|RUN|CMD|EXPOSE|ENV|ADD)\s</string>
-			<key>name</key>
-			<string>keyword.control.dockerfile</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>^\s*(ENTRYPOINT|VOLUME|USER|WORKDIR)\s</string>
-			<key>name</key>
-			<string>keyword.operator.dockerfile</string>
-		</dict>
-		<dict>
-			<key>begin</key>
-			<string>"</string>
-			<key>end</key>
-			<string>"</string>
-			<key>name</key>
-			<string>string.quoted.double.dockerfile</string>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>match</key>
-					<string>\\.</string>
-					<key>name</key>
-					<string>constant.character.escaped.dockerfile</string>
-				</dict>
-			</array>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>^\s*#.*$</string>
-			<key>name</key>
-			<string>comment.block.dockerfile</string>
-		</dict>
-	</array>
-	<key>scopeName</key>
-	<string>source.dockerfile</string>
-	<key>uuid</key>
-	<string>a39d8795-59d2-49af-aa00-fe74ee29576e</string>
-</dict>
-</plist>
@@ -1 +0,0 @@
-Asbjorn Enge <asbjorn@hanafjedle.net> (@asbjornenge)
@@ -1,9 +0,0 @@
-# Dockerfile.tmLanguage
-
-Pretty basic Dockerfile.tmLanguage for Sublime Text syntax highlighting.
-
-PR's with syntax updates, suggestions etc. are all very much appreciated!
-
-I'll get to making this installable via Package Control soon!
-
-enjoy.
@@ -1 +1,2 @@
+Kawsar Saiyeed <kawsar.saiyeed@projiris.com> (@KSid)
 Tianon Gravi <admwiggin@gmail.com> (@tianon)
@@ -0,0 +1 @@
+*.pyc
@@ -0,0 +1,78 @@
+# docker-brew
+
+docker-brew is a command-line tool used to build the docker standard library.
+
+## Install instructions
+
+1. Install python if it isn't already available on your OS of choice
+1. Install the easy_install tool (`sudo apt-get install python-setuptools`
+for Debian)
+1. Install the python package manager, `pip` (`easy_install pip`)
+1. Run the following command: `sudo pip install -r requirements.txt`
+1. You should now be able to use the `docker-brew` script as such.
+
+## Basics
+
+	./docker-brew -h
+
+Display usage and help.
+
+	./docker-brew
+
+Default build from the default repo/branch. Images will be created under the
+`library/` namespace. Does not perform a remote push.
+
+	./docker-brew -n mycorp.com -b stable --push git://github.com/mycorp/docker
+
+Will fetch the library definition files in the `stable` branch of the
+`git://github.com/mycorp/docker` repository and create images under the
+`mycorp.com` namespace (e.g. `mycorp.com/ubuntu`). Created images will then
+be pushed to the official docker repository (pending: support for private
+repositories)
+
+## Library definition files
+
+The library definition files are plain text files found in the `library/`
+subfolder of the docker repository.
+
+### File names
+
+The name of a definition file will determine the name of the image(s) it
+creates. For example, the `library/ubuntu` file will create images in the
+`<namespace>/ubuntu` repository. If multiple instructions are present in
+a single file, all images are expected to be created under a different tag.
+
+### Instruction format
+
+Each line represents a build instruction.
+There are different formats that `docker-brew` is able to parse.
+
+	<git-url>
+	git://github.com/dotcloud/hipache
+	https://github.com/dotcloud/docker.git
+
+The simplest format. `docker-brew` will fetch data from the provided git
+repository from the `HEAD`of its `master` branch. Generated image will be
+tagged as `latest`. Use of this format is discouraged because there is no
+way to ensure stability.
+
+	<docker-tag> <git-url>
+	bleeding-edge git://github.com/dotcloud/docker
+	unstable https://github.com/dotcloud/docker-redis.git
+
+A more advanced format. `docker-brew` will fetch data from the provided git
+repository from the `HEAD`of its `master` branch. Generated image will be
+tagged as `<docker-tag>`. Recommended if we always want to provide a snapshot
+of the latest development. Again, no way to ensure stability.
+
+	<docker-tag>	<git-url>	T:<git-tag>
+	2.4.0 	git://github.com/dotcloud/docker-redis	T:2.4.0
+	<docker-tag>	<git-url>	B:<git-branch>
+	zfs		git://github.com/dotcloud/docker	B:zfs-support
+	<docker-tag>	<git-url>	C:<git-commit-id>
+	2.2.0 	https://github.com/dotcloud/docker-redis.git C:a4bf8923ee4ec566d3ddc212
+
+The most complete format. `docker-brew` will fetch data from the provided git
+repository from the provided reference (if it's a branch, brew will fetch its
+`HEAD`). Generated image will be tagged as `<docker-tag>`. Recommended whenever
+possible.
@@ -0,0 +1 @@
+from brew import build_library, DEFAULT_REPOSITORY, DEFAULT_BRANCH
@@ -0,0 +1,185 @@
+import os
+import logging
+from shutil import rmtree
+
+import docker
+
+import git
+
+DEFAULT_REPOSITORY = 'git://github.com/dotcloud/docker'
+DEFAULT_BRANCH = 'master'
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
+                    level='INFO')
+client = docker.Client()
+processed = {}
+processed_folders = []
+
+
+def build_library(repository=None, branch=None, namespace=None, push=False,
+        debug=False, prefill=True, registry=None):
+    dst_folder = None
+    summary = Summary()
+    if repository is None:
+        repository = DEFAULT_REPOSITORY
+    if branch is None:
+        branch = DEFAULT_BRANCH
+    if debug:
+        logger.setLevel('DEBUG')
+
+    if not (repository.startswith('https://') or repository.startswith('git://')):
+        logger.info('Repository provided assumed to be a local path')
+        dst_folder = repository
+
+    try:
+        client.version()
+    except Exception as e:
+        logger.error('Could not reach the docker daemon. Please make sure it '
+            'is running.')
+        logger.warning('Also make sure you have access to the docker UNIX '
+            'socket (use sudo)')
+        return
+
+    #FIXME: set destination folder and only pull latest changes instead of
+    # cloning the whole repo everytime
+    if not dst_folder:
+        logger.info('Cloning docker repo from {0}, branch: {1}'.format(
+            repository, branch))
+        try:
+            rep, dst_folder = git.clone_branch(repository, branch)
+        except Exception as e:
+            logger.exception(e)
+            logger.error('Source repository could not be fetched. Check '
+                'that the address is correct and the branch exists.')
+            return
+    try:
+        dirlist = os.listdir(os.path.join(dst_folder, 'library'))
+    except OSError as e:
+        logger.error('The path provided ({0}) could not be found or didn\'t'
+            'contain a library/ folder.'.format(dst_folder))
+        return
+    for buildfile in dirlist:
+        if buildfile == 'MAINTAINERS':
+            continue
+        f = open(os.path.join(dst_folder, 'library', buildfile))
+        linecnt = 0
+        for line in f:
+            linecnt = linecnt + 1
+            logger.debug('{0} ---> {1}'.format(buildfile, line))
+            args = line.split()
+            try:
+                if len(args) > 3:
+                    raise RuntimeError('Incorrect line format, '
+                        'please refer to the docs')
+
+                url = None
+                ref = 'refs/heads/master'
+                tag = None
+                if len(args) == 1:  # Just a URL, simple mode
+                    url = args[0]
+                elif len(args) == 2 or len(args) == 3:  # docker-tag   url
+                    url = args[1]
+                    tag = args[0]
+
+                if len(args) == 3:  # docker-tag  url     B:branch or T:tag
+                    ref = None
+                    if args[2].startswith('B:'):
+                        ref = 'refs/heads/' + args[2][2:]
+                    elif args[2].startswith('T:'):
+                        ref = 'refs/tags/' + args[2][2:]
+                    elif args[2].startswith('C:'):
+                        ref = args[2][2:]
+                    else:
+                        raise RuntimeError('Incorrect line format, '
+                            'please refer to the docs')
+                if prefill:
+                    logger.debug('Pulling {0} from official repository (cache '
+                        'fill)'.format(buildfile))
+                    client.pull(buildfile)
+                img = build_repo(url, ref, buildfile, tag, namespace, push,
+                    registry)
+                summary.add_success(buildfile, (linecnt, line), img)
+                processed['{0}@{1}'.format(url, ref)] = img
+            except Exception as e:
+                logger.exception(e)
+                summary.add_exception(buildfile, (linecnt, line), e)
+
+        f.close()
+    if dst_folder != repository:
+        rmtree(dst_folder, True)
+    for d in processed_folders:
+        rmtree(d, True)
+    summary.print_summary(logger)
+
+
+def build_repo(repository, ref, docker_repo, docker_tag, namespace, push, registry):
+    docker_repo = '{0}/{1}'.format(namespace or 'library', docker_repo)
+    img_id = None
+    dst_folder = None
+    if '{0}@{1}'.format(repository, ref) not in processed.keys():
+        logger.info('Cloning {0} (ref: {1})'.format(repository, ref))
+        if repository not in processed:
+            rep, dst_folder = git.clone(repository, ref)
+            processed[repository] = rep
+            processed_folders.append(dst_folder)
+        else:
+            dst_folder = git.checkout(processed[repository], ref)
+        if not 'Dockerfile' in os.listdir(dst_folder):
+            raise RuntimeError('Dockerfile not found in cloned repository')
+        logger.info('Building using dockerfile...')
+        img_id, logs = client.build(path=dst_folder, quiet=True)
+    else:
+        img_id = processed['{0}@{1}'.format(repository, ref)]
+    logger.info('Committing to {0}:{1}'.format(docker_repo,
+        docker_tag or 'latest'))
+    client.tag(img_id, docker_repo, docker_tag)
+    if push:
+        logger.info('Pushing result to registry {0}'.format(
+            registry or "default"))
+        if registry is not None:
+            docker_repo = '{0}/{1}'.format(registry, docker_repo)
+            logger.info('Also tagging {0}'.format(docker_repo))
+            client.tag(img_id, docker_repo, docker_tag)
+        client.push(docker_repo)
+    return img_id
+
+
+class Summary(object):
+    def __init__(self):
+        self._summary = {}
+        self._has_exc = False
+
+    def _add_data(self, image, linestr, data):
+        if image not in self._summary:
+            self._summary[image] = { linestr: data }
+        else:
+            self._summary[image][linestr] = data
+
+    def add_exception(self, image, line, exc):
+        lineno, linestr = line
+        self._add_data(image, linestr, { 'line': lineno, 'exc': str(exc) })
+        self._has_exc = True
+
+    def add_success(self, image, line, img_id):
+        lineno, linestr = line
+        self._add_data(image, linestr, { 'line': lineno, 'id': img_id })
+
+    def print_summary(self, logger=None):
+        linesep = ''.center(61, '-') + '\n'
+        s = 'BREW BUILD SUMMARY\n' + linesep
+        success = 'OVERALL SUCCESS: {}\n'.format(not self._has_exc)
+        details = linesep
+        for image, lines in self._summary.iteritems():
+            details = details + '{}\n{}'.format(image, linesep)
+            for linestr, data in lines.iteritems():
+                details = details + '{0:2} | {1} | {2:50}\n'.format(
+                    data['line'],
+                    'KO' if 'exc' in data else 'OK',
+                    data['exc'] if 'exc' in data else data['id']
+                )
+            details = details + linesep
+        if logger:
+            logger.info(s + success + details)
+        else:
+            print s, success, details
@@ -0,0 +1,63 @@
+import tempfile
+import logging
+
+from dulwich import index
+from dulwich.client import get_transport_and_path
+from dulwich.repo import Repo
+
+logger = logging.getLogger(__name__)
+
+
+def clone_branch(repo_url, branch="master", folder=None):
+    return clone(repo_url, 'refs/heads/' + branch, folder)
+
+
+def clone_tag(repo_url, tag, folder=None):
+    return clone(repo_url, 'refs/tags/' + tag, folder)
+
+
+def checkout(rep, ref=None):
+    is_commit = False
+    if ref is None:
+        ref = 'refs/heads/master'
+    elif not ref.startswith('refs/'):
+        is_commit = True
+    if is_commit:
+        rep['HEAD'] = rep.commit(ref)
+    else:
+        rep['HEAD'] = rep.refs[ref]
+    indexfile = rep.index_path()
+    tree = rep["HEAD"].tree
+    index.build_index_from_tree(rep.path, indexfile, rep.object_store, tree)
+    return rep.path
+
+def clone(repo_url, ref=None, folder=None):
+    is_commit = False
+    if ref is None:
+        ref = 'refs/heads/master'
+    elif not ref.startswith('refs/'):
+        is_commit = True
+    logger.debug("clone repo_url={0}, ref={1}".format(repo_url, ref))
+    if folder is None:
+        folder = tempfile.mkdtemp()
+    logger.debug("folder = {0}".format(folder))
+    rep = Repo.init(folder)
+    client, relative_path = get_transport_and_path(repo_url)
+    logger.debug("client={0}".format(client))
+
+    remote_refs = client.fetch(relative_path, rep)
+    for k, v in remote_refs.iteritems():
+        try:
+            rep.refs.add_if_new(k, v)
+        except:
+            pass
+
+    if is_commit:
+        rep['HEAD'] = rep.commit(ref)
+    else:
+        rep['HEAD'] = remote_refs[ref]
+    indexfile = rep.index_path()
+    tree = rep["HEAD"].tree
+    index.build_index_from_tree(rep.path, indexfile, rep.object_store, tree)
+    logger.debug("done")
+    return rep, folder
@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+
+import argparse
+import sys
+
+try:
+    import brew
+except ImportError as e:
+    print str(e)
+    print 'Please install the required dependencies first'
+    print 'sudo pip install -r requirements.txt'
+    sys.exit(1)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser('Build the docker standard library')
+    parser.add_argument('--push', action='store_true', default=False,
+        help='Push generated repositories')
+    parser.add_argument('--debug', default=False, action='store_true',
+        help='Enable debugging output')
+    parser.add_argument('--noprefill', default=True, action='store_false',
+        dest='prefill', help='Disable cache prefill')
+    parser.add_argument('-n', metavar='NAMESPACE', default='library',
+        help='Namespace used for generated repositories.'
+        ' Default is library')
+    parser.add_argument('-b', metavar='BRANCH', default=brew.DEFAULT_BRANCH,
+        help='Branch in the repository where the library definition'
+        ' files will be fetched. Default is ' + brew.DEFAULT_BRANCH)
+    parser.add_argument('repository', default=brew.DEFAULT_REPOSITORY,
+        nargs='?', help='git repository containing the library definition'
+        ' files. Default is ' + brew.DEFAULT_REPOSITORY)
+    parser.add_argument('--reg', default=None, help='Registry address to'
+        ' push build results to. Also sets push to true.')
+    args = parser.parse_args()
+    brew.build_library(args.repository, args.b, args.n,
+        args.push or args.reg is not None, args.debug, args.prefill, args.reg)
@@ -0,0 +1,2 @@
+dulwich==0.9.0
+-e git://github.com/dotcloud/docker-py.git#egg=docker-py
@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+import os
+from setuptools import setup
+
+ROOT_DIR = os.path.dirname(__file__)
+SOURCE_DIR = os.path.join(ROOT_DIR)
+
+test_requirements = []
+setup(
+    name="docker-brew",
+    version='0.0.1',
+    description="-",
+    packages=['dockerbrew'],
+    install_requires=['dulwich', 'docker'] + test_requirements,
+    zip_safe=False,
+    classifiers=['Development Status :: 3 - Alpha',
+                 'Environment :: Other Environment',
+                 'Intended Audience :: Developers',
+                 'Operating System :: OS Independent',
+                 'Programming Language :: Python',
+                 'Topic :: Utilities'],
+    )
@@ -1,242 +0,0 @@
-#compdef docker 
-#
-# zsh completion for docker (http://docker.io)
-#
-# version:  0.2.2
-# author:   Felix Riedel
-# license:  BSD License
-# github:   https://github.com/felixr/docker-zsh-completion
-#
-
-__parse_docker_list() {
-    sed -e '/^ID/d' -e 's/[ ]\{2,\}/|/g' -e 's/ \([hdwm]\)\(inutes\|ays\|ours\|eeks\)/\1/' | awk ' BEGIN {FS="|"} { printf("%s:%7s, %s\n", $1, $4, $2)}'
-}
-
-__docker_stoppedcontainers() {
-    local expl
-    declare -a stoppedcontainers 
-    stoppedcontainers=(${(f)"$(docker ps -a | grep --color=never 'Exit' |  __parse_docker_list )"})
-    _describe -t containers-stopped "Stopped Containers" stoppedcontainers 
-}
-
-__docker_runningcontainers() {
-    local expl
-    declare -a containers 
-
-    containers=(${(f)"$(docker ps | __parse_docker_list)"})
-    _describe -t containers-active "Running Containers" containers 
-}
-
-__docker_containers () {
-    __docker_stoppedcontainers 
-    __docker_runningcontainers
-}
-
-__docker_images () {
-    local expl
-    declare -a images
-    images=(${(f)"$(docker images | awk '(NR > 1){printf("%s\\:%s\n", $1,$2)}')"})
-    images=($images ${(f)"$(docker images | awk '(NR > 1){printf("%s:%-15s in %s\n", $3,$2,$1)}')"})
-    _describe -t docker-images "Images" images
-}
-
-__docker_tags() {
-    local expl
-    declare -a tags
-    tags=(${(f)"$(docker images | awk '(NR>1){print $2}'| sort | uniq)"})
-    _describe -t docker-tags "tags" tags
-}
-
-__docker_search() {
-    # declare -a dockersearch
-    local cache_policy
-    zstyle -s ":completion:${curcontext}:" cache-policy cache_policy
-    if [[ -z "$cache_policy" ]]; then
-        zstyle ":completion:${curcontext}:" cache-policy __docker_caching_policy 
-    fi
-
-    local searchterm cachename
-    searchterm="${words[$CURRENT]%/}"
-    cachename=_docker-search-$searchterm
-
-    local expl
-    local -a result 
-    if ( [[ ${(P)+cachename} -eq 0 ]] || _cache_invalid ${cachename#_} ) \
-        && ! _retrieve_cache ${cachename#_}; then
-        _message "Searching for ${searchterm}..."
-        result=(${(f)"$(docker search ${searchterm} | awk '(NR>2){print $1}')"})
-        _store_cache ${cachename#_} result
-    fi 
-    _wanted dockersearch expl 'Available images' compadd -a result 
-}
-
-__docker_caching_policy()
-{
-  # oldp=( "$1"(Nmh+24) )     # 24 hour
-  oldp=( "$1"(Nmh+1) )     # 24 hour
-  (( $#oldp ))
-}
-
-
-__docker_repositories () {
-    local expl
-    declare -a repos
-    repos=(${(f)"$(docker images | sed -e '1d' -e 's/[ ].*//' | sort | uniq)"})
-    _describe -t docker-repos "Repositories" repos
-}
-
-__docker_commands () {
-    # local -a  _docker_subcommands
-    local cache_policy
-
-    zstyle -s ":completion:${curcontext}:" cache-policy cache_policy
-    if [[ -z "$cache_policy" ]]; then
-        zstyle ":completion:${curcontext}:" cache-policy __docker_caching_policy 
-    fi
-
-    if ( [[ ${+_docker_subcommands} -eq 0 ]] || _cache_invalid docker_subcommands) \
-        && ! _retrieve_cache docker_subcommands; 
-    then
-        _docker_subcommands=(${${(f)"$(_call_program commands 
-        docker 2>&1 | sed -e '1,6d' -e '/^[ ]*$/d' -e 's/[ ]*\([^ ]\+\)\s*\([^ ].*\)/\1:\2/' )"}})
-        _docker_subcommands=($_docker_subcommands 'help:Show help for a command') 
-        _store_cache docker_subcommands _docker_subcommands
-    fi
-    _describe -t docker-commands "docker command" _docker_subcommands
-}
-
-__docker_subcommand () {
-    local -a _command_args
-    case "$words[1]" in
-        (attach|wait)
-            _arguments ':containers:__docker_runningcontainers'
-            ;;
-        (build)
-            _arguments \
-                '-t=-:repository:__docker_repositories' \
-                ':path or URL:_directories'
-            ;;
-        (commit)
-            _arguments \
-                ':container:__docker_containers' \
-                ':repository:__docker_repositories' \
-                ':tag: '
-            ;;
-        (diff|export|logs)
-            _arguments '*:containers:__docker_containers'
-            ;;
-        (history)
-            _arguments '*:images:__docker_images'
-            ;;
-        (images)
-            _arguments \
-                '-a[Show all images]' \
-                ':repository:__docker_repositories'
-            ;;
-        (inspect)
-            _arguments '*:containers:__docker_containers'
-            ;;
-        (history)
-            _arguments ':images:__docker_images'
-            ;;
-        (insert)
-            _arguments '1:containers:__docker_containers' \
-                       '2:URL:(http:// file://)' \
-                       '3:file:_files'
-            ;;
-        (kill)
-            _arguments '*:containers:__docker_runningcontainers'
-            ;;
-        (port)
-            _arguments '1:containers:__docker_runningcontainers'
-            ;;
-        (start)
-            _arguments '*:containers:__docker_stoppedcontainers'
-            ;;
-        (rm)
-            _arguments '-v[Remove the volumes associated to the container]' \
-                '*:containers:__docker_stoppedcontainers'
-            ;;
-        (rmi)
-            _arguments '-v[Remove the volumes associated to the container]' \
-                '*:images:__docker_images'
-            ;;
-        (top)
-            _arguments '1:containers:__docker_runningcontainers'
-            ;;
-        (restart|stop)
-            _arguments '-t=-[Number of seconds to try to stop for before killing the container]:seconds to before killing:(1 5 10 30 60)' \
-                '*:containers:__docker_runningcontainers'
-            ;;
-        (top)
-            _arguments ':containers:__docker_runningcontainers'
-            ;;
-        (ps)
-            _arguments '-a[Show all containers. Only running containers are shown by default]' \
-                '-h[Show help]' \
-                '-beforeId=-[Show only container created before Id, include non-running one]:containers:__docker_containers' \
-            '-n=-[Show n last created containers, include non-running one]:n:(1 5 10 25 50)'
-            ;;
-        (tag)
-            _arguments \
-                '-f[force]'\
-                ':image:__docker_images'\
-                ':repository:__docker_repositories' \
-                ':tag:__docker_tags'
-            ;;
-        (run)
-            _arguments \
-                '-a=-[Attach to stdin, stdout or stderr]:toggle:(true false)' \
-                '-c=-[CPU shares (relative weight)]:CPU shares: ' \
-                '-d[Detached mode: leave the container running in the background]' \
-                '*-dns=[Set custom dns servers]:dns server: ' \
-                '*-e=[Set environment variables]:environment variable: ' \
-                '-entrypoint=-[Overwrite the default entrypoint of the image]:entry point: ' \
-                '-h=-[Container host name]:hostname:_hosts' \
-                '-i[Keep stdin open even if not attached]' \
-                '-m=-[Memory limit (in bytes)]:limit: ' \
-                '*-p=-[Expose a container''s port to the host]:port:_ports' \
-                '-t=-[Allocate a pseudo-tty]:toggle:(true false)' \
-                '-u=-[Username or UID]:user:_users' \
-                '*-v=-[Bind mount a volume (e.g. from the host: -v /host:/container, from docker: -v /container)]:volume: '\
-                '-volumes-from=-[Mount volumes from the specified container]:volume: ' \
-                '(-):images:__docker_images' \
-                '(-):command: _command_names -e' \
-                '*::arguments: _normal'
-                ;;
-        (pull|search)
-            _arguments ':name:__docker_search'
-            ;;
-        (help)
-            _arguments ':subcommand:__docker_commands'
-            ;;
-        (*)
-            _message 'Unknown sub command'
-    esac
-
-}
-
-_docker () {
-    local curcontext="$curcontext" state line
-    typeset -A opt_args
-
-    _arguments -C \
-      '-H=-[tcp://host:port to bind/connect to]:socket: ' \
-         '(-): :->command' \
-         '(-)*:: :->option-or-argument' 
-
-    if (( CURRENT == 1 )); then
-
-    fi
-    case $state in 
-        (command)
-            __docker_commands
-            ;;
-        (option-or-argument)
-            curcontext=${curcontext%:*:*}:docker-$words[1]:
-            __docker_subcommand 
-            ;;
-    esac
-}
-
-_docker "$@"
@@ -1,11 +0,0 @@
-Desktop Integration
-===================
-
-The ./contrib/desktop-integration contains examples of typical dockerized
-desktop applications.
-
-Examples
-========
-
-* Data container: ./data/Dockerfile creates a data image sharing /data volume
-* Firefox: ./firefox/Dockerfile shows a way to dockerize a common multimedia application
@@ -1,38 +0,0 @@
-# VERSION:        0.1
-# DESCRIPTION:    Create data image sharing /data volume
-# AUTHOR:         Daniel Mizyrycki <daniel@dotcloud.com>
-# COMMENTS:
-#   This image is used as base for all data containers.
-#   /data volume is owned by sysadmin.
-# USAGE:
-#   # Download data Dockerfile
-#   wget http://raw.github.com/dotcloud/docker/master/contrib/desktop-integration/data/Dockerfile
-#
-#   # Build data image
-#   docker build -t data -rm .
-#
-#   # Create a data container. (eg: firefox-data)
-#   docker run -name firefox-data data true
-#
-#   # List data from it
-#   docker run -volumes-from firefox-data busybox ls -al /data
-
-docker-version 0.6.5
-
-# Smallest base image, just to launch a container
-from busybox
-maintainer	Daniel Mizyrycki <daniel@docker.com>
-
-# Create a regular user
-run echo 'sysadmin:x:1000:1000::/data:/bin/sh' >> /etc/passwd
-run echo 'sysadmin:x:1000:' >> /etc/group
-
-# Create directory for that user
-run mkdir /data
-run chown sysadmin.sysadmin /data
-
-# Add content to /data. This will keep sysadmin ownership
-run touch /data/init_volume
-
-# Create /data volume
-VOLUME /data
@@ -1,49 +0,0 @@
-# VERSION:        0.7
-# DESCRIPTION:    Create firefox container with its dependencies
-# AUTHOR:         Daniel Mizyrycki <daniel@dotcloud.com>
-# COMMENTS:
-#   This file describes how to build a Firefox container with all
-#   dependencies installed. It uses native X11 unix socket and alsa
-#   sound devices. Tested on Debian 7.2
-# USAGE:
-#   # Download Firefox Dockerfile
-#   wget http://raw.github.com/dotcloud/docker/master/contrib/desktop-integration/firefox/Dockerfile
-#
-#   # Build firefox image
-#   docker build -t firefox -rm .
-#
-#   # Run stateful data-on-host firefox. For ephemeral, remove -v /data/firefox:/data
-#   docker run -v /data/firefox:/data -v /tmp/.X11-unix:/tmp/.X11-unix \
-#     -v /dev/snd:/dev/snd -lxc-conf='lxc.cgroup.devices.allow = c 116:* rwm' \
-#     -e DISPLAY=unix$DISPLAY firefox
-#
-#   # To run stateful dockerized data containers
-#   docker run -volumes-from firefox-data -v /tmp/.X11-unix:/tmp/.X11-unix \
-#     -v /dev/snd:/dev/snd -lxc-conf='lxc.cgroup.devices.allow = c 116:* rwm' \
-#     -e DISPLAY=unix$DISPLAY firefox
-
-docker-version 0.6.5
-
-# Base docker image
-from tianon/debian:wheezy
-maintainer	Daniel Mizyrycki <daniel@docker.com>
-
-# Install firefox dependencies
-run echo "deb http://ftp.debian.org/debian/ wheezy main contrib" > /etc/apt/sources.list
-run apt-get update
-run DEBIAN_FRONTEND=noninteractive apt-get install -y libXrender1 libasound2 \
-    libdbus-glib-1-2 libgtk2.0-0 libpango1.0-0 libxt6 wget bzip2 sudo
-
-# Install Firefox
-run mkdir /application
-run cd /application; wget -O - \
-    http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/25.0/linux-x86_64/en-US/firefox-25.0.tar.bz2 | tar jx
-
-# create sysadmin account
-run useradd -m -d /data -p saIVpsc0EVTwA sysadmin
-run sed -Ei 's/sudo:x:27:/sudo:x:27:sysadmin/' /etc/group
-run sed -Ei 's/(\%sudo\s+ALL=\(ALL\:ALL\) )ALL/\1 NOPASSWD:ALL/' /etc/sudoers
-
-# Autorun firefox. -no-remote is necessary to create a new container, as firefox
-# appears to communicate with itself through X11.
-cmd ["/bin/sh", "-c", "/usr/bin/sudo -u sysadmin -H -E /application/firefox/firefox -no-remote"]
@@ -1,170 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"github.com/dotcloud/docker/graphdriver/devmapper"
-	"os"
-	"path"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-func usage() {
-	fmt.Fprintf(os.Stderr, "Usage: %s <flags>  [status] | [list] | [device id]  | [resize new-pool-size] | [snap new-id base-id] | [remove id] | [mount id mountpoint]\n", os.Args[0])
-	flag.PrintDefaults()
-	os.Exit(1)
-}
-
-func byteSizeFromString(arg string) (int64, error) {
-	digits := ""
-	rest := ""
-	last := strings.LastIndexAny(arg, "0123456789")
-	if last >= 0 {
-		digits = arg[:last+1]
-		rest = arg[last+1:]
-	}
-
-	val, err := strconv.ParseInt(digits, 10, 64)
-	if err != nil {
-		return val, err
-	}
-
-	rest = strings.ToLower(strings.TrimSpace(rest))
-
-	var multiplier int64 = 1
-	switch rest {
-	case "":
-		multiplier = 1
-	case "k", "kb":
-		multiplier = 1024
-	case "m", "mb":
-		multiplier = 1024 * 1024
-	case "g", "gb":
-		multiplier = 1024 * 1024 * 1024
-	case "t", "tb":
-		multiplier = 1024 * 1024 * 1024 * 1024
-	default:
-		return 0, fmt.Errorf("Unknown size unit: %s", rest)
-	}
-
-	return val * multiplier, nil
-}
-
-func main() {
-	root := flag.String("r", "/var/lib/docker", "Docker root dir")
-	flDebug := flag.Bool("D", false, "Debug mode")
-
-	flag.Parse()
-
-	if *flDebug {
-		os.Setenv("DEBUG", "1")
-	}
-
-	if flag.NArg() < 1 {
-		usage()
-	}
-
-	args := flag.Args()
-
-	home := path.Join(*root, "devicemapper")
-	devices, err := devmapper.NewDeviceSet(home, false)
-	if err != nil {
-		fmt.Println("Can't initialize device mapper: ", err)
-		os.Exit(1)
-	}
-
-	switch args[0] {
-	case "status":
-		status := devices.Status()
-		fmt.Printf("Pool name: %s\n", status.PoolName)
-		fmt.Printf("Data Loopback file: %s\n", status.DataLoopback)
-		fmt.Printf("Metadata Loopback file: %s\n", status.MetadataLoopback)
-		fmt.Printf("Sector size: %d\n", status.SectorSize)
-		fmt.Printf("Data use: %d of %d (%.1f %%)\n", status.Data.Used, status.Data.Total, 100.0*float64(status.Data.Used)/float64(status.Data.Total))
-		fmt.Printf("Metadata use: %d of %d (%.1f %%)\n", status.Metadata.Used, status.Metadata.Total, 100.0*float64(status.Metadata.Used)/float64(status.Metadata.Total))
-		break
-	case "list":
-		ids := devices.List()
-		sort.Strings(ids)
-		for _, id := range ids {
-			fmt.Println(id)
-		}
-		break
-	case "device":
-		if flag.NArg() < 2 {
-			usage()
-		}
-		status, err := devices.GetDeviceStatus(args[1])
-		if err != nil {
-			fmt.Println("Can't get device info: ", err)
-			os.Exit(1)
-		}
-		fmt.Printf("Id: %d\n", status.DeviceId)
-		fmt.Printf("Size: %d\n", status.Size)
-		fmt.Printf("Transaction Id: %d\n", status.TransactionId)
-		fmt.Printf("Size in Sectors: %d\n", status.SizeInSectors)
-		fmt.Printf("Mapped Sectors: %d\n", status.MappedSectors)
-		fmt.Printf("Highest Mapped Sector: %d\n", status.HighestMappedSector)
-		break
-	case "resize":
-		if flag.NArg() < 2 {
-			usage()
-		}
-
-		size, err := byteSizeFromString(args[1])
-		if err != nil {
-			fmt.Println("Invalid size: ", err)
-			os.Exit(1)
-		}
-
-		err = devices.ResizePool(size)
-		if err != nil {
-			fmt.Println("Error resizeing pool: ", err)
-			os.Exit(1)
-		}
-
-		break
-	case "snap":
-		if flag.NArg() < 3 {
-			usage()
-		}
-
-		err := devices.AddDevice(args[1], args[2])
-		if err != nil {
-			fmt.Println("Can't create snap device: ", err)
-			os.Exit(1)
-		}
-		break
-	case "remove":
-		if flag.NArg() < 2 {
-			usage()
-		}
-
-		err := devices.RemoveDevice(args[1])
-		if err != nil {
-			fmt.Println("Can't remove device: ", err)
-			os.Exit(1)
-		}
-		break
-	case "mount":
-		if flag.NArg() < 3 {
-			usage()
-		}
-
-		err := devices.MountDevice(args[1], args[2], false)
-		if err != nil {
-			fmt.Println("Can't create snap device: ", err)
-			os.Exit(1)
-		}
-		break
-	default:
-		fmt.Printf("Unknown command %s\n", args[0])
-		usage()
-
-		os.Exit(1)
-	}
-
-	return
-}
@@ -341,7 +341,7 @@ _docker_pull()

 _docker_push()
 {
-	__docker_image_repos
+	return
 }

 _docker_restart()
@@ -426,7 +426,7 @@ _docker_run()

 _docker_search()
 {
-	COMPREPLY=( $( compgen -W "-notrunc" "-stars" "-trusted" -- "$cur" ) )
+	COMPREPLY=( $( compgen -W "-notrunc" -- "$cur" ) )
 }

 _docker_start()
@@ -1,27 +0,0 @@
-#
-# This Dockerfile will create an image that allows to generate upstart and
-# systemd scripts (more to come)
-#
-# docker-version 0.6.2
-#
-
-FROM		ubuntu:12.10
-MAINTAINER	Guillaume J. Charmes <guillaume@dotcloud.com>
-
-RUN		apt-get update && apt-get install -y wget git mercurial
-
-# Install Go
-RUN		wget --no-check-certificate https://go.googlecode.com/files/go1.1.2.linux-amd64.tar.gz -O go-1.1.2.tar.gz
-RUN		tar -xzvf go-1.1.2.tar.gz && mv /go /goroot
-RUN		mkdir /go
-
-ENV		GOROOT	  /goroot
-ENV		GOPATH	  /go
-ENV		PATH	  $GOROOT/bin:$PATH
-
-RUN		go get github.com/dotcloud/docker && cd /go/src/github.com/dotcloud/docker && git checkout v0.6.3
-ADD		manager.go	/manager/
-RUN		cd /manager && go build -o /usr/bin/manager
-
-ENTRYPOINT	["/usr/bin/manager"]
-
@@ -1,4 +0,0 @@
-FROM		busybox
-MAINTAINER	Guillaume J. Charmes <guillaume@dotcloud.com>
-ADD		manager	  /usr/bin/
-ENTRYPOINT	["/usr/bin/manager"]
@@ -1,130 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"flag"
-	"fmt"
-	"github.com/dotcloud/docker"
-	"os"
-	"strings"
-	"text/template"
-)
-
-var templates = map[string]string{
-
-	"upstart": `description "{{.description}}"
-author "{{.author}}"
-start on filesystem and started lxc-net and started docker
-stop on runlevel [!2345]
-respawn
-exec /home/vagrant/goroot/bin/docker start -a {{.container_id}}
-`,
-
-	"systemd": `[Unit]
-	Description={{.description}}
-	Author={{.author}}
-	After=docker.service
-
-[Service]
-	Restart=always
-	ExecStart=/usr/bin/docker start -a {{.container_id}}
-	ExecStop=/usr/bin/docker stop -t 2 {{.container_id}}
-
-[Install]
-	WantedBy=local.target
-`,
-}
-
-func main() {
-	// Parse command line for custom options
-	kind := flag.String("t", "upstart", "Type of manager requested")
-	author := flag.String("a", "<none>", "Author of the image")
-	description := flag.String("d", "<none>", "Description of the image")
-	flag.Usage = func() {
-		fmt.Fprintf(os.Stderr, "\nUsage: manager <container id>\n\n")
-		flag.PrintDefaults()
-	}
-	flag.Parse()
-
-	// We require at least the container ID
-	if flag.NArg() != 1 {
-		println(flag.NArg())
-		flag.Usage()
-		return
-	}
-
-	// Check that the requested process manager is supported
-	if _, exists := templates[*kind]; !exists {
-		panic("Unkown script template")
-	}
-
-	// Load the requested template
-	tpl, err := template.New("processManager").Parse(templates[*kind])
-	if err != nil {
-		panic(err)
-	}
-
-	// Create stdout/stderr buffers
-	bufOut := bytes.NewBuffer(nil)
-	bufErr := bytes.NewBuffer(nil)
-
-	// Instanciate the Docker CLI
-	cli := docker.NewDockerCli(nil, bufOut, bufErr, "unix", "/var/run/docker.sock")
-	// Retrieve the container info
-	if err := cli.CmdInspect(flag.Arg(0)); err != nil {
-		// As of docker v0.6.3, CmdInspect always returns nil
-		panic(err)
-	}
-
-	// If there is nothing in the error buffer, then the Docker daemon is there and the container has been found
-	if bufErr.Len() == 0 {
-		// Unmarshall the resulting container data
-		c := []*docker.Container{{}}
-		if err := json.Unmarshal(bufOut.Bytes(), &c); err != nil {
-			panic(err)
-		}
-		// Reset the buffers
-		bufOut.Reset()
-		bufErr.Reset()
-		// Retrieve the info of the linked image
-		if err := cli.CmdInspect(c[0].Image); err != nil {
-			panic(err)
-		}
-		// If there is nothing in the error buffer, then the image has been found.
-		if bufErr.Len() == 0 {
-			// Unmarshall the resulting image data
-			img := []*docker.Image{{}}
-			if err := json.Unmarshal(bufOut.Bytes(), &img); err != nil {
-				panic(err)
-			}
-			// If no author has been set, use the one from the image
-			if *author == "<none>" && img[0].Author != "" {
-				*author = strings.Replace(img[0].Author, "\"", "", -1)
-			}
-			// If no description has been set, use the comment from the image
-			if *description == "<none>" && img[0].Comment != "" {
-				*description = strings.Replace(img[0].Comment, "\"", "", -1)
-			}
-		}
-	}
-
-	/// Old version: Wrtie the resulting script to file
-	// f, err := os.OpenFile(kind, os.O_CREATE|os.O_WRONLY, 0755)
-	// if err != nil {
-	// 	panic(err)
-	// }
-	// defer f.Close()
-
-	// Create a map with needed data
-	data := map[string]string{
-		"author":       *author,
-		"description":  *description,
-		"container_id": flag.Arg(0),
-	}
-
-	// Process the template and output it on Stdout
-	if err := tpl.Execute(os.Stdout, data); err != nil {
-		panic(err)
-	}
-}
@@ -1,53 +0,0 @@
-#!/bin/sh
-set -e
-
-usage() {
-	echo >&2 "usage: $0 [-a author] [-d description] container [manager]"
-	echo >&2 "   ie: $0 -a 'John Smith' 4ec9612a37cd systemd"
-	echo >&2 "   ie: $0 -d 'Super Cool System' 4ec9612a37cd # defaults to upstart"
-	exit 1
-}
-
-auth='<none>'
-desc='<none>'
-have_auth=
-have_desc=
-while getopts a:d: opt; do
-	case "$opt" in
-		a)
-			auth="$OPTARG"
-			have_auth=1
-			;;
-		d)
-			desc="$OPTARG"
-			have_desc=1
-			;;
-	esac
-done
-shift $(($OPTIND - 1))
-
-[ $# -ge 1 -a $# -le 2 ] || usage
-
-cid="$1"
-script="${2:-upstart}"
-if [ ! -e "manager/$script" ]; then
-	echo >&2 "Error: manager type '$script' is unknown (PRs always welcome!)."
-	echo >&2 'The currently supported types are:'
-	echo >&2 "  $(cd manager && echo *)"
-	exit 1
-fi
-
-# TODO https://github.com/dotcloud/docker/issues/734 (docker inspect formatting)
-#if command -v docker > /dev/null 2>&1; then
-#	image="$(docker inspect -f '{{.Image}}' "$cid")"
-#	if [ "$image" ]; then
-#		if [ -z "$have_auth" ]; then
-#			auth="$(docker inspect -f '{{.Author}}' "$image")"
-#		fi
-#		if [ -z "$have_desc" ]; then
-#			desc="$(docker inspect -f '{{.Comment}}' "$image")"
-#		fi
-#	fi
-#fi
-
-exec "manager/$script" "$cid" "$auth" "$desc"
@@ -1,20 +0,0 @@
-#!/bin/sh
-set -e
-
-cid="$1"
-auth="$2"
-desc="$3"
-
-cat <<-EOF
-	[Unit]
-	Description=$desc
-	Author=$auth
-	After=docker.service
-	
-	[Service]
-	ExecStart=/usr/bin/docker start -a $cid
-	ExecStop=/usr/bin/docker stop -t 2 $cid
-	
-	[Install]
-	WantedBy=local.target
-EOF
@@ -1,15 +0,0 @@
-#!/bin/sh
-set -e
-
-cid="$1"
-auth="$2"
-desc="$3"
-
-cat <<-EOF
-	description "$(echo "$desc" | sed 's/"/\\"/g')"
-	author "$(echo "$auth" | sed 's/"/\\"/g')"
-	start on filesystem and started lxc-net and started docker
-	stop on runlevel [!2345]
-	respawn
-	exec /usr/bin/docker start -a "$cid"
-EOF
@@ -1,13 +0,0 @@
-# /etc/conf.d/docker: config file for /etc/init.d/docker
-
-# where the docker daemon output gets piped
-#DOCKER_LOGFILE="/var/log/docker.log"
-
-# where docker's pid get stored
-#DOCKER_PIDFILE="/run/docker.pid"
-
-# where the docker daemon itself is run from
-#DOCKER_BINARY="/usr/bin/docker"
-
-# any other random options you want to pass to docker
-DOCKER_OPTS=""
@@ -1,31 +0,0 @@
-#!/sbin/runscript
-# Copyright 1999-2013 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Header: $
-
-DOCKER_LOGFILE=${DOCKER_LOGFILE:-/var/log/${SVCNAME}.log}
-DOCKER_PIDFILE=${DOCKER_PIDFILE:-/run/${SVCNAME}.pid}
-DOCKER_BINARY=${DOCKER_BINARY:-/usr/bin/docker}
-DOCKER_OPTS=${DOCKER_OPTS:-}
-
-start() {
-	checkpath -f -m 0644 -o root:docker "$DOCKER_LOGFILE"
-
-	ebegin "Starting docker daemon"
-	start-stop-daemon --start --background \
-		--exec "$DOCKER_BINARY" \
-		--pidfile "$DOCKER_PIDFILE" \
-		--stdout "$DOCKER_LOGFILE" \
-		--stderr "$DOCKER_LOGFILE" \
-		-- -d -p "$DOCKER_PIDFILE" \
-		$DOCKER_OPTS
-	eend $?
-}
-
-stop() {
-	ebegin "Stopping docker daemon"
-	start-stop-daemon --stop \
-		--exec "$DOCKER_BINARY" \
-		--pidfile "$DOCKER_PIDFILE"
-	eend $?
-}
@@ -1,13 +0,0 @@
-[Unit]
-Description=Docker Application Container Engine 
-Documentation=http://docs.docker.io
-Requires=network.target
-After=multi-user.target
-
-[Service]
-Type=simple
-ExecStartPre=/bin/mount --make-rprivate /
-ExecStart=/usr/bin/docker -d
-
-[Install]
-WantedBy=multi-user.target
@@ -1,96 +0,0 @@
-#!/bin/sh
-
-### BEGIN INIT INFO
-# Provides:           docker
-# Required-Start:     $syslog $remote_fs
-# Required-Stop:      $syslog $remote_fs
-# Default-Start:      2 3 4 5
-# Default-Stop:       0 1 6
-# Short-Description:  Create lightweight, portable, self-sufficient containers.
-# Description:
-#  Docker is an open-source project to easily create lightweight, portable,
-#  self-sufficient containers from any application. The same container that a
-#  developer builds and tests on a laptop can run at scale, in production, on
-#  VMs, bare metal, OpenStack clusters, public clouds and more.
-### END INIT INFO
-
-BASE=$(basename $0)
-
-DOCKER=/usr/bin/$BASE
-DOCKER_PIDFILE=/var/run/$BASE.pid
-DOCKER_OPTS=
-
-PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin
-
-# Get lsb functions
-. /lib/lsb/init-functions
-
-if [ -f /etc/default/$BASE ]; then
-	. /etc/default/$BASE
-fi
-
-# see also init_is_upstart in /lib/lsb/init-functions (which isn't available in Ubuntu 12.04, or we'd use it)
-if [ -x /sbin/initctl ] && /sbin/initctl version 2>/dev/null | /bin/grep -q upstart; then
-	log_failure_msg "Docker is managed via upstart, try using service $BASE $1"
-	exit 1
-fi
-
-# Check docker is present
-if [ ! -x $DOCKER ]; then
-	log_failure_msg "$DOCKER not present or not executable"
-	exit 1
-fi
-
-fail_unless_root() {
-	if [ "$(id -u)" != '0' ]; then
-		log_failure_msg "Docker must be run as root"
-		exit 1
-	fi
-}
-
-case "$1" in
-	start)
-		fail_unless_root
-		log_begin_msg "Starting Docker: $BASE"
-		mount | grep cgroup >/dev/null || mount -t cgroup none /sys/fs/cgroup 2>/dev/null
-		start-stop-daemon --start --background \
-			--exec "$DOCKER" \
-			--pidfile "$DOCKER_PIDFILE" \
-			-- -d -p "$DOCKER_PIDFILE" \
-			$DOCKER_OPTS
-		log_end_msg $?
-		;;
-
-	stop)
-		fail_unless_root
-		log_begin_msg "Stopping Docker: $BASE"
-		start-stop-daemon --stop \
-			--pidfile "$DOCKER_PIDFILE"
-		log_end_msg $?
-		;;
-
-	restart)
-		fail_unless_root
-		docker_pid=`cat "$DOCKER_PIDFILE" 2>/dev/null`
-		[ -n "$docker_pid" ] \
-			&& ps -p $docker_pid > /dev/null 2>&1 \
-			&& $0 stop
-		$0 start
-		;;
-
-	force-reload)
-		fail_unless_root
-		$0 restart
-		;;
-
-	status)
-		status_of_proc -p "$DOCKER_PIDFILE" "$DOCKER" docker
-		;;
-
-	*)
-		echo "Usage: $0 {start|stop|restart|status}"
-		exit 1
-		;;
-esac
-
-exit 0
@@ -1,15 +0,0 @@
-description "Docker daemon"
-
-start on filesystem and started lxc-net
-stop on runlevel [!2345]
-
-respawn
-
-script
-	DOCKER=/usr/bin/$UPSTART_JOB
-	DOCKER_OPTS=
-	if [ -f /etc/default/$UPSTART_JOB ]; then
-		. /etc/default/$UPSTART_JOB
-	fi
-	"$DOCKER" -d $DOCKER_OPTS
-end script
@@ -0,0 +1,61 @@
+#!/bin/sh
+# This script is meant for quick & easy install via 'curl URL-OF-SCRIPT | sh'
+# Original version by Jeff Lindsay <progrium@gmail.com>
+# Revamped by Jerome Petazzoni <jerome@dotcloud.com>
+#
+# This script canonical location is https://get.docker.io/; to update it, run:
+# s3cmd put -m text/x-shellscript -P install.sh s3://get.docker.io/index
+
+echo "Ensuring basic dependencies are installed..."
+apt-get -qq update
+apt-get -qq install lxc wget
+
+echo "Looking in /proc/filesystems to see if we have AUFS support..."
+if grep -q aufs /proc/filesystems
+then
+    echo "Found."
+else
+    echo "Ahem, it looks like the current kernel does not support AUFS."
+    echo "Let's see if we can load the AUFS module with modprobe..."
+    if modprobe aufs
+    then
+        echo "Module loaded."
+    else
+        echo "Ahem, things didn't turn out as expected."
+        KPKG=linux-image-extra-$(uname -r)
+        echo "Trying to install $KPKG..."
+        if apt-get -qq install $KPKG
+        then
+            echo "Installed."
+        else
+            echo "Oops, we couldn't install the -extra kernel."
+            echo "Are you sure you are running a supported version of Ubuntu?"
+            echo "Proceeding anyway, but Docker will probably NOT WORK!"
+        fi
+    fi
+fi
+
+echo "Downloading docker binary to /usr/local/bin..."
+curl -s https://get.docker.io/builds/$(uname -s)/$(uname -m)/docker-latest \
+    > /usr/local/bin/docker
+chmod +x /usr/local/bin/docker
+
+if [ -f /etc/init/dockerd.conf ]
+then
+  echo "Upstart script already exists."
+else
+  echo "Creating /etc/init/dockerd.conf..."
+  cat >/etc/init/dockerd.conf <<EOF
+description "Docker daemon"
+start on filesystem and started lxc-net
+stop on runlevel [!2345]
+respawn
+exec /usr/local/bin/docker -d
+EOF
+fi
+
+echo "Starting dockerd..."
+start dockerd > /dev/null
+
+echo "Done."
+echo
@@ -1,67 +0,0 @@
-#!/bin/bash
-# Generate a minimal filesystem for archlinux and load it into the local
-# docker as "archlinux"
-# requires root
-set -e
-
-PACSTRAP=$(which pacstrap)
-[ "$PACSTRAP" ] || {
-    echo "Could not find pacstrap. Run pacman -S arch-install-scripts"
-    exit 1
-}
-EXPECT=$(which expect)
-[ "$EXPECT" ] || {
-    echo "Could not find expect. Run pacman -S expect"
-    exit 1
-}
-
-ROOTFS=~/rootfs-arch-$$-$RANDOM
-mkdir $ROOTFS
-
-#packages to ignore for space savings
-PKGIGNORE=linux,jfsutils,lvm2,cryptsetup,groff,man-db,man-pages,mdadm,pciutils,pcmciautils,reiserfsprogs,s-nail,xfsprogs
- 
-expect <<EOF
-  set timeout 60
-  set send_slow {1 1}
-  spawn pacstrap -c -d -G -i $ROOTFS base haveged --ignore $PKGIGNORE
-  expect {
-    "Install anyway?" { send n\r; exp_continue }
-    "(default=all)" { send \r; exp_continue }
-    "Proceed with installation?" { send "\r"; exp_continue }
-    "skip the above package" {send "y\r"; exp_continue }
-    "checking" { exp_continue }
-    "loading" { exp_continue }
-    "installing" { exp_continue }
-  }
-EOF
-
-arch-chroot $ROOTFS /bin/sh -c "haveged -w 1024; pacman-key --init; pkill haveged; pacman -Rs --noconfirm haveged; pacman-key --populate archlinux"
-arch-chroot $ROOTFS /bin/sh -c "ln -s /usr/share/zoneinfo/UTC /etc/localtime"
-cat > $ROOTFS/etc/locale.gen <<DELIM
-en_US.UTF-8 UTF-8
-en_US ISO-8859-1
-DELIM
-arch-chroot $ROOTFS locale-gen
-arch-chroot $ROOTFS /bin/sh -c 'echo "Server = http://mirrors.kernel.org/archlinux/\$repo/os/\$arch" > /etc/pacman.d/mirrorlist'
-
-# udev doesn't work in containers, rebuild /dev
-DEV=${ROOTFS}/dev
-mv ${DEV} ${DEV}.old
-mkdir -p ${DEV}
-mknod -m 666 ${DEV}/null c 1 3
-mknod -m 666 ${DEV}/zero c 1 5
-mknod -m 666 ${DEV}/random c 1 8
-mknod -m 666 ${DEV}/urandom c 1 9
-mkdir -m 755 ${DEV}/pts
-mkdir -m 1777 ${DEV}/shm
-mknod -m 666 ${DEV}/tty c 5 0
-mknod -m 600 ${DEV}/console c 5 1
-mknod -m 666 ${DEV}/tty0 c 4 0
-mknod -m 666 ${DEV}/full c 1 7
-mknod -m 600 ${DEV}/initctl p
-mknod -m 666 ${DEV}/ptmx c 5 2
-
-tar --numeric-owner -C $ROOTFS -c . | docker import - archlinux
-docker run -i -t archlinux echo Success.
-rm -rf $ROOTFS
@@ -35,5 +35,5 @@ do
    cp -a /dev/$X dev
 done

-tar --numeric-owner -cf- . | docker import - busybox
+tar -cf- . | docker import - busybox
 docker run -i -u root busybox /bin/echo Success.
@@ -0,0 +1,66 @@
+#!/bin/bash
+set -e
+
+# these should match the names found at http://www.debian.org/releases/
+stableSuite='wheezy'
+testingSuite='jessie'
+unstableSuite='sid'
+
+variant='minbase'
+include='iproute,iputils-ping'
+
+repo="$1"
+suite="${2:-$stableSuite}"
+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"
+
+# prevent init scripts from running during install/update
+echo $'#!/bin/sh\nexit 101' | sudo tee usr/sbin/policy-rc.d > /dev/null
+sudo chmod +x usr/sbin/policy-rc.d
+# see https://github.com/dotcloud/docker/issues/446#issuecomment-16953173
+
+# shrink the image, since apt makes us fat (wheezy: ~157.5MB vs ~120MB)
+sudo chroot . apt-get clean
+
+# while we're at it, apt is unnecessarily slow inside containers
+#  this forces dpkg not to call sync() after package extraction and speeds up install
+echo 'force-unsafe-io' | sudo tee etc/dpkg/dpkg.cfg.d/02apt-speedup > /dev/null
+#  we don't need an apt cache in a container
+echo 'Acquire::http {No-Cache=True;};' | sudo tee etc/apt/apt.conf.d/no-cache > /dev/null
+
+# create the image (and tag $repo:$suite)
+sudo tar -c . | docker import - $repo $suite
+
+# test the image
+docker run -i -t $repo:$suite echo success
+
+if [ "$suite" = "$stableSuite" -o "$suite" = 'stable' ]; then
+	# tag latest
+	docker tag $repo:$suite $repo latest
+	
+	# tag the specific debian release version
+	ver=$(docker run $repo:$suite cat /etc/debian_version)
+	docker tag $repo:$suite $repo $ver
+fi
+
+# cleanup
+cd "$returnTo"
+sudo rm -rf "$target"
@@ -1,233 +0,0 @@
-#!/bin/bash
-set -e
-
-variant='minbase'
-include='iproute,iputils-ping'
-arch='amd64' # intentionally undocumented for now
-skipDetection=
-strictDebootstrap=
-justTar=
-
-usage() {
-	echo >&2
-	
-	echo >&2 "usage: $0 [options] repo suite [mirror]"
-	
-	echo >&2
-	echo >&2 'options: (not recommended)'
-	echo >&2 "  -p set an http_proxy for debootstrap"
-	echo >&2 "  -v $variant # change default debootstrap variant"
-	echo >&2 "  -i $include # change default package includes"
-	echo >&2 "  -d # strict debootstrap (do not apply any docker-specific tweaks)"
-	echo >&2 "  -s # skip version detection and tagging (ie, precise also tagged as 12.04)"
-	echo >&2 "     # note that this will also skip adding universe and/or security/updates to sources.list"
-	echo >&2 "  -t # just create a tarball, especially for dockerbrew (uses repo as tarball name)"
-	
-	echo >&2
-	echo >&2 "   ie: $0 username/debian squeeze"
-	echo >&2 "       $0 username/debian squeeze http://ftp.uk.debian.org/debian/"
-	
-	echo >&2
-	echo >&2 "   ie: $0 username/ubuntu precise"
-	echo >&2 "       $0 username/ubuntu precise http://mirrors.melbourne.co.uk/ubuntu/"
-	
-	echo >&2
-	echo >&2 "   ie: $0 -t precise.tar.bz2 precise"
-	echo >&2 "       $0 -t wheezy.tgz wheezy"
-	echo >&2 "       $0 -t wheezy-uk.tar.xz wheezy http://ftp.uk.debian.org/debian/"
-	
-	echo >&2
-}
-
-# these should match the names found at http://www.debian.org/releases/
-debianStable=wheezy
-debianUnstable=sid
-# this should match the name found at http://releases.ubuntu.com/
-ubuntuLatestLTS=precise
-
-while getopts v:i:a:p:dst name; do
-	case "$name" in
-		p)
-			http_proxy="$OPTARG"
-			;;
-		v)
-			variant="$OPTARG"
-			;;
-		i)
-			include="$OPTARG"
-			;;
-		a)
-			arch="$OPTARG"
-			;;
-		d)
-			strictDebootstrap=1
-			;;
-		s)
-			skipDetection=1
-			;;
-		t)
-			justTar=1
-			;;
-		?)
-			usage
-			exit 0
-			;;
-	esac
-done
-shift $(($OPTIND - 1))
-
-repo="$1"
-suite="$2"
-mirror="${3:-}" # stick to the default debootstrap mirror if one is not provided
-
-if [ ! "$repo" ] || [ ! "$suite" ]; then
-	usage
-	exit 1
-fi
-
-# some rudimentary detection for whether we need to "sudo" our docker calls
-docker=''
-if docker version > /dev/null 2>&1; then
-	docker='docker'
-elif sudo docker version > /dev/null 2>&1; then
-	docker='sudo docker'
-elif command -v docker > /dev/null 2>&1; then
-	docker='docker'
-else
-	echo >&2 "warning: either docker isn't installed, or your current user cannot run it;"
-	echo >&2 "         this script is not likely to work as expected"
-	sleep 3
-	docker='docker' # give us a command-not-found later
-fi
-
-# make sure we have an absolute path to our final tarball so we can still reference it properly after we change directory
-if [ "$justTar" ]; then
-	if [ ! -d "$(dirname "$repo")" ]; then
-		echo >&2 "error: $(dirname "$repo") does not exist"
-		exit 1
-	fi
-	repo="$(cd "$(dirname "$repo")" && pwd -P)/$(basename "$repo")"
-fi
-
-# will be filled in later, if [ -z "$skipDetection" ]
-lsbDist=''
-
-target="/tmp/docker-rootfs-debootstrap-$suite-$$-$RANDOM"
-
-cd "$(dirname "$(readlink -f "$BASH_SOURCE")")"
-returnTo="$(pwd -P)"
-
-set -x
-
-# bootstrap
-mkdir -p "$target"
-sudo http_proxy=$http_proxy debootstrap --verbose --variant="$variant" --include="$include" --arch="$arch" "$suite" "$target" "$mirror"
-
-cd "$target"
-
-if [ -z "$strictDebootstrap" ]; then
-	# prevent init scripts from running during install/update
-	#  policy-rc.d (for most scripts)
-	echo $'#!/bin/sh\nexit 101' | sudo tee usr/sbin/policy-rc.d > /dev/null
-	sudo chmod +x usr/sbin/policy-rc.d
-	#  initctl (for some pesky upstart scripts)
-	sudo chroot . dpkg-divert --local --rename --add /sbin/initctl
-	sudo ln -sf /bin/true sbin/initctl
-	# see https://github.com/dotcloud/docker/issues/446#issuecomment-16953173
-	
-	# shrink the image, since apt makes us fat (wheezy: ~157.5MB vs ~120MB)
-	sudo chroot . apt-get clean
-	
-	# while we're at it, apt is unnecessarily slow inside containers
-	#  this forces dpkg not to call sync() after package extraction and speeds up install
-	#    the benefit is huge on spinning disks, and the penalty is nonexistent on SSD or decent server virtualization
-	echo 'force-unsafe-io' | sudo tee etc/dpkg/dpkg.cfg.d/02apt-speedup > /dev/null
-	#  we want to effectively run "apt-get clean" after every install to keep images small
-	echo 'DPkg::Post-Invoke {"/bin/rm -f /var/cache/apt/archives/*.deb || true";};' | sudo tee etc/apt/apt.conf.d/no-cache > /dev/null
-	
-	# helpful undo lines for each the above tweaks (for lack of a better home to keep track of them):
-	#  rm /usr/sbin/policy-rc.d
-	#  rm /sbin/initctl; dpkg-divert --rename --remove /sbin/initctl
-	#  rm /etc/dpkg/dpkg.cfg.d/02apt-speedup
-	#  rm /etc/apt/apt.conf.d/no-cache
-	
-	if [ -z "$skipDetection" ]; then
-		# see also rudimentary platform detection in hack/install.sh
-		lsbDist=''
-		if [ -r etc/lsb-release ]; then
-			lsbDist="$(. etc/lsb-release && echo "$DISTRIB_ID")"
-		fi
-		if [ -z "$lsbDist" ] && [ -r etc/debian_version ]; then
-			lsbDist='Debian'
-		fi
-		
-		case "$lsbDist" in
-			Debian)
-				# add the updates and security repositories
-				if [ "$suite" != "$debianUnstable" -a "$suite" != 'unstable' ]; then
-					# ${suite}-updates only applies to non-unstable
-					sudo sed -i "p; s/ $suite main$/ ${suite}-updates main/" etc/apt/sources.list
-					
-					# same for security updates
-					echo "deb http://security.debian.org/ $suite/updates main" | sudo tee -a etc/apt/sources.list > /dev/null
-				fi
-				;;
-			Ubuntu)
-				# add the universe, updates, and security repositories
-				sudo sed -i "
-					s/ $suite main$/ $suite main universe/; p;
-					s/ $suite main/ ${suite}-updates main/; p;
-					s/ $suite-updates main/ ${suite}-security main/
-				" etc/apt/sources.list
-				;;
-		esac
-	fi
-fi
-
-if [ "$justTar" ]; then
-	# create the tarball file so it has the right permissions (ie, not root)
-	touch "$repo"
-	
-	# fill the tarball
-	sudo tar --numeric-owner -caf "$repo" .
-else
-	# create the image (and tag $repo:$suite)
-	sudo tar --numeric-owner -c . | $docker import - $repo:$suite
-	
-	# test the image
-	$docker run -i -t $repo:$suite echo success
-	
-	if [ -z "$skipDetection" ]; then
-		case "$lsbDist" in
-			Debian)
-				if [ "$suite" = "$debianStable" -o "$suite" = 'stable' ] && [ -r etc/debian_version ]; then
-					# tag latest
-					$docker tag $repo:$suite $repo:latest
-					
-					if [ -r etc/debian_version ]; then
-						# tag the specific debian release version (which is only reasonable to tag on debian stable)
-						ver=$(cat etc/debian_version)
-						$docker tag $repo:$suite $repo:$ver
-					fi
-				fi
-				;;
-			Ubuntu)
-				if [ "$suite" = "$ubuntuLatestLTS" ]; then
-					# tag latest
-					$docker tag $repo:$suite $repo:latest
-				fi
-				if [ -r etc/lsb-release ]; then
-					lsbRelease="$(. etc/lsb-release && echo "$DISTRIB_RELEASE")"
-					if [ "$lsbRelease" ]; then
-						# tag specific Ubuntu version number, if available (12.04, etc.)
-						$docker tag $repo:$suite $repo:$lsbRelease
-					fi
-				fi
-				;;
-		esac
-	fi
-fi
-
-# cleanup
-cd "$returnTo"
-sudo rm -rf "$target"
@@ -44,6 +44,6 @@ do
 done

 chmod 0755 $ROOTFS # See #486
-tar --numeric-owner -cf- . | docker import - docker-ut
+tar -cf- . | docker import - docker-ut
 docker run -i -u root docker-ut /bin/echo Success.
 rm -rf $ROOTFS
@@ -1,19 +1,3 @@
-# Vagrant integration
+# Vagrant-docker

-Currently there are at least 4 different projects that we are aware of that deals
-with integration with [Vagrant](http://vagrantup.com/) at different levels. One
-approach is to use Docker as a [provisioner](http://docs.vagrantup.com/v2/provisioning/index.html)
-which means you can create containers and pull base images on VMs using Docker's
-CLI and the other is to use Docker as a [provider](http://docs.vagrantup.com/v2/providers/index.html),
-meaning you can use Vagrant to control Docker containers.
-
-
-### Provisioners
-
-* [Vocker](https://github.com/fgrehm/vocker)
-* [Ventriloquist](https://github.com/fgrehm/ventriloquist)
-
-### Providers
-
-* [docker-provider](https://github.com/fgrehm/docker-provider)
-* [vagrant-shell](https://github.com/destructuring/vagrant-shell)
+This is a placeholder for the official vagrant-docker, a plugin for Vagrant (http://vagrantup.com) which exposes Docker as a provider.
@@ -1,22 +0,0 @@
-Copyright (c) 2013 Honza Pokorny
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@@ -1,23 +0,0 @@
-dockerfile.vim
-==============
-
-Syntax highlighting for Dockerfiles
-
-Installation
------------
-
-Via pathogen, the usual way...
-
-Features
--------
-
-The syntax highlighting includes:
-
-* The directives (e.g. `FROM`)
-* Strings
-* Comments
-
-License
-------
-
-BSD, short and sweet
@@ -1,18 +0,0 @@
-*dockerfile.txt*  Syntax highlighting for Dockerfiles
-
-Author: Honza Pokorny <http://honza.ca>
-License: BSD
-
-INSTALLATION                                                     *installation*
-
-Drop it on your Pathogen path and you're all set.
-
-FEATURES                                                             *features*
-
-The syntax highlighting includes:
-
-* The directives (e.g. FROM)
-* Strings
-* Comments
-
- vim:tw=78:et:ft=help:norl:
@@ -1 +0,0 @@
-au BufNewFile,BufRead Dockerfile set filetype=dockerfile
@@ -1,24 +0,0 @@
-" dockerfile.vim - Syntax highlighting for Dockerfiles
-" Maintainer:   Honza Pokorny <http://honza.ca>
-" Version:      0.5
-
-
-if exists("b:current_syntax")
-    finish
-endif
-
-let b:current_syntax = "dockerfile"
-
-syntax case ignore
-
-syntax match dockerfileKeyword /\v^\s*(FROM|MAINTAINER|RUN|CMD|EXPOSE|ENV|ADD)\s/
-syntax match dockerfileKeyword /\v^\s*(ENTRYPOINT|VOLUME|USER|WORKDIR)\s/
-highlight link dockerfileKeyword Keyword
-
-syntax region dockerfileString start=/\v"/ skip=/\v\\./ end=/\v"/
-highlight link dockerfileString String
-
-syntax match dockerfileComment "\v^\s*#.*$"
-highlight link dockerfileComment Comment
-
-set commentstring=#\ %s
@@ -4,12 +4,15 @@ import (
 	"flag"
 	"fmt"
 	"github.com/dotcloud/docker"
-	"github.com/dotcloud/docker/engine"
-	"github.com/dotcloud/docker/sysinit"
 	"github.com/dotcloud/docker/utils"
+	"io/ioutil"
 	"log"
+	"net"
 	"os"
+	"os/signal"
+	"strconv"
 	"strings"
+	"syscall"
 )

 var (
@@ -20,25 +23,23 @@ var (
 func main() {
 	if selfPath := utils.SelfPath(); selfPath == "/sbin/init" || selfPath == "/.dockerinit" {
 		// Running in init mode
-		sysinit.SysInit()
+		docker.SysInit()
 		return
 	}
 	// FIXME: Switch d and D ? (to be more sshd like)
 	flVersion := flag.Bool("v", false, "Print version information and quit")
-	flDaemon := flag.Bool("d", false, "Enable daemon mode")
-	flDebug := flag.Bool("D", false, "Enable debug mode")
-	flAutoRestart := flag.Bool("r", true, "Restart previously running containers")
-	bridgeName := flag.String("b", "", "Attach containers to a pre-existing network bridge; use 'none' to disable container networking")
-	pidfile := flag.String("p", "/var/run/docker.pid", "Path to use for daemon PID file")
-	flRoot := flag.String("g", "/var/lib/docker", "Path to use as the root of the docker runtime")
-	flEnableCors := flag.Bool("api-enable-cors", false, "Enable CORS headers in the remote API")
-	flDns := flag.String("dns", "", "Force docker to use specific DNS servers")
-	flHosts := utils.ListOpts{fmt.Sprintf("unix://%s", docker.DEFAULTUNIXSOCKET)}
-	flag.Var(&flHosts, "H", "Multiple tcp://host:port or unix://path/to/socket to bind in daemon mode, single connection otherwise")
-	flEnableIptables := flag.Bool("iptables", true, "Disable docker's addition of iptables rules")
-	flDefaultIp := flag.String("ip", "0.0.0.0", "Default IP address to use when binding container ports")
-	flInterContainerComm := flag.Bool("icc", true, "Enable inter-container communication")
-	flGraphDriver := flag.String("graph-driver", "", "Force docker runtime to use a specific graph driver")
+	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. Use 'none' to disable container networking")
+	pidfile := flag.String("p", "/var/run/docker.pid", "File containing process PID")
+	flGraphPath := flag.String("g", "/var/lib/docker", "Path to graph storage base dir.")
+	flEnableCors := flag.Bool("api-enable-cors", false, "Enable CORS requests in the remote api.")
+	flDns := flag.String("dns", "", "Set custom dns servers")
+	flHosts := docker.ListOpts{fmt.Sprintf("unix://%s", docker.DEFAULTUNIXSOCKET)}
+	flag.Var(&flHosts, "H", "tcp://host:port to bind/connect to or unix://path/to/socket to use")
+	flEnableIptables := flag.Bool("iptables", true, "Disable iptables within docker")
+	flDefaultIp := flag.String("ip", "0.0.0.0", "Default ip address to use when binding a containers ports")

 	flag.Parse()

@@ -50,14 +51,13 @@ func main() {
 		flHosts = flHosts[1:] //trick to display a nice default value in the usage
 	}
 	for i, flHost := range flHosts {
-		host, err := utils.ParseHost(docker.DEFAULTHTTPHOST, docker.DEFAULTHTTPPORT, flHost)
-		if err == nil {
-			flHosts[i] = host
-		} else {
-			log.Fatal(err)
-		}
+		flHosts[i] = utils.ParseHost(docker.DEFAULTHTTPHOST, docker.DEFAULTHTTPPORT, flHost)
 	}

+	bridge := docker.DefaultNetworkBridge
+	if *bridgeName != "" {
+		bridge = *bridgeName
+	}
 	if *flDebug {
 		os.Setenv("DEBUG", "1")
 	}
@@ -68,34 +68,32 @@ func main() {
 			flag.Usage()
 			return
 		}
-		eng, err := engine.New(*flRoot)
-		if err != nil {
-			log.Fatal(err)
+		var dns []string
+		if *flDns != "" {
+			dns = []string{*flDns}
 		}
-		// Load plugin: httpapi
-		job := eng.Job("initapi")
-		job.Setenv("Pidfile", *pidfile)
-		job.Setenv("Root", *flRoot)
-		job.SetenvBool("AutoRestart", *flAutoRestart)
-		job.SetenvBool("EnableCors", *flEnableCors)
-		job.Setenv("Dns", *flDns)
-		job.SetenvBool("EnableIptables", *flEnableIptables)
-		job.Setenv("BridgeIface", *bridgeName)
-		job.Setenv("DefaultIp", *flDefaultIp)
-		job.SetenvBool("InterContainerCommunication", *flInterContainerComm)
-		job.Setenv("GraphDriver", *flGraphDriver)
-		if err := job.Run(); err != nil {
-			log.Fatal(err)
+
+		ip := net.ParseIP(*flDefaultIp)
+
+		config := &docker.DaemonConfig{
+			Pidfile:        *pidfile,
+			GraphPath:      *flGraphPath,
+			AutoRestart:    *flAutoRestart,
+			EnableCors:     *flEnableCors,
+			Dns:            dns,
+			EnableIptables: *flEnableIptables,
+			BridgeIface:    bridge,
+			ProtoAddresses: flHosts,
+			DefaultIp:      ip,
 		}
-		// Serve api
-		job = eng.Job("serveapi", flHosts...)
-		job.SetenvBool("Logging", true)
-		if err := job.Run(); err != nil {
+		if err := daemon(config); err != nil {
 			log.Fatal(err)
+			os.Exit(-1)
 		}
 	} else {
 		if len(flHosts) > 1 {
 			log.Fatal("Please specify only one -H")
+			return
 		}
 		protoAddrParts := strings.SplitN(flHosts[0], "://", 2)
 		if err := docker.ParseCommands(protoAddrParts[0], protoAddrParts[1], flag.Args()...); err != nil {
@@ -103,6 +101,7 @@ func main() {
 				os.Exit(sterr.Status)
 			}
 			log.Fatal(err)
+			os.Exit(-1)
 		}
 	}
 }
@@ -110,3 +109,74 @@ func main() {
 func showVersion() {
 	fmt.Printf("Docker version %s, build %s\n", VERSION, GITCOMMIT)
 }
+
+func createPidFile(pidfile string) error {
+	if pidString, err := ioutil.ReadFile(pidfile); err == nil {
+		pid, err := strconv.Atoi(string(pidString))
+		if err == nil {
+			if _, err := os.Stat(fmt.Sprintf("/proc/%d/", pid)); err == nil {
+				return fmt.Errorf("pid file found, ensure docker is not running or delete %s", pidfile)
+			}
+		}
+	}
+
+	file, err := os.Create(pidfile)
+	if err != nil {
+		return err
+	}
+
+	defer file.Close()
+
+	_, err = fmt.Fprintf(file, "%d", os.Getpid())
+	return err
+}
+
+func removePidFile(pidfile string) {
+	if err := os.Remove(pidfile); err != nil {
+		log.Printf("Error removing %s: %s", pidfile, err)
+	}
+}
+
+func daemon(config *docker.DaemonConfig) error {
+	if err := createPidFile(config.Pidfile); err != nil {
+		log.Fatal(err)
+	}
+	defer removePidFile(config.Pidfile)
+
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, os.Kill, os.Signal(syscall.SIGTERM))
+	go func() {
+		sig := <-c
+		log.Printf("Received signal '%v', exiting\n", sig)
+		removePidFile(config.Pidfile)
+		os.Exit(0)
+	}()
+	server, err := docker.NewServer(config)
+	if err != nil {
+		return err
+	}
+	chErrors := make(chan error, len(config.ProtoAddresses))
+	for _, protoAddr := range config.ProtoAddresses {
+		protoAddrParts := strings.SplitN(protoAddr, "://", 2)
+		if protoAddrParts[0] == "unix" {
+			syscall.Unlink(protoAddrParts[1])
+		} else if protoAddrParts[0] == "tcp" {
+			if !strings.HasPrefix(protoAddrParts[1], "127.0.0.1") {
+				log.Println("/!\\ DON'T BIND ON ANOTHER IP ADDRESS THAN 127.0.0.1 IF YOU DON'T KNOW WHAT YOU'RE DOING /!\\")
+			}
+		} else {
+			log.Fatal("Invalid protocol format.")
+			os.Exit(-1)
+		}
+		go func() {
+			chErrors <- docker.ListenAndServe(protoAddrParts[0], protoAddrParts[1], server, true)
+		}()
+	}
+	for i := 0; i < len(config.ProtoAddresses); i += 1 {
+		err := <-chErrors
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
@@ -1,16 +0,0 @@
-package main
-
-import (
-	"github.com/dotcloud/docker/sysinit"
-)
-
-var (
-	GITCOMMIT string
-	VERSION   string
-)
-
-func main() {
-	// Running in init mode
-	sysinit.SysInit()
-	return
-}
@@ -1,16 +1,11 @@
 from ubuntu:12.04
 maintainer Nick Stinemates
-#
-#    docker build -t docker:docs . && docker run -p 8000:8000 docker:docs
-#

 run apt-get update
 run apt-get install -y python-setuptools make
 run easy_install pip
-#from docs/requirements.txt, but here to increase cacheability
-run pip install Sphinx==1.1.3
-run pip install sphinxcontrib-httpdomain==1.1.8
 add . /docs
+run pip install -r /docs/requirements.txt
 run cd /docs; make docs

 expose 8000
@@ -31,7 +31,7 @@ help:
 #	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
 #	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
 #	@echo "  text       to make text files"
-	@echo "  man        to make a manual page"
+#	@echo "  man        to make manual pages"
 #	@echo "  texinfo    to make Texinfo files"
 #	@echo "  info       to make Texinfo files and run them through makeinfo"
 #	@echo "  gettext    to make PO message catalogs"
@@ -1,94 +1,38 @@
 Docker Documentation
 ====================

-Overview
--------
+Documentation
+-------------
+This is your definite place to contribute to the docker documentation. After each push to master the documentation
+is automatically generated and made available on [docs.docker.io](http://docs.docker.io)

-The source for Docker documentation is here under ``sources/`` in the
-form of .rst files. These files use
-[reStructuredText](http://docutils.sourceforge.net/rst.html)
-formatting with [Sphinx](http://sphinx-doc.org/) extensions for
-structure, cross-linking and indexing.
+Each of the .rst files under sources reflects a page on the documentation. 

-The HTML files are built and hosted on
-[readthedocs.org](https://readthedocs.org/projects/docker/), appearing
-via proxy on https://docs.docker.io. The HTML files update
-automatically after each change to the master or release branch of the
-[docker files on GitHub](https://github.com/dotcloud/docker) thanks to
-post-commit hooks. The "release" branch maps to the "latest"
-documentation and the "master" branch maps to the "master"
-documentation. 
-
-**Warning**: The "master" documentation may include features not yet
-part of any official docker release. "Master" docs should be used only
-for understanding bleeding-edge development and "latest" should be
-used for the latest official release.
-
-If you need to manually trigger a build of an existing branch, then
-you can do that through the [readthedocs
-interface](https://readthedocs.org/builds/docker/). If you would like
-to add new build targets, including new branches or tags, then you
-must contact one of the existing maintainers and get your
-readthedocs.org account added to the maintainers list, or just file an
-issue on GitHub describing the branch/tag and why it needs to be added
-to the docs, and one of the maintainers will add it for you.
-
-Getting Started
---------------
-
-To edit and test the docs, you'll need to install the Sphinx tool and
-its dependencies. There are two main ways to install this tool:
-
-###Native Installation
+Installation
+------------

+* Work in your own fork of the code, we accept pull requests.
 * Install sphinx: `pip install sphinx`
-    * Mac OS X: `[sudo] pip-2.7 install sphinx`
+    * Mac OS X: `[sudo] pip-2.7 install sphinx`)
 * Install sphinx httpdomain contrib package: `pip install sphinxcontrib-httpdomain`
    * Mac OS X: `[sudo] pip-2.7 install sphinxcontrib-httpdomain`
 * If pip is not available you can probably install it using your favorite package manager as **python-pip**

-###Alternative Installation: Docker Container
-
-If you're running ``docker`` on your development machine then you may
-find it easier and cleaner to use the Dockerfile. This installs Sphinx
-in a container, adds the local ``docs/`` directory and builds the HTML
-docs inside the container, even starting a simple HTTP server on port
-8000 so that you can connect and see your changes. Just run ``docker
-build .`` and run the resulting image. This is the equivalent to
-``make clean server`` since each container starts clean.
-
-In the ``docs/`` directory, run:
-    ```docker build -t docker:docs . && docker run -p 8000:8000 docker:docs```
-
 Usage
 -----
-* Follow the contribution guidelines (``../CONTRIBUTING.md``)
-* Work in your own fork of the code, we accept pull requests.
-* Change the ``.rst`` files with your favorite editor -- try to keep the
-  lines short and respect RST and Sphinx conventions. 
-* Run ``make clean docs`` to clean up old files and generate new ones,
-  or just ``make docs`` to update after small changes.
-* Your static website can now be found in the ``_build`` directory.
-* To preview what you have generated run ``make server`` and open
-  http://localhost:8000/ in your favorite browser.
-
-``make clean docs`` must complete without any warnings or errors.
+* Change the `.rst` files with your favorite editor to your liking.
+* Run `make docs` to clean up old files and generate new ones.
+* Your static website can now be found in the `_build` directory.
+* To preview what you have generated run `make server` and open http://localhost:8000/ in your favorite browser.

 Working using GitHub's file editor
 ----------------------------------
-
-Alternatively, for small changes and typos you might want to use
-GitHub's built in file editor. It allows you to preview your changes
-right online (though there can be some differences between GitHub
-markdown and Sphinx RST). Just be careful not to create many commits.
+Alternatively, for small changes and typo's you might want to use GitHub's built in file editor. It allows
+you to preview your changes right online. Just be careful not to create many commits.

 Images
 ------
-
-When you need to add images, try to make them as small as possible
-(e.g. as gif). Usually images should go in the same directory as the
-.rst file which references them, or in a subdirectory if one already
-exists.
+When you need to add images, try to make them as small as possible (e.g. as gif).

 Notes
 -----
@@ -97,7 +41,7 @@ lessc ``lessc main.less`` or watched using watch-lessc ``watch-lessc -i main.les

 Guides on using sphinx
 ----------------------
-* To make links to certain sections create a link target like so:
+* To make links to certain pages create a link target like so:

  ```
    .. _hello_world:
@@ -108,10 +52,7 @@ Guides on using sphinx
    This is.. (etc.)
  ```

-  The ``_hello_world:`` will make it possible to link to this position
-  (page and section heading) from all other pages. See the [Sphinx
-  docs](http://sphinx-doc.org/markup/inline.html#role-ref) for more
-  information and examples.
+  The ``_hello_world:`` will make it possible to link to this position (page and marker) from all other pages.

 * Notes, warnings and alarms

@@ -127,17 +68,13 @@ Guides on using sphinx

 * Code examples

-  * Start without $, so it's easy to copy and paste.
-  * Use "sudo" with docker to ensure that your command is runnable
-    even if they haven't [used the *docker*
-    group](http://docs.docker.io/en/latest/use/basics/#why-sudo).
+  Start without $, so it's easy to copy and paste.

 Manpages
 --------

-* To make the manpages, run ``make man``. Please note there is a bug
-  in spinx 1.1.3 which makes this fail.  Upgrade to the latest version
-  of Sphinx.
-* Then preview the manpage by running ``man _build/man/docker.1``,
-  where ``_build/man/docker.1`` is the path to the generated manfile
-
+* To make the manpages, simply run 'make man'. Please note there is a bug in spinx 1.1.3 which makes this fail.
+Upgrade to the latest version of sphinx.
+* Then preview the manpage by running `man _build/man/docker.1`, where _build/man/docker.1 is the path to the generated
+manfile
+* The manpages are also autogenerated by our hosted readthedocs here: http://docs-docker.dotcloud.com/projects/docker/downloads/
@@ -1,2 +1,2 @@
 Sphinx==1.1.3
-sphinxcontrib-httpdomain==1.1.9
+sphinxcontrib-httpdomain==1.1.8
@@ -26,125 +26,16 @@ Docker Remote API
 2. Versions
 ===========

-The current version of the API is 1.7
+The current version of the API is 1.6

 Calling /images/<name>/insert is the same as calling
-/v1.7/images/<name>/insert
+/v1.6/images/<name>/insert

 You can still call an old version of the api using
 /v1.0/images/<name>/insert

-v1.7
-****
-
-Full Documentation
------------------
-
-:doc:`docker_remote_api_v1.7`
-
-What's new
----------
-
-.. http:get:: /images/json
-
-   The format of the json returned from this uri changed.  Instead of an entry
-   for each repo/tag on an image, each image is only represented once, with a
-   nested attribute indicating the repo/tags that apply to that image.
-
-   Instead of:
-
-   .. sourcecode:: http
-
-      HTTP/1.1 200 OK
-      Content-Type: application/json
-
-      [
-        {
-          "VirtualSize": 131506275,
-          "Size": 131506275,
-          "Created": 1365714795,
-          "Id": "8dbd9e392a964056420e5d58ca5cc376ef18e2de93b5cc90e868a1bbc8318c1c",
-          "Tag": "12.04",
-          "Repository": "ubuntu"
-        },
-        {
-          "VirtualSize": 131506275,
-          "Size": 131506275,
-          "Created": 1365714795,
-          "Id": "8dbd9e392a964056420e5d58ca5cc376ef18e2de93b5cc90e868a1bbc8318c1c",
-          "Tag": "latest",
-          "Repository": "ubuntu"
-        },
-        {
-          "VirtualSize": 131506275,
-          "Size": 131506275,
-          "Created": 1365714795,
-          "Id": "8dbd9e392a964056420e5d58ca5cc376ef18e2de93b5cc90e868a1bbc8318c1c",
-          "Tag": "precise",
-          "Repository": "ubuntu"
-        },
-        {
-          "VirtualSize": 180116135,
-          "Size": 24653,
-          "Created": 1364102658,
-          "Id": "b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc",
-          "Tag": "12.10",
-          "Repository": "ubuntu"
-        },
-        {
-          "VirtualSize": 180116135,
-          "Size": 24653,
-          "Created": 1364102658,
-          "Id": "b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc",
-          "Tag": "quantal",
-          "Repository": "ubuntu"
-        }
-      ]
-
-   The returned json looks like this:
-
-   .. sourcecode:: http
-
-      HTTP/1.1 200 OK
-      Content-Type: application/json
-      
-      [
-        {
-           "RepoTag": [
-             "ubuntu:12.04",
-             "ubuntu:precise",
-             "ubuntu:latest"
-           ],
-           "Id": "8dbd9e392a964056420e5d58ca5cc376ef18e2de93b5cc90e868a1bbc8318c1c",
-           "Created": 1365714795,
-           "Size": 131506275,
-           "VirtualSize": 131506275
-        },
-        {
-           "RepoTag": [
-             "ubuntu:12.10",
-             "ubuntu:quantal"
-           ],
-           "ParentId": "27cf784147099545",
-           "Id": "b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc",
-           "Created": 1364102658,
-           "Size": 24653,
-           "VirtualSize": 180116135
-        }
-      ]
-
-.. http:get:: /images/viz
-
-   This URI no longer exists.  The ``images -viz`` output is now generated in
-   the client, using the ``/images/json`` data.
-
-v1.6
-****
-
-Full Documentation
------------------
-
 :doc:`docker_remote_api_v1.6`
+*****************************

 What's new
 ----------
@@ -158,13 +49,8 @@ What's new
   stderr are merged.


-v1.5
-****
-
-Full Documentation
------------------
-
 :doc:`docker_remote_api_v1.5`
+*****************************

 What's new
 ----------
@@ -185,13 +71,8 @@ What's new
   dicts each containing `PublicPort`, `PrivatePort` and `Type` describing a
   port mapping.

-v1.4
-****
-
-Full Documentation
------------------
-
 :doc:`docker_remote_api_v1.4`
+*****************************

 What's new
 ----------
@@ -208,16 +89,11 @@ What's new

   **New!** Image's name added in the events

-v1.3
-****
+:doc:`docker_remote_api_v1.3`
+*****************************

 docker v0.5.0 51f6c4a_

-Full Documentation
------------------
-
-:doc:`docker_remote_api_v1.3`
-
 What's new
 ----------

@@ -250,16 +126,11 @@ Start containers (/containers/<id>/start):
 - You can now pass host-specific configuration (e.g. bind mounts) in
  the POST body for start calls

-v1.2
-****
+:doc:`docker_remote_api_v1.2`
+*****************************

 docker v0.4.2 2e7649b_

-Full Documentation
------------------
-
-:doc:`docker_remote_api_v1.2`
-
 What's new
 ----------

@@ -285,16 +156,11 @@ The client should send it's authConfig as POST on each call of
  deleted/untagged.


-v1.1
-****
+:doc:`docker_remote_api_v1.1`
+*****************************

 docker v0.4.0 a8ae398_

-Full Documentation
------------------
-
-:doc:`docker_remote_api_v1.1`
-
 What's new
 ----------

@@ -314,15 +180,11 @@ What's new
 	   {"error":"Invalid..."}
 	   ...

-v1.0
-****
-
-docker v0.3.4 8d73740_
-
-Full Documentation
------------------

 :doc:`docker_remote_api_v1.0`
+*****************************
+
+docker v0.3.4 8d73740_

 What's new
 ----------
@@ -970,33 +970,28 @@ Create a new image from a container's changes

 	**Example request**:

-    .. sourcecode:: http
+        .. sourcecode:: http

-       POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1
-       Content-Type: application/json
-   
-       {
-           "Cmd": ["cat", "/world"],
-           "PortSpecs":["22"]
-       }
+           POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1

-    **Example response**:
+        **Example response**:

-    .. sourcecode:: http
+        .. sourcecode:: http

-       HTTP/1.1 201 OK
-       Content-Type: application/vnd.docker.raw-stream
+           HTTP/1.1 201 OK
+	   Content-Type: application/vnd.docker.raw-stream

-       {"Id":"596069db4bf5"}
+           {"Id":"596069db4bf5"}

-    :query container: source container
-    :query repo: repository
-    :query tag: tag
-    :query m: commit message
-    :query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
-    :statuscode 201: no error
-    :statuscode 404: no such container
-    :statuscode 500: server error
+	:query container: source container
+	:query repo: repository
+	:query tag: tag
+	:query m: commit message
+	:query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
+	:query run: config automatically applied when the image is run. (ex: {"Cmd": ["cat", "/world"], "PortSpecs":["22"]})
+        :statuscode 201: no error
+	:statuscode 404: no such container
+        :statuscode 500: server error


 3. Going further
@@ -977,37 +977,32 @@ Create a new image from a container's changes

 .. http:post:: /commit

-    Create a new image from a container's changes
+	Create a new image from a container's changes

-    **Example request**:
-    
-    .. sourcecode:: http
-    
-       POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1
-       Content-Type: application/json
-   
-       {
-           "Cmd": ["cat", "/world"],
-           "PortSpecs":["22"]
-       }
-    
-    **Example response**:
-    
-    .. sourcecode:: http
-    
-        HTTP/1.1 201 OK
-        Content-Type: application/vnd.docker.raw-stream
+	**Example request**:

-        {"Id":"596069db4bf5"}
+        .. sourcecode:: http

-    :query container: source container
-    :query repo: repository
-    :query tag: tag
-    :query m: commit message
-    :query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
-    :statuscode 201: no error
-    :statuscode 404: no such container
-    :statuscode 500: server error
+           POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1
+
+        **Example response**:
+
+        .. sourcecode:: http
+
+           HTTP/1.1 201 OK
+	   Content-Type: application/vnd.docker.raw-stream
+
+           {"Id":"596069db4bf5"}
+
+	:query container: source container
+	:query repo: repository
+	:query tag: tag
+	:query m: commit message
+	:query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
+	:query run: config automatically applied when the image is run. (ex: {"Cmd": ["cat", "/world"], "PortSpecs":["22"]})
+        :statuscode 201: no error
+	:statuscode 404: no such container
+        :statuscode 500: server error


 3. Going further
@@ -985,37 +985,32 @@ Create a new image from a container's changes

 .. http:post:: /commit

-    Create a new image from a container's changes
+	Create a new image from a container's changes

-    **Example request**:
+	**Example request**:

-    .. sourcecode:: http
+        .. sourcecode:: http

-       POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1
-       Content-Type: application/json
-   
-       {
-           "Cmd": ["cat", "/world"],
-           "PortSpecs":["22"]
-       }
+           POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1

-    **Example response**:
+        **Example response**:

-    .. sourcecode:: http
+        .. sourcecode:: http

-       HTTP/1.1 201 OK
+           HTTP/1.1 201 OK
 	   Content-Type: application/vnd.docker.raw-stream

-       {"Id":"596069db4bf5"}
+           {"Id":"596069db4bf5"}

-    :query container: source container
-    :query repo: repository
-    :query tag: tag
-    :query m: commit message
-    :query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
-    :statuscode 201: no error
-    :statuscode 404: no such container
-    :statuscode 500: server error
+	:query container: source container
+	:query repo: repository
+	:query tag: tag
+	:query m: commit message
+	:query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
+	:query run: config automatically applied when the image is run. (ex: {"Cmd": ["cat", "/world"], "PortSpecs":["22"]})
+        :statuscode 201: no error
+	:statuscode 404: no such container
+        :statuscode 500: server error


 3. Going further
@@ -1034,37 +1034,32 @@ Create a new image from a container's changes

 .. http:post:: /commit

-    Create a new image from a container's changes
+	Create a new image from a container's changes

-    **Example request**:
+	**Example request**:

-    .. sourcecode:: http
+        .. sourcecode:: http

-       POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1
-       Content-Type: application/json
-   
-       {
-           "Cmd": ["cat", "/world"],
-           "PortSpecs":["22"]
-       }
+           POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1

-    **Example response**:
+        **Example response**:

-    .. sourcecode:: http
+        .. sourcecode:: http

-       HTTP/1.1 201 OK
+           HTTP/1.1 201 OK
 	   Content-Type: application/vnd.docker.raw-stream

-       {"Id":"596069db4bf5"}
+           {"Id":"596069db4bf5"}

-    :query container: source container
-    :query repo: repository
-    :query tag: tag
-    :query m: commit message
-    :query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
-    :statuscode 201: no error
-    :statuscode 404: no such container
-    :statuscode 500: server error
+	:query container: source container
+	:query repo: repository
+	:query tag: tag
+	:query m: commit message
+	:query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
+	:query run: config automatically applied when the image is run. (ex: {"Cmd": ["cat", "/world"], "PortSpecs":["22"]})
+        :statuscode 201: no error
+	:statuscode 404: no such container
+        :statuscode 500: server error


 Monitor Docker's events
@@ -943,36 +943,36 @@ Build an image from Dockerfile via stdin

 .. http:post:: /build

-    Build an image from Dockerfile via stdin
+   Build an image from Dockerfile via stdin

-    **Example request**:
+   **Example request**:

-    .. sourcecode:: http
+   .. sourcecode:: http

-        POST /build HTTP/1.1
+      POST /build HTTP/1.1

-        {{ STREAM }}
+      {{ STREAM }}

-    **Example response**:
+   **Example response**:

-    .. sourcecode:: http
+   .. sourcecode:: http

-        HTTP/1.1 200 OK
+      HTTP/1.1 200 OK

-        {{ STREAM }}
+      {{ STREAM }}


-    The stream must be a tar archive compressed with one of the following algorithms:
-    identity (no compression), gzip, bzip2, xz. The archive must include a file called
-    `Dockerfile` at its root. It may include any number of other files, which will be
-    accessible in the build context (See the ADD build command).
+       The stream must be a tar archive compressed with one of the following algorithms:
+       identity (no compression), gzip, bzip2, xz. The archive must include a file called
+       `Dockerfile` at its root. It may include any number of other files, which will be
+       accessible in the build context (See the ADD build command).

-    The Content-type header should be set to "application/tar".
+       The Content-type header should be set to "application/tar".

-    :query t: repository name (and optionally a tag) to be applied to the resulting image in case of success
-    :query q: suppress verbose build output
+	:query t: repository name (and optionally a tag) to be applied to the resulting image in case of success
+	:query q: suppress verbose build output
    :query nocache: do not use the cache when building the image
-    :statuscode 200: no error
+	:statuscode 200: no error
    :statuscode 500: server error


@@ -1069,8 +1069,8 @@ Show the docker version information
 		"GoVersion":"go1.0.3"
 	   }

-    :statuscode 200: no error
-    :statuscode 500: server error
+        :statuscode 200: no error
+	:statuscode 500: server error


 Create a new image from a container's changes
@@ -1084,28 +1084,23 @@ Create a new image from a container's changes

    .. sourcecode:: http

-       POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1
-       Content-Type: application/json
-   
-       {
-           "Cmd": ["cat", "/world"],
-           "PortSpecs":["22"]
-       }
+        POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1

    **Example response**:

    .. sourcecode:: http

-       HTTP/1.1 201 OK
-	   Content-Type: application/vnd.docker.raw-stream
+        HTTP/1.1 201 OK
+	    Content-Type: application/vnd.docker.raw-stream

-       {"Id":"596069db4bf5"}
+        {"Id":"596069db4bf5"}

    :query container: source container
    :query repo: repository
    :query tag: tag
    :query m: commit message
    :query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
+    :query run: config automatically applied when the image is run. (ex: {"Cmd": ["cat", "/world"], "PortSpecs":["22"]})
    :statuscode 201: no error
    :statuscode 404: no such container
    :statuscode 500: server error
@@ -13,12 +13,9 @@ Docker Remote API v1.6
 1. Brief introduction
 =====================

- The Remote API has replaced rcli
- The daemon listens on ``unix:///var/run/docker.sock``, but you can
-  :ref:`bind_docker`.
- The API tends to be REST, but for some complex commands, like
-  ``attach`` or ``pull``, the HTTP connection is hijacked to transport
-  ``stdout, stdin`` and ``stderr``
+- The Remote API is replacing rcli
+- Default port in the docker daemon is 4243
+- The API tends to be REST, but for some complex commands, like attach or pull, the HTTP connection is hijacked to transport stdout stdin and stderr

 2. Endpoints
 ============
@@ -121,7 +118,8 @@ Create a container
 		"AttachStdin":false,
 		"AttachStdout":true,
 		"AttachStderr":true,
-		"ExposedPorts":{},
+		"PortSpecs":null,
+		"Privileged": false,
 		"Tty":false,
 		"OpenStdin":false,
 		"StdinOnce":false,
@@ -134,6 +132,7 @@ Create a container
 		"Volumes":{},
 		"VolumesFrom":"",
 		"WorkingDir":""
+
 	   }
 	   
 	**Example response**:
@@ -149,63 +148,11 @@ Create a container
 	   }
 	
 	:jsonparam config: the container's configuration
- 	:query name: container name to use
 	:statuscode 201: no error
 	:statuscode 404: no such container
 	:statuscode 406: impossible to attach (container not running)
 	:statuscode 500: server error

-	**More Complex Example request, in 2 steps.**
-	**First, use create to expose a Private Port, which can be bound back to a Public Port at startup**:
-
-	.. sourcecode:: http
-
-	   POST /containers/create HTTP/1.1
-	   Content-Type: application/json
-
-	   {
-		"Cmd":[
-			"/usr/sbin/sshd","-D"
-		],
-		"Image":"image-with-sshd",
-		"ExposedPorts":{"22/tcp":{}}
-		}
-
-	**Example response**:
-
-	.. sourcecode:: http
-
-	   HTTP/1.1 201 OK
-	   Content-Type: application/json
-
-	   {
-		"Id":"e90e34656806"
-		"Warnings":[]
-	   }
-
-	**Second, start (using the ID returned above) the image we just created, mapping the ssh port 22 to something on the host**:
-
-	.. sourcecode:: http
-
-	   POST /containers/e90e34656806/start HTTP/1.1
-	   Content-Type: application/json
-
-	   {
-		"PortBindings": { "22/tcp": [{ "HostPort": "11022" }]} 
-		}
-
-	**Example response**:
-
-	.. sourcecode:: http
-
-		HTTP/1.1 204 No Content
-		Content-Type: text/plain; charset=utf-8
-		Content-Length: 0
-
-	**Now you can ssh into your new container on port 11022.**
-
-
-

 Inspect a container
 *******************
@@ -240,7 +187,7 @@ Inspect a container
 				"AttachStdin": false,
 				"AttachStdout": true,
 				"AttachStderr": true,
-				"ExposedPorts": {},
+				"PortSpecs": null,
 				"Tty": false,
 				"OpenStdin": false,
 				"StdinOnce": false,
@@ -411,12 +358,7 @@ Start a container

           {
                "Binds":["/tmp:/tmp"],
-                "LxcConf":{"lxc.utsname":"docker"},
-                "ContainerIDFile": "",
-                "Privileged": false,
-                "PortBindings": {"22/tcp": [{HostIp:"", HostPort:""}]},
-                "Links": [],
-                "PublishAllPorts": false
+                "LxcConf":{"lxc.utsname":"docker"}
           }

        **Example response**:
@@ -500,8 +442,7 @@ Kill a container
 	.. sourcecode:: http

 	   HTTP/1.1 204 OK
-
-	:query signal: Signal to send to the container (integer). When not set, SIGKILL is assumed and the call will waits for the container to exit.
+	   	
 	:statuscode 204: no error
 	:statuscode 404: no such container
 	:statuscode 500: server error
@@ -849,7 +790,7 @@ Inspect an image
 				"AttachStdin":false,
 				"AttachStdout":false,
 				"AttachStderr":false,
-				"ExposedPorts":{},
+				"PortSpecs":null,
 				"Tty":true,
 				"OpenStdin":true,
 				"StdinOnce":false,
@@ -1049,36 +990,36 @@ Build an image from Dockerfile via stdin

 .. http:post:: /build

-    Build an image from Dockerfile via stdin
+   Build an image from Dockerfile via stdin

-    **Example request**:
+   **Example request**:

-    .. sourcecode:: http
+   .. sourcecode:: http

-        POST /build HTTP/1.1
+      POST /build HTTP/1.1

-        {{ STREAM }}
+      {{ STREAM }}

-    **Example response**:
+   **Example response**:

-    .. sourcecode:: http
+   .. sourcecode:: http

-        HTTP/1.1 200 OK
+      HTTP/1.1 200 OK

-        {{ STREAM }}
+      {{ STREAM }}


-    The stream must be a tar archive compressed with one of the following algorithms:
-    identity (no compression), gzip, bzip2, xz. The archive must include a file called
-    `Dockerfile` at its root. It may include any number of other files, which will be
-    accessible in the build context (See the ADD build command).
-    
-    The Content-type header should be set to "application/tar".
+       The stream must be a tar archive compressed with one of the following algorithms:
+       identity (no compression), gzip, bzip2, xz. The archive must include a file called
+       `Dockerfile` at its root. It may include any number of other files, which will be
+       accessible in the build context (See the ADD build command).

-    :query t: repository name (and optionally a tag) to be applied to the resulting image in case of success
-    :query q: suppress verbose build output
+       The Content-type header should be set to "application/tar".
+
+	:query t: repository name (and optionally a tag) to be applied to the resulting image in case of success
+	:query q: suppress verbose build output
    :query nocache: do not use the cache when building the image
-    :statuscode 200: no error
+	:statuscode 200: no error
    :statuscode 500: server error


@@ -1190,13 +1131,7 @@ Create a new image from a container's changes

    .. sourcecode:: http

-       POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1
-       Content-Type: application/json
-       
-       {
-           "Cmd": ["cat", "/world"],
-           "ExposedPorts":{"22/tcp":{}}
-       }
+        POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1

    **Example response**:

@@ -1212,6 +1147,7 @@ Create a new image from a container's changes
    :query tag: tag
    :query m: commit message
    :query author: author (eg. "John Hannibal Smith <hannibal@a-team.com>")
+    :query run: config automatically applied when the image is run. (ex: {"Cmd": ["cat", "/world"], "PortSpecs":["22"]})
    :statuscode 201: no error
    :statuscode 404: no such container
    :statuscode 500: server error
@@ -14,5 +14,5 @@ Your programs and scripts can access Docker's functionality via these interfaces
  registry_api
  index_api
  docker_remote_api
-  remote_api_client_libraries
+

@@ -463,7 +463,7 @@ Ancestry
 2.4 Status
 ----------

-.. http:get:: /v1/_ping
+.. http:get /v1/_ping

    Check status of the registry. This endpoint is also used to determine if
    the registry supports SSL.
@@ -479,6 +479,9 @@ Ancestry

        ""

+    :parameter namespace: namespace for the repo
+    :parameter repository: name for the repo
+
    **Example Response**:

    .. sourcecode:: http
@@ -1,4 +1,4 @@
-:title: Remote API Client Libraries
+:title: Registry API
 :description: Various client libraries available to use with the Docker remote API
 :keywords: API, Docker, index, registry, REST, documentation, clients, Python, Ruby, Javascript, Erlang, Go

@@ -12,28 +12,26 @@ compatibility. Please file issues with the library owners.  If you
 find more library implementations, please list them in Docker doc bugs
 and we will add the libraries here.

-+----------------------+----------------+--------------------------------------------+----------+
-| Language/Framework   | Name           | Repository                                 | Status   |
-+======================+================+============================================+==========+
-| Python               | docker-py      | https://github.com/dotcloud/docker-py      | Active   |
-+----------------------+----------------+--------------------------------------------+----------+
-| Ruby                 | docker-client  | https://github.com/geku/docker-client      | Outdated |
-+----------------------+----------------+--------------------------------------------+----------+
-| Ruby                 | docker-api     | https://github.com/swipely/docker-api      | Active   |
-+----------------------+----------------+--------------------------------------------+----------+
-| Javascript (NodeJS)  | docker.io      | https://github.com/appersonlabs/docker.io  | Active   |
-|                      |                | Install via NPM: `npm install docker.io`   |          |
-+----------------------+----------------+--------------------------------------------+----------+
-| Javascript           | docker-js      | https://github.com/dgoujard/docker-js      | Active   |
-+----------------------+----------------+--------------------------------------------+----------+
-| Javascript (Angular) | dockerui       | https://github.com/crosbymichael/dockerui  | Active   |
-| **WebUI**            |                |                                            |          |
-+----------------------+----------------+--------------------------------------------+----------+
-| Java                 | docker-java    | https://github.com/kpelykh/docker-java     | Active   |
-+----------------------+----------------+--------------------------------------------+----------+
-| Erlang               | erldocker      | https://github.com/proger/erldocker        | Active   |
-+----------------------+----------------+--------------------------------------------+----------+
-| Go                   | go-dockerclient| https://github.com/fsouza/go-dockerclient  | Active   |
-+----------------------+----------------+--------------------------------------------+----------+
-| PHP                  | Alvine         | http://pear.alvine.io/ (alpha)             | Active   |
-+----------------------+----------------+--------------------------------------------+----------+
+----------------------+----------------+--------------------------------------------+
+| Language/Framework   | Name           | Repository                                 |
+======================+================+============================================+
+| Python               | docker-py      | https://github.com/dotcloud/docker-py      |
+----------------------+----------------+--------------------------------------------+
+| Ruby                 | docker-client  | https://github.com/geku/docker-client      |
+----------------------+----------------+--------------------------------------------+
+| Ruby                 | docker-api     | https://github.com/swipely/docker-api      |
+----------------------+----------------+--------------------------------------------+
+| Javascript (NodeJS)  | docker.io      | https://github.com/appersonlabs/docker.io  |
+|                      |                | Install via NPM: `npm install docker.io`   |
+----------------------+----------------+--------------------------------------------+
+| Javascript           | docker-js      | https://github.com/dgoujard/docker-js      |
+----------------------+----------------+--------------------------------------------+
+| Javascript (Angular) | dockerui       | https://github.com/crosbymichael/dockerui  |
+| **WebUI**            |                |                                            |
+----------------------+----------------+--------------------------------------------+
+| Java                 | docker-java    | https://github.com/kpelykh/docker-java     |
+----------------------+----------------+--------------------------------------------+
+| Erlang               | erldocker      | https://github.com/proger/erldocker        |
+----------------------+----------------+--------------------------------------------+
+| Go                   | go-dockerclient| https://github.com/fsouza/go-dockerclient  |
+----------------------+----------------+--------------------------------------------+
@@ -0,0 +1,59 @@
+:title: Attach Command
+:description: Attach to a running container
+:keywords: attach, container, docker, documentation
+
+===========================================
+``attach`` -- Attach to a running container
+===========================================
+
+::
+
+    Usage: docker attach CONTAINER
+
+    Attach to a running container.
+
+You can detach from the container again (and leave it running) with
+``CTRL-c`` (for a quiet exit) or ``CTRL-\`` to get a stacktrace of
+the Docker client when it quits.
+
+To stop a container, use ``docker stop``
+
+To kill the container, use ``docker kill``
+ 
+Examples:
+---------
+
+.. code-block:: bash
+
+     $ ID=$(sudo docker run -d ubuntu /usr/bin/top -b)
+     $ sudo docker attach $ID
+     top - 02:05:52 up  3:05,  0 users,  load average: 0.01, 0.02, 0.05
+     Tasks:   1 total,   1 running,   0 sleeping,   0 stopped,   0 zombie
+     Cpu(s):  0.1%us,  0.2%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
+     Mem:    373572k total,   355560k used,    18012k free,    27872k buffers
+     Swap:   786428k total,        0k used,   786428k free,   221740k cached
+
+     PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND            
+      1 root      20   0 17200 1116  912 R    0  0.3   0:00.03 top                
+
+      top - 02:05:55 up  3:05,  0 users,  load average: 0.01, 0.02, 0.05
+      Tasks:   1 total,   1 running,   0 sleeping,   0 stopped,   0 zombie
+      Cpu(s):  0.0%us,  0.2%sy,  0.0%ni, 99.8%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
+      Mem:    373572k total,   355244k used,    18328k free,    27872k buffers
+      Swap:   786428k total,        0k used,   786428k free,   221776k cached
+
+        PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND            
+	    1 root      20   0 17208 1144  932 R    0  0.3   0:00.03 top                
+
+
+      top - 02:05:58 up  3:06,  0 users,  load average: 0.01, 0.02, 0.05
+      Tasks:   1 total,   1 running,   0 sleeping,   0 stopped,   0 zombie
+      Cpu(s):  0.2%us,  0.3%sy,  0.0%ni, 99.5%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
+      Mem:    373572k total,   355780k used,    17792k free,    27880k buffers
+      Swap:   786428k total,        0k used,   786428k free,   221776k cached
+
+      PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND            
+           1 root      20   0 17208 1144  932 R    0  0.3   0:00.03 top                
+     ^C$ 
+     $ sudo docker stop $ID
+
@@ -0,0 +1,65 @@
+:title: Build Command
+:description: Build a new image from the Dockerfile passed via stdin
+:keywords: build, docker, container, documentation
+
+================================================
+``build`` -- Build a container from a Dockerfile
+================================================
+
+::
+
+    Usage: docker build [OPTIONS] PATH | URL | -
+    Build a new container image from the source code at PATH
+      -t="": Repository name (and optionally a tag) to be applied to the resulting image in case of success.
+      -q=false: Suppress verbose build output.
+      -no-cache: Do not use the cache when building the image.
+      -rm: Remove intermediate containers after a successful build
+    When a single Dockerfile is given as URL, then no context is set. When a git repository is set as URL, the repository is used as context
+
+
+Examples
+--------
+
+.. code-block:: bash
+
+    sudo docker build .
+
+This will read the ``Dockerfile`` from the current directory. It will
+also send any other files and directories found in the current
+directory to the ``docker`` daemon.
+
+The contents of this directory would be used by ``ADD`` commands found
+within the ``Dockerfile``.  This will send a lot of data to the
+``docker`` daemon if the current directory contains a lot of data.  If
+the absolute path is provided instead of ``.`` then only the files and
+directories required by the ADD commands from the ``Dockerfile`` will be
+added to the context and transferred to the ``docker`` daemon.
+
+.. code-block:: bash
+
+   sudo docker build -t vieux/apache:2.0 .
+
+This will build like the previous example, but it will then tag the
+resulting image. The repository name will be ``vieux/apache`` and the
+tag will be ``2.0``
+
+
+.. code-block:: bash
+
+    sudo docker build - < Dockerfile
+
+This will read a ``Dockerfile`` from *stdin* without context. Due to
+the lack of a context, no contents of any local directory will be sent
+to the ``docker`` daemon.  ``ADD`` doesn't work when running in this
+mode because the absence of the context provides no source files to
+copy to the container.
+
+
+.. code-block:: bash
+
+    sudo docker build github.com/creack/docker-firefox
+
+This will clone the Github repository and use it as context. The
+``Dockerfile`` at the root of the repository is used as
+``Dockerfile``.  Note that you can specify an arbitrary git repository
+by using the ``git://`` schema.
@@ -0,0 +1,52 @@
+:title: Commit Command
+:description: Create a new image from a container's changes
+:keywords: commit, docker, container, documentation
+
+===========================================================
+``commit`` -- Create a new image from a container's changes
+===========================================================
+
+::
+
+    Usage: docker commit [OPTIONS] CONTAINER [REPOSITORY [TAG]]
+
+    Create a new image from a container's changes
+
+      -m="": Commit message
+      -author="": Author (eg. "John Hannibal Smith <hannibal@a-team.com>"
+      -run="": Configuration to be applied when the image is launched with `docker run`. 
+               (ex: '{"Cmd": ["cat", "/world"], "PortSpecs": ["22"]}')
+
+Full -run example (multiline is ok within a single quote ``'``)
+
+::
+
+  $ sudo docker commit -run='
+  {
+      "Entrypoint" : null,
+      "Privileged" : false,
+      "User" : "",
+      "VolumesFrom" : "",
+      "Cmd" : ["cat", "-e", "/etc/resolv.conf"],
+      "Dns" : ["8.8.8.8", "8.8.4.4"],
+      "MemorySwap" : 0,
+      "AttachStdin" : false,
+      "AttachStderr" : false,
+      "CpuShares" : 0,
+      "OpenStdin" : false,
+      "Volumes" : null,
+      "Hostname" : "122612f45831",
+      "PortSpecs" : ["22", "80", "443"],
+      "Image" : "b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc",
+      "Tty" : false,
+      "Env" : [
+         "HOME=/",
+         "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+      ],
+      "StdinOnce" : false,
+      "Domainname" : "",
+      "WorkingDir" : "/",
+      "NetworkDisabled" : false,
+      "Memory" : 0,
+      "AttachStdout" : false
+  }' $CONTAINER_ID
@@ -0,0 +1,14 @@
+:title: Cp Command
+:description: Copy files/folders from the containers filesystem to the host path
+:keywords: cp, docker, container, documentation, copy
+
+============================================================================
+``cp`` -- Copy files/folders from the containers filesystem to the host path
+============================================================================
+
+::
+
+    Usage: docker cp CONTAINER:RESOURCE HOSTPATH
+
+    Copy files/folders from the containers filesystem to the host
+    path.  Paths are relative to the root of the filesystem.
@@ -0,0 +1,13 @@
+:title: Diff Command
+:description: Inspect changes on a container's filesystem
+:keywords: diff, docker, container, documentation
+
+=======================================================
+``diff`` -- Inspect changes on a container's filesystem
+=======================================================
+
+::
+
+    Usage: docker diff CONTAINER [OPTIONS]
+
+    Inspect changes on a container's filesystem
@@ -0,0 +1,34 @@
+:title: Events Command
+:description: Get real time events from the server
+:keywords: events, docker, documentation
+
+=================================================================
+``events`` -- Get real time events from the server
+=================================================================
+
+::
+
+    Usage: docker events
+
+    Get real time events from the server
+
+Examples
+--------
+
+Starting and stopping a container
+.................................
+
+.. code-block:: bash
+
+    $ sudo docker start 4386fb97867d
+    $ sudo docker stop 4386fb97867d
+
+In another shell
+
+.. code-block:: bash
+    
+    $ sudo docker events
+    [2013-09-03 15:49:26 +0200 CEST] 4386fb97867d: (from 12de384bfb10) start
+    [2013-09-03 15:49:29 +0200 CEST] 4386fb97867d: (from 12de384bfb10) die
+    [2013-09-03 15:49:29 +0200 CEST] 4386fb97867d: (from 12de384bfb10) stop
+
@@ -0,0 +1,13 @@
+:title: Export Command
+:description: Export the contents of a filesystem as a tar archive
+:keywords: export, docker, container, documentation
+
+=================================================================
+``export`` -- Stream the contents of a container as a tar archive
+=================================================================
+
+::
+
+    Usage: docker export CONTAINER
+
+    Export the contents of a filesystem as a tar archive
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Michael Crosby	e245abcc4d	Fix rebase conflicts from master	2013-10-02 13:58:43 -07:00
Michael Crosby	19c53c3833	Add docs and maintainers file for new sub pkgs	2013-10-02 12:48:27 -07:00
Michael Crosby	51db855bc3	Remove network connection when link is removed	2013-10-02 12:44:41 -07:00
Michael Crosby	8c1fae65d3	Convert links to upper case	2013-10-02 12:44:41 -07:00
Michael Crosby	018d3178e3	Add support for names with start command	2013-10-02 12:43:09 -07:00
Michael Crosby	2bae258bff	Update make script for ldl	2013-10-02 12:43:09 -07:00
Michael Crosby	394d2f4ea7	Add sqlite as graphdb backend Add build steps to compile docker statically with CGO enabled	2013-10-02 12:43:09 -07:00
Michael Crosby	457a9260bc	Refactor to use graph for linking	2013-10-02 12:38:41 -07:00
Michael Crosby	e4fbeddf53	Add gograph database to handle linking	2013-10-02 12:38:41 -07:00
Michael Crosby	a32741b1c2	Remove top level link command and endpoint	2013-10-02 12:38:41 -07:00
Michael Crosby	a5dbb9a900	Add name and alias to docker ps output	2013-10-02 12:38:41 -07:00
Michael Crosby	21b9c9c7b4	Restore container links at runtime start	2013-10-02 12:38:41 -07:00
Michael Crosby	828ba3494d	Update new unittests after rebase	2013-10-02 12:38:41 -07:00
Michael Crosby	583340bd56	Add default port for link Add links unit test file	2013-10-02 12:38:41 -07:00
Michael Crosby	12d3e3e644	Add view all links for the engine	2013-10-02 12:38:41 -07:00
Michael Crosby	e574bbf55e	Do not reference ports for linking containers	2013-10-02 12:38:41 -07:00
Michael Crosby	377bfc3ad2	Create LinkRepository during runtime init	2013-10-02 12:38:41 -07:00
Michael Crosby	c7d854af01	Create private link via iptables to linked containers Allow active links to be removed	2013-10-02 12:38:41 -07:00
Michael Crosby	a712b7467e	Prevent inter-container communication	2013-10-02 12:38:41 -07:00
Michael Crosby	248e0c63db	Add port and ip for links	2013-10-02 12:38:41 -07:00
Michael Crosby	20c962696f	Initial commit to add links and inject env	2013-10-02 12:38:41 -07:00
Michael Crosby	234587e0ef	Refactor internal port mappings	2013-10-02 12:38:41 -07:00
Michael Crosby	78adacde93	Add IP to APIPort struct	2013-10-02 12:38:41 -07:00
Michael Crosby	2e6329a904	Add -expose flag to expose ports without publishing	2013-10-02 12:38:40 -07:00
Michael Crosby	3e6d3ad1e4	Add warning and build error for public image ports	2013-10-02 12:38:40 -07:00
Michael Crosby	1b3baab4a8	Add destination to iptables conf	2013-10-02 12:38:40 -07:00
Michael Crosby	c69549e016	Refactor internal port mappings	2013-10-02 12:38:40 -07:00
Michael Crosby	760648e33e	Add flag to set the default ip ports are bound to	2013-10-02 12:36:56 -07:00
Michael Crosby	36b1be2acf	Move proxy into sub package	2013-10-02 12:36:56 -07:00
Michael Crosby	e1be306389	Add DaemonConfig Use a config type for accessing data Add bridgeiface name to config Add option to disable iptables	2013-10-02 12:36:56 -07:00
Michael Crosby	2a76af221f	Move iptables into sub package	2013-10-02 12:36:56 -07:00
				`@@ -1 +0,0 @@`
				`Asbjorn Enge <asbjorn@hanafjedle.net> (@asbjornenge)`
				`@@ -0,0 +1 @@`
				`from brew import build_library, DEFAULT_REPOSITORY, DEFAULT_BRANCH`
				`@@ -1 +0,0 @@`
				`au BufNewFile,BufRead Dockerfile set filetype=dockerfile`