Bump version to 0.6.4

Fix error/debug messages in Container.Attach and recover from ErrClosedPipe

.gitignore

@@ -5,10 +5,7 @@ docker/docker
 a.out
 *.orig
 build_src
-command-line-arguments.test
 .flymake*
-docker.test
-auth/auth.test
 .idea
 .DS_Store
 docs/_build
@@ -16,3 +13,7 @@ docs/_static
 docs/_templates
 .gopath/
 .dotcloud
+*.test
+bundles/
+.hg/
+.git/

.mailmap

@@ -1,4 +1,4 @@
-# Generate AUTHORS: git log --all --format='%aN <%aE>' | sort -uf | grep -v vagrant-ubuntu-12
+# Generate AUTHORS: git log --format='%aN <%aE>' | sort -uf | grep -v vagrant-ubuntu-12
 <charles.hooper@dotcloud.com> <chooper@plumata.com> 
 <daniel.mizyrycki@dotcloud.com> <daniel@dotcloud.com>
 <daniel.mizyrycki@dotcloud.com> <mzdaniel@glidelink.net>
@@ -25,3 +25,16 @@ Walter Stanish <walter@pratyeka.org>
 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>

AUTHORS

@@ -5,87 +5,145 @@
 #
 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>
 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>
+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>
+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>
 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>
 Kevin J. Lynagh <kevin@keminglabs.com>
 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>
+Matt Bachmann <bachmann.matt@gmail.com>
+Matthew Mueller <mattmuelle@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>
 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>
@@ -93,21 +151,38 @@ 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>
+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>
 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>
 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>
+Zaiste! <oh@zaiste.net>

CHANGELOG.md

@@ -1,5 +1,227 @@
 # Changelog
 
+## 0.6.4 (2013-10-15)
+- Runtime: Add cleanup of container when Start() fails
+- Testing: Catch errClosing error when TCP and UDP proxies are terminated
+- Testing: Add aggregated docker-ci email report
+- Testing: Remove a few errors in tests
+* Contrib: Reorganize contributed completion scripts to add zsh completion
+* Contrib: Add vim syntax highlighting for Dockerfiles from @honza
+* Runtime: Add better comments to utils/stdcopy.go
+- Testing: add cleanup to remove leftover containers
+* Documentation: Document how to edit and release docs
+* Documentation: Add initial draft of the Docker infrastructure doc
+* Contrib: Add mkimage-arch.sh
+- Builder: Abort build if mergeConfig returns an error and fix duplicate error message
+- Runtime: Remove error messages which are not actually errors
+* Testing: Only run certain tests with TESTFLAGS='-run TestName' make.sh
+* Testing: Prevent docker-ci to test closing PRs
+- Documentation: Minor updates to postgresql_service.rst
+* Testing: Add nightly release to docker-ci
+* Hack: Improve network performance for VirtualBox
+* Hack: Add vagrant user to the docker group
+* Runtime: Add utils.Errorf for error logging
+- Packaging: Remove deprecated packaging directory
+* Hack: Revamp install.sh to be usable by more people, and to use official install methods whenever possible (apt repo, portage tree, etc.)
+- Hack: Fix contrib/mkimage-debian.sh apt caching prevention
+* Documentation: Clarify LGTM process to contributors
+- Documentation: Small fixes to parameter names in docs for ADD command
+* Runtime: Record termination time in state.
+- Registry: Use correct auth config when logging in.
+- Documentation: Corrected error in the package name
+* Documentation: Document what `vagrant up` is actually doing
+- Runtime: Fix `docker rm` with volumes
+- Runtime: Use empty string so TempDir uses the OS's temp dir automatically
+- Runtime: Make sure to close the network allocators
+* Testing: Replace panic by log.Fatal in tests
++ Documentation: improve doc search results
+- Runtime: Fix some error cases where a HTTP body might not be closed
+* Hack: Add proper bash completion for "docker push"
+* Documentation: Add devenvironment link to CONTRIBUTING.md
+* Documentation: Cleanup whitespace in API 1.5 docs
+* Documentation: use angle brackets in MAINTAINER example email
+- Testing: Increase TestRunDetach timeout
+* Documentation: Fix help text for -v option
++ Hack: Added Dockerfile.tmLanguage to contrib
++ Runtime: Autorestart containers by default
+* Testing: Adding more tests around auth.ResolveAuthConfig
+* Hack: Configured FPM to make /etc/init/docker.conf a config file
+* Hack: Add xz utils as a runtime dep
+* Documentation: Add `apt-get install curl` to Ubuntu docs
+* Documentation: Remove Gentoo install notes about #1422 workaround
+* Documentation: Fix Ping endpoint documentation
+* Runtime: Bump vendor kr/pty to commit 3b1f6487b (syscall.O_NOCTTY)
+* Runtime: lxc: Allow set_file_cap capability in container
+* Documentation: Update archlinux.rst
+- Documentation: Fix ironic typo in changelog
+* Documentation: Add explanation for export restrictions
+* Hack: Add cleanup/refactor portion of #2010 for hack and Dockerfile updates
++ Documentation: Changes to a new style for the docs. Includes version switcher.
+* Documentation: Formatting, add information about multiline json
++ Hack: Add contrib/mkimage-centos.sh back (from #1621), and associated documentation link
+- Runtime: Fix panic with wrong dockercfg file
+- Runtime: Fix the attach behavior with -i
+* Documentation: Add .dockercfg doc
+- Runtime: Move run -rm to the cli only
+* Hack: Enable SSH Agent forwarding in Vagrant VM
++ Runtime: Add -rm to docker run for removing a container on exit
+* Documentation: Improve registry and index REST API documentation
+* Runtime: Split stdout stderr
+- Documentation: Replace deprecated upgrading reference to docker-latest.tgz, which hasn't been updated since 0.5.3
+* Documentation: Update Gentoo installation documentation now that we're in the portage tree proper
+- Registry: Fix the error message so it is the same as the regex
+* Runtime: Always create a new session for the container
+* Hack: Add several of the small make.sh fixes from #1920, and make the output more consistent and contributor-friendly
+* Documentation: Various command fixes in postgres example
+* Documentation: Cleanup and reorganize docs and tooling for contributors and maintainers
+- Documentation: Minor spelling correction of protocoll -> protocol
+* Hack: Several small tweaks/fixes for contrib/mkimage-debian.sh
++ Hack: Add @tianon to hack/MAINTAINERS
+
+## 0.6.3 (2013-09-23)
+* Packaging: Update tar vendor dependency
+- Client: Fix detach issue
+- Runtime: Only copy and change permissions on non-bindmount volumes
+- Registry: Update regular expression to match index
+* Runtime: Allow multiple volumes-from
+* Packaging: Download apt key over HTTPS
+* Documentation: Update section on extracting the docker binary after build
+* Documentation: Update development environment docs for new build process
+* Documentation: Remove 'base' image from documentation
+* Packaging: Add 'docker' group on install for ubuntu package
+- Runtime: Fix HTTP imports from STDIN
+
+## 0.6.2 (2013-09-17)
++ Hack: Vendor all dependencies
++ Builder: Add -rm option in order to remove intermediate containers
++ Runtime: Add domainname support
++ Runtime: Implement image filtering with path.Match
+* Builder: Allow multiline for the RUN instruction
+* Runtime: Remove unnecesasry warnings
+* Runtime: Only mount the hostname file when the config exists
+* Runtime: Handle signals within the `docker login` command
+* Runtime: Remove os/user dependency
+* Registry: Implement login with private registry
+* Remote API: Bump to v1.5
+* Packaging: Break down hack/make.sh into small scripts, one per 'bundle': test, binary, ubuntu etc.
+* Documentation: General improvements
+- Runtime: UID and GID are now also applied to volumes
+- Runtime: `docker start` set error code upon error
+- Runtime: `docker run` set the same error code as the process started
+- Registry: Fix push issues
+
+## 0.6.1 (2013-08-23)
+* Registry: Pass "meta" headers in API calls to the registry
+- Packaging: Use correct upstart script with new build tool
+- Packaging: Use libffi-dev, don't build it from sources
+- Packaging: Removed duplicate mercurial install command
+
+## 0.6.0 (2013-08-22)
+- Runtime: Load authConfig only when needed and fix useless WARNING
++ Runtime: Add lxc-conf flag to allow custom lxc options
+- Runtime: Fix race conditions in parallel pull
+- Runtime: Improve CMD, ENTRYPOINT, and attach docs.
+* Documentation: Small fix to docs regarding adding docker groups
+* Documentation: Add MongoDB image example
++ Builder: Add USER instruction do Dockerfile
+* Documentation: updated default -H docs
+* Remote API: Sort Images by most recent creation date.
++ Builder: Add workdir support for the Buildfile
++ Runtime: Add an option to set the working directory
+- Runtime: Show tag used when image is missing
+* Documentation: Update readme with dependencies for building
+* Documentation: Add instructions for creating and using the docker group
+* Remote API: Reworking opaque requests in registry module
+- Runtime: Fix Graph ByParent() to generate list of child images per parent image.
+* Runtime: Add Image name to LogEvent tests
+* Documentation: Add sudo to examples and installation to documentation
++ Hack: Bash Completion: Limit commands to containers of a relevant state
+* Remote API: Add image name in /events
+* Runtime: Apply volumes-from before creating volumes
+- Runtime: Make docker run handle SIGINT/SIGTERM
+- Runtime: Prevent crash when .dockercfg not readable
+* Hack: Add docker dependencies coverage testing into docker-ci
++ Runtime: Add -privileged flag and relevant tests, docs, and examples
++ Packaging: Docker-brew 0.5.2 support and memory footprint reduction
+- Runtime: Install script should be fetched over https, not http.
+* Packaging: Add new docker dependencies into docker-ci
+* Runtime: Use Go 1.1.2 for dockerbuilder
+* Registry: Improve auth push
+* Runtime: API, issue 1471: Use groups for socket permissions
+* Documentation: PostgreSQL service example in documentation
+* Contrib: bash completion script
+* Tests: Improve TestKillDifferentUser to prevent timeout on buildbot
+* Documentation: Fix typo in docs for docker run -dns
+* Documentation: Adding a reference to ps -a
+- Runtime: Correctly detect IPv4 forwarding
+- Packaging: Revert "docker.upstart: avoid spawning a `sh` process"
+* Runtime: Use ranged for loop on channels
+- Runtime: Fix typo: fmt.Sprint -> fmt.Sprintf
+- Tests: Fix typo in TestBindMounts (runContainer called without image)
+* Runtime: add websocket support to /container/<name>/attach/ws
+* Runtime: Mount /dev/shm as a tmpfs
+- Builder: Only count known instructions as build steps
+- Builder: Fix docker build and docker events output
+- Runtime: switch from http to https for get.docker.io
+* Tests: Improve TestGetContainersTop so it does not rely on sleep
++ Packaging: Docker-brew and Docker standard library
+* Testing: Add some tests in server and utils
++ Packaging: Release docker with docker
+- Builder: Make sure ENV instruction within build perform a commit each time
+* Packaging: Fix the upstart script generated by get.docker.io
+- Runtime: fix small \n error un docker build
+* Runtime: Let userland proxy handle container-bound traffic
+* Runtime: Updated the Docker CLI to specify a value for the "Host" header.
+* Runtime: Add warning when net.ipv4.ip_forwarding = 0
+* Registry: Registry unit tests + mock registry
+* Runtime: fixed #910. print user name to docker info output
+- Builder: Forbid certain paths within docker build ADD
+- Runtime: change network range to avoid conflict with EC2 DNS
+* Tests: Relax the lo interface test to allow iface index != 1
+* Documentation: Suggest installing linux-headers by default.
+* Documentation: Change the twitter handle
+* Client: Add docker cp command and copy api endpoint to copy container files/folders to the host
+* Remote API: Use mime pkg to parse Content-Type
+- Runtime: Reduce connect and read timeout when pinging the registry
+* Documentation: Update amazon.rst to explain that Vagrant is not necessary for running Docker on ec2
+* Packaging: Enabled the docs to generate manpages.
+* Runtime: Parallel pull
+- Runtime: Handle ip route showing mask-less IP addresses
+* Documentation: Clarify Amazon EC2 installation
+* Documentation: 'Base' image is deprecated and should no longer be referenced in the docs.
+* Runtime: Fix to "Inject dockerinit at /.dockerinit"
+* Runtime: Allow ENTRYPOINT without CMD
+- Runtime: Always consider localhost as a domain name when parsing the FQN repos name
+* Remote API: 650 http utils and user agent field
+* Documentation: fix a typo in the ubuntu installation guide
+- Builder: Repository name (and optionally a tag) in build usage
+* Documentation: Move note about officially supported kernel
+* Packaging: Revert "Bind daemon to 0.0.0.0 in Vagrant.
+* Builder: Add no cache for docker build
+* Runtime: Add hostname to environment
+* Runtime: Add last stable version in `docker version`
+- Builder: Make sure ADD will create everything in 0755
+* Documentation: Add ufw doc
+* Tests: Add registry functional test to docker-ci
+- Documentation: Solved the logo being squished in Safari
+- Runtime: Use utils.ParseRepositoryTag instead of strings.Split(name, ":") in server.ImageDelete
+* Runtime: Refactor checksum
+- Runtime: Improve connect message with socket error
+* Documentation: Added information about Docker's high level tools over LXC.
+* Don't read from stdout when only attached to stdin
+
+## 0.5.3 (2013-08-13)
+* Runtime: Use docker group for socket permissions
+- Runtime: Spawn shell within upstart script
+- Builder: Make sure ENV instruction within build perform a commit each time
+- Runtime: Handle ip route showing mask-less IP addresses
+- Runtime: Add hostname to environment
+
+## 0.5.2 (2013-08-08)
+ * Builder: Forbid certain paths within docker build ADD
+ - Runtime: Change network range to avoid conflict with EC2 DNS
+ * API: Change daemon to listen on unix socket by default
+
 ## 0.5.1 (2013-07-30)
  + API: Docker client now sets useragent (RFC 2616)
  + Runtime: Add `ps` args to `docker top`

CONTRIBUTING.md

@@ -3,6 +3,10 @@
 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/).
+
 ## Contribution guidelines
 
 ### Pull requests are always welcome
@@ -23,7 +27,7 @@ that feature *on top of* docker.
 ### Discuss your design on the mailing list
 
 We recommend discussing your plans [on the mailing
-list](https://groups.google.com/forum/?fromgroups#!forum/docker-club)
+list](https://groups.google.com/forum/?fromgroups#!forum/docker-dev)
 before starting to code - especially for more ambitious contributions.
 This gives other contributors a chance to point you in the right
 direction, give feedback on your design, and maybe point out if someone
@@ -55,8 +59,10 @@ 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.
 
-Make sure you include relevant updates or additions to documentation when
-creating or modifying features.
+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.
 
 Write clean code. Universally formatted code promotes ease of writing, reading,
 and maintenance. Always run `go fmt` before committing your changes. Most
@@ -89,53 +95,17 @@ 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
 
-## Decision process
+Docker maintainers use LGTM (looks good to me) in comments on the code review
+to indicate acceptance.
 
-### How are decisions made?
+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
 
-Short answer: with pull requests to the docker repository.
-
-Docker is an open-source project with an open design philosophy. This means that the repository is the source of truth for EVERY aspect of the project,
-including its philosophy, design, roadmap and APIs. *If it's part of the project, it's in the repo. It's in the repo, it's part of the project.*
-
-As a result, all decisions can be expressed as changes to the repository. An implementation change is a change to the source code. An API change is a change to
-the API specification. A philosophy change is a change to the philosophy manifesto. And so on.
-
-All decisions affecting docker, big and small, follow the same 3 steps:
-
-* Step 1: Open a pull request. Anyone can do this.
-
-* Step 2: Discuss the pull request. Anyone can do this.
-
-* Step 3: Accept or refuse a pull request. The relevant maintainer does this (see below "Who decides what?")
-
-
-### Who decides what?
-
-So all decisions are pull requests, and the relevant maintainer makes the decision by accepting or refusing the pull request.
-But how do we identify the relevant maintainer for a given pull request?
-
-Docker follows the timeless, highly efficient and totally unfair system known as [Benevolent dictator for life](http://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life),
-with yours truly, Solomon Hykes, in the role of BDFL.
-This means that all decisions are made by default by me. Since making every decision myself would be highly unscalable, in practice decisions are spread across multiple maintainers.
-
-The relevant maintainer for a pull request is assigned in 3 steps:
-
-* Step 1: Determine the subdirectory affected by the pull request. This might be src/registry, docs/source/api, or any other part of the repo.
-
-* Step 2: Find the MAINTAINERS file which affects this directory. If the directory itself does not have a MAINTAINERS file, work your way up the the repo hierarchy until you find one.
-
-* Step 3: The first maintainer listed is the primary maintainer. The pull request is assigned to him. He may assign it to other listed maintainers, at his discretion.
-
-
-### I'm a maintainer, should I make pull requests too?
-
-Primary maintainers are not required to create pull requests when changing their own subdirectory, but secondary maintainers are.
-
-### Who assigns maintainers?
-
-Solomon.
+For more details see [MAINTAINERS.md](hack/MAINTAINERS.md)
 
 ### How can I become a maintainer?
 
@@ -146,15 +116,3 @@ Solomon.
 Don't forget: being a maintainer is a time investment. Make sure you will have time to make yourself available.
 You don't have to be a maintainer to make a difference on the project!
 
-### What are a maintainer's responsibility?
-
-It is every maintainer's responsibility to:
-
-* 1) Expose a clear roadmap for improving their component.
-* 2) Deliver prompt feedback and decisions on pull requests.
-* 3) Be available to anyone with questions, bug reports, criticism etc. on their component. This includes irc, github requests and the mailing list.
-* 4) Make sure their component respects the philosophy, design and roadmap of the project.
-
-### How is this process changed?
-
-Just like everything else: by making a pull request :)

Dockerfile

@@ -1,30 +1,69 @@
 # This file describes the standard way to build Docker, using docker
-docker-version 0.4.2
+#
+# Usage:
+#
+# # 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 -lxc-conf=lxc.aa_profile=unconfined -i -t docker bash
+#
+#
+# # Run the test suite:
+# docker run -privileged -lxc-conf=lxc.aa_profile=unconfined docker hack/make.sh test
+#
+# # Publish a release:
+# 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
+#
+
+docker-version 0.6.1
 from	ubuntu:12.04
 maintainer	Solomon Hykes <solomon@dotcloud.com>
+
 # Build dependencies
-run	apt-get install -y -q curl
-run	apt-get install -y -q git
-# Install Go
-run	curl -s https://go.googlecode.com/files/go1.1.1.linux-amd64.tar.gz | tar -v -C /usr/local -xz
-env	PATH	/usr/local/go/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
-env	GOPATH	/go
-env	CGO_ENABLED 0
-run	cd /tmp && echo 'package main' > t.go && go test -a -i -v
-# Download dependencies
-run	PKG=github.com/kr/pty REV=27435c699;		 git clone http://$PKG /go/src/$PKG && cd /go/src/$PKG && git checkout -f $REV
-run	PKG=github.com/gorilla/context/ REV=708054d61e5; git clone http://$PKG /go/src/$PKG && cd /go/src/$PKG && git checkout -f $REV
-run	PKG=github.com/gorilla/mux/ REV=9b36453141c;	 git clone http://$PKG /go/src/$PKG && cd /go/src/$PKG && git checkout -f $REV
-# Run dependencies
-run	apt-get install -y iptables
-# lxc requires updating ubuntu sources
 run	echo 'deb http://archive.ubuntu.com/ubuntu precise main universe' > /etc/apt/sources.list
 run	apt-get update
-run	apt-get install -y lxc
-run	apt-get install -y aufs-tools
+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
+
+# Install Go from source (for eventual cross-compiling)
+env	CGO_ENABLED 0
+run	curl -s https://go.googlecode.com/files/go1.1.2.src.tar.gz | tar -v -C / -xz && mv /go /goroot
+run	cd /goroot/src && ./make.bash
+env GOROOT	/goroot
+env	PATH	$PATH:/goroot/bin
+env	GOPATH	/go:/go/src/github.com/dotcloud/docker/vendor
+
+# 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
+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
+
+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"]
+
 # Upload docker source
 add	.       /go/src/github.com/dotcloud/docker
-# Build the binary
-run	cd /go/src/github.com/dotcloud/docker/docker && go install -ldflags "-X main.GITCOMMIT '??' -d -w"
-env	PATH	/usr/local/go/bin:/go/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
-cmd	["docker"]

FIXME

@@ -15,22 +15,16 @@ 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
+* Save metadata with import/export (#1974)
 * Upgrade dockerd without stopping containers
-* bring back git revision info, looks like it was lost
-* Simple command to remove all untagged images
+* Simple command to remove all untagged images (`docker rmi $(docker images | awk '/^<none>/ { print $3 }')`)
 * Simple command to clean up containers for disk space
-* Caching after an ADD
-* entry point config
-* bring back git revision info, looks like it was lost
+* Caching after an ADD (#880)
 * Clean up the ProgressReader api, it's a PITA to use
+* Use netlink instead of iproute2/iptables (#925)

MAINTAINERS

@@ -1,5 +1,6 @@
-Solomon Hykes <solomon@dotcloud.com>
-Guillaume Charmes <guillaume@dotcloud.com>
-Victor Vieux <victor@dotcloud.com>
-api.go: Victor Vieux <victor@dotcloud.com>
-Vagrantfile: Daniel Mizyrycki <daniel@dotcloud.com>
+Solomon Hykes <solomon@dotcloud.com> (@shykes)
+Guillaume Charmes <guillaume@dotcloud.com> (@creack)
+Victor Vieux <victor@dotcloud.com> (@vieux)
+Michael Crosby <michael@crosbymichael.com> (@crosbymichael)
+api.go: Victor Vieux <victor@dotcloud.com> (@vieux)
+Vagrantfile: Daniel Mizyrycki <daniel@dotcloud.com> (@mzdaniel)

Makefile

@@ -1,95 +0,0 @@
-DOCKER_PACKAGE := github.com/dotcloud/docker
-RELEASE_VERSION := $(shell git tag | grep -E "v[0-9\.]+$$" | sort -nr | head -n 1)
-SRCRELEASE := docker-$(RELEASE_VERSION)
-BINRELEASE := docker-$(RELEASE_VERSION).tgz
-BUILD_SRC := build_src
-BUILD_PATH := ${BUILD_SRC}/src/${DOCKER_PACKAGE}
-
-GIT_ROOT := $(shell git rev-parse --show-toplevel)
-BUILD_DIR := $(CURDIR)/.gopath
-
-GOPATH ?= $(BUILD_DIR)
-export GOPATH
-
-GO_OPTIONS ?= -a -ldflags='-w -d'
-ifeq ($(VERBOSE), 1)
-GO_OPTIONS += -v
-endif
-
-GIT_COMMIT = $(shell git rev-parse --short HEAD)
-GIT_STATUS = $(shell test -n "`git status --porcelain`" && echo "+CHANGES")
-
-BUILD_OPTIONS = -a -ldflags "-X main.GITCOMMIT $(GIT_COMMIT)$(GIT_STATUS) -d -w"
-
-SRC_DIR := $(GOPATH)/src
-
-DOCKER_DIR := $(SRC_DIR)/$(DOCKER_PACKAGE)
-DOCKER_MAIN := $(DOCKER_DIR)/docker
-
-DOCKER_BIN_RELATIVE := bin/docker
-DOCKER_BIN := $(CURDIR)/$(DOCKER_BIN_RELATIVE)
-
-.PHONY: all clean test hack release srcrelease $(BINRELEASE) $(SRCRELEASE) $(DOCKER_BIN) $(DOCKER_DIR)
-
-all: $(DOCKER_BIN)
-
-$(DOCKER_BIN): $(DOCKER_DIR)
-	@mkdir -p  $(dir $@)
-	@(cd $(DOCKER_MAIN); CGO_ENABLED=0 go build $(GO_OPTIONS) $(BUILD_OPTIONS) -o $@)
-	@echo $(DOCKER_BIN_RELATIVE) is created.
-
-$(DOCKER_DIR):
-	@mkdir -p $(dir $@)
-	@if [ -h $@ ]; then rm -f $@; fi; ln -sf $(CURDIR)/ $@
-	@(cd $(DOCKER_MAIN); go get -d $(GO_OPTIONS))
-
-whichrelease:
-	echo $(RELEASE_VERSION)
-
-release: $(BINRELEASE)
-	s3cmd -P put $(BINRELEASE) s3://get.docker.io/builds/`uname -s`/`uname -m`/docker-$(RELEASE_VERSION).tgz
-	s3cmd -P put docker-latest.tgz s3://get.docker.io/builds/`uname -s`/`uname -m`/docker-latest.tgz
-	s3cmd -P put $(SRCRELEASE)/bin/docker s3://get.docker.io/builds/`uname -s`/`uname -m`/docker
-
-srcrelease: $(SRCRELEASE)
-deps: $(DOCKER_DIR)
-
-# A clean checkout of $RELEASE_VERSION, with vendored dependencies
-$(SRCRELEASE):
-	rm -fr $(SRCRELEASE)
-	git clone $(GIT_ROOT) $(SRCRELEASE)
-	cd $(SRCRELEASE); git checkout -q $(RELEASE_VERSION)
-
-# A binary release ready to be uploaded to a mirror
-$(BINRELEASE): $(SRCRELEASE)
-	rm -f $(BINRELEASE)
-	cd $(SRCRELEASE); make; cp -R bin docker-$(RELEASE_VERSION); tar -f ../$(BINRELEASE) -zv -c docker-$(RELEASE_VERSION)
-	cd $(SRCRELEASE); cp -R bin docker-latest; tar -f ../docker-latest.tgz -zv -c docker-latest
-
-clean:
-	@rm -rf $(dir $(DOCKER_BIN))
-ifeq ($(GOPATH), $(BUILD_DIR))
-	@rm -rf $(BUILD_DIR)
-else ifneq ($(DOCKER_DIR), $(realpath $(DOCKER_DIR)))
-	@rm -f $(DOCKER_DIR)
-endif
-
-test:
-	# Copy docker source and dependencies for testing
-	rm -rf ${BUILD_SRC}; mkdir -p ${BUILD_PATH}
-	tar --exclude=${BUILD_SRC} -cz . | tar -xz -C ${BUILD_PATH}
-	GOPATH=${CURDIR}/${BUILD_SRC} go get -d
-	# Do the test
-	sudo -E GOPATH=${CURDIR}/${BUILD_SRC} CGO_ENABLED=0 go test ${GO_OPTIONS}
-
-testall: all
-	@(cd $(DOCKER_DIR); CGO_ENABLED=0 sudo -E go test ./... $(GO_OPTIONS))
-
-fmt:
-	@gofmt -s -l -w .
-
-hack:
-	cd $(CURDIR)/hack && vagrant up
-
-ssh-dev:
-	cd $(CURDIR)/hack && vagrant ssh

NOTICE

@@ -1,11 +1,43 @@
 Docker
 Copyright 2012-2013 dotCloud, inc.
 
-This product includes software developed at dotCloud, inc. (http://www.dotcloud.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.
+This product contains software (https://github.com/kr/pty) developed
+by Keith Rarick, licensed under the MIT License.
 
-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.
+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.
+
+What does that mean? 
+Here is a further explanation from our legal counsel:
+
+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.
+
+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.

README.md

@@ -1,8 +1,8 @@
 Docker: the Linux container engine
 ==================================
 
-Docker is an open-source engine which automates the deployment of
-applications as highly portable, self-sufficient containers.
+Docker is an open source project to pack, ship and run any application
+as a lightweight container
 
 Docker containers are both *hardware-agnostic* and
 *platform-agnostic*. This means that they can run anywhere, from your
@@ -18,7 +18,7 @@ Platform-as-a-Service.  It benefits directly from the experience
 accumulated over several years of large-scale operation and support of
 hundreds of thousands of applications and databases.
 
-![Docker L](docs/sources/concepts/images/dockerlogo-h.png "Docker")
+![Docker L](docs/theme/docker/static/img/dockerlogo-h.png "Docker")
 
 ## Better than VMs
 
@@ -140,144 +140,25 @@ Note that Docker doesn't care *how* dependencies are built - as long
 as they can be built by running a Unix command in a container.
 
 
-Install instructions
-==================
+Getting started
+===============
 
-Quick install on Ubuntu 12.04 and 12.10
----------------------------------------
+Docker can be installed on your local machine as well as servers - both bare metal and virtualized.
+It is available as a binary on most modern Linux systems, or as a VM on Windows, Mac and other systems.
 
-```bash
-curl get.docker.io | sudo sh -x
-```
+We also offer an interactive tutorial for quickly learning the basics of using Docker.
 
-Binary installs
-----------------
 
-Docker supports the following binary installation methods.  Note that
-some methods are community contributions and not yet officially
-supported.
+For up-to-date install instructions and online tutorials, see the [Getting Started page](http://www.docker.io/gettingstarted/).
 
-* [Ubuntu 12.04 and 12.10 (officially supported)](http://docs.docker.io/en/latest/installation/ubuntulinux/)
-* [Arch Linux](http://docs.docker.io/en/latest/installation/archlinux/)
-* [Mac OS X (with Vagrant)](http://docs.docker.io/en/latest/installation/vagrant/)
-* [Windows (with Vagrant)](http://docs.docker.io/en/latest/installation/windows/)
-* [Amazon EC2 (with Vagrant)](http://docs.docker.io/en/latest/installation/amazon/)
-
-Installing from source
-----------------------
-
-1. Make sure you have a [Go language](http://golang.org/doc/install)
-compiler >= 1.1 and [git](http://git-scm.com) installed.
-2. Checkout the source code
-
-   ```bash
-   git clone http://github.com/dotcloud/docker
-   ```
-
-3. Build the ``docker`` binary
-
-   ```bash
-   cd docker
-   make VERBOSE=1
-   sudo cp ./bin/docker /usr/local/bin/docker
-   ```
 
 Usage examples
 ==============
 
-First run the ``docker`` daemon
--------------------------------
+Docker can be used to run short-lived commands, long-running daemons (app servers, databases etc.),
+interactive shell sessions, etc.
 
-All the examples assume your machine is running the ``docker``
-daemon. To run the ``docker`` daemon in the background, simply type:
-
-```bash
-# On a production system you want this running in an init script
-sudo docker -d &
-```
-
-Now you can run ``docker`` in client mode: all commands will be
-forwarded to the ``docker`` daemon, so the client can run from any
-account.
-
-```bash
-# Now you can run docker commands from any account.
-docker help
-```
-
-
-Throwaway shell in a base Ubuntu image
---------------------------------------
-
-```bash
-docker pull ubuntu:12.10
-
-# Run an interactive shell, allocate a tty, attach stdin and stdout
-# To detach the tty without exiting the shell, use the escape sequence Ctrl-p + Ctrl-q
-docker run -i -t ubuntu:12.10 /bin/bash
-```
-
-Starting a long-running worker process
---------------------------------------
-
-```bash
-# Start a very useful long-running process
-JOB=$(docker run -d ubuntu /bin/sh -c "while true; do echo Hello world; sleep 1; done")
-
-# Collect the output of the job so far
-docker logs $JOB
-
-# Kill the job
-docker kill $JOB
-```
-
-Running an irc bouncer
-----------------------
-
-```bash
-BOUNCER_ID=$(docker run -d -p 6667 -u irc shykes/znc zncrun $USER $PASSWORD)
-echo "Configure your irc client to connect to port $(docker port $BOUNCER_ID 6667) of this machine"
-```
-
-Running Redis
--------------
-
-```bash
-REDIS_ID=$(docker run -d -p 6379 shykes/redis redis-server)
-echo "Configure your redis client to connect to port $(docker port $REDIS_ID 6379) of this machine"
-```
-
-Share your own image!
----------------------
-
-```bash
-CONTAINER=$(docker run -d ubuntu:12.10 apt-get install -y curl)
-docker commit -m "Installed curl" $CONTAINER $USER/betterbase
-docker push $USER/betterbase
-```
-
-A list of publicly available images is [available
-here](https://github.com/dotcloud/docker/wiki/Public-docker-images).
-
-Expose a service on a TCP port
-------------------------------
-
-```bash
-# Expose port 4444 of this container, and tell netcat to listen on it
-JOB=$(docker run -d -p 4444 base /bin/nc -l -p 4444)
-
-# Which public port is NATed to my container?
-PORT=$(docker port $JOB 4444)
-
-# Connect to the public port via the host's public address
-# Please note that because of how routing works connecting to localhost or 127.0.0.1 $PORT will not work.
-# Replace *eth0* according to your local interface name.
-IP=$(ip -o -4 addr list eth0 | perl -n -e 'if (m{inet\s([\d\.]+)\/\d+\s}xms) { print $1 }')
-echo hello world | nc $IP $PORT
-
-# Verify that the network connection worked
-echo "Daemon received: $(docker logs $JOB)"
-```
+You can find a [list of real-world examples](http://docs.docker.io/en/latest/examples/) in the documentation.
 
 Under the hood
 --------------
@@ -301,151 +182,17 @@ Contributing to Docker
 ======================
 
 Want to hack on Docker? Awesome! There are instructions to get you
-started on the website:
-http://docs.docker.io/en/latest/contributing/contributing/
+started [here](CONTRIBUTING.md).
 
 They are probably not perfect, please let us know if anything feels
 wrong or incomplete.
 
 
-Note
-----
-
-We also keep the documentation in this repository. The website
-documentation is generated using Sphinx using these sources.  Please
-find it under docs/sources/ and read more about it
-https://github.com/dotcloud/docker/tree/master/docs/README.md
-
-Please feel free to fix / update the documentation and send us pull
-requests. More tutorials are also welcome.
-
-
-Setting up a dev environment
-----------------------------
-
-Instructions that have been verified to work on Ubuntu 12.10,
-
-```bash
-sudo apt-get -y install lxc curl xz-utils golang git
-
-export GOPATH=~/go/
-export PATH=$GOPATH/bin:$PATH
-
-mkdir -p $GOPATH/src/github.com/dotcloud
-cd $GOPATH/src/github.com/dotcloud
-git clone https://github.com/dotcloud/docker.git
-cd docker
-
-go get -v github.com/dotcloud/docker/...
-go install -v github.com/dotcloud/docker/...
-```
-
-Then run the docker daemon,
-
-```bash
-sudo $GOPATH/bin/docker -d
-```
-
-Run the `go install` command (above) to recompile docker.
-
-
-What is a Standard Container?
-=============================
-
-Docker defines a unit of software delivery called a Standard
-Container. The goal of a Standard Container is to encapsulate a
-software component and all its dependencies in a format that is
-self-describing and portable, so that any compliant runtime can run it
-without extra dependencies, regardless of the underlying machine and
-the contents of the container.
-
-The spec for Standard Containers is currently a work in progress, but
-it is very straightforward. It mostly defines 1) an image format, 2) a
-set of standard operations, and 3) an execution environment.
-
-A great analogy for this is the shipping container. Just like how
-Standard Containers are a fundamental unit of software delivery,
-shipping containers are a fundamental unit of physical delivery.
-
-### 1. STANDARD OPERATIONS
-
-Just like shipping containers, Standard Containers define a set of
-STANDARD OPERATIONS. Shipping containers can be lifted, stacked,
-locked, loaded, unloaded and labelled. Similarly, Standard Containers
-can be started, stopped, copied, snapshotted, downloaded, uploaded and
-tagged.
-
-
-### 2. CONTENT-AGNOSTIC
-
-Just like shipping containers, Standard Containers are
-CONTENT-AGNOSTIC: all standard operations have the same effect
-regardless of the contents. A shipping container will be stacked in
-exactly the same way whether it contains Vietnamese powder coffee or
-spare Maserati parts. Similarly, Standard Containers are started or
-uploaded in the same way whether they contain a postgres database, a
-php application with its dependencies and application server, or Java
-build artifacts.
-
-
-### 3. INFRASTRUCTURE-AGNOSTIC
-
-Both types of containers are INFRASTRUCTURE-AGNOSTIC: they can be
-transported to thousands of facilities around the world, and
-manipulated by a wide variety of equipment. A shipping container can
-be packed in a factory in Ukraine, transported by truck to the nearest
-routing center, stacked onto a train, loaded into a German boat by an
-Australian-built crane, stored in a warehouse at a US facility,
-etc. Similarly, a standard container can be bundled on my laptop,
-uploaded to S3, downloaded, run and snapshotted by a build server at
-Equinix in Virginia, uploaded to 10 staging servers in a home-made
-Openstack cluster, then sent to 30 production instances across 3 EC2
-regions.
-
-
-### 4. DESIGNED FOR AUTOMATION
-
-Because they offer the same standard operations regardless of content
-and infrastructure, Standard Containers, just like their physical
-counterparts, are extremely well-suited for automation. In fact, you
-could say automation is their secret weapon.
-
-Many things that once required time-consuming and error-prone human
-effort can now be programmed. Before shipping containers, a bag of
-powder coffee was hauled, dragged, dropped, rolled and stacked by 10
-different people in 10 different locations by the time it reached its
-destination. 1 out of 50 disappeared. 1 out of 20 was damaged. The
-process was slow, inefficient and cost a fortune - and was entirely
-different depending on the facility and the type of goods.
-
-Similarly, before Standard Containers, by the time a software
-component ran in production, it had been individually built,
-configured, bundled, documented, patched, vendored, templated, tweaked
-and instrumented by 10 different people on 10 different
-computers. Builds failed, libraries conflicted, mirrors crashed,
-post-it notes were lost, logs were misplaced, cluster updates were
-half-broken. The process was slow, inefficient and cost a fortune -
-and was entirely different depending on the language and
-infrastructure provider.
-
-
-### 5. INDUSTRIAL-GRADE DELIVERY
-
-There are 17 million shipping containers in existence, packed with
-every physical good imaginable. Every single one of them can be loaded
-onto the same boats, by the same cranes, in the same facilities, and
-sent anywhere in the World with incredible efficiency. It is
-embarrassing to think that a 30 ton shipment of coffee can safely
-travel half-way across the World in *less time* than it takes a
-software team to deliver its code from one datacenter to another
-sitting 10 miles away.
-
-With Standard Containers we can put an end to that embarrassment, by
-making INDUSTRIAL-GRADE DELIVERY of software a reality.
-
-
 ### Legal
 
+*Brought to you courtesy of our legal counsel. For more context,
+please see the Notice document.*
+
 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,

VERSION

@@ -0,0 +1 @@
+0.6.4

Vagrantfile

@@ -12,24 +12,22 @@ 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
-  config.vm.forward_port 4243, 4243
 
-  # Provision docker and new kernel if deployment was not done
+  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 = "apt-get update -qq; apt-get install -q -y python-software-properties; " \
-      "add-apt-repository -y ppa:dotcloud/lxc-docker; apt-get update -qq; " \
-      "apt-get install -q -y lxc-docker; "
-    # Listen on all interfaces so that the daemon is accessible from the host
-    pkg_cmd << "sed -i -E 's|    /usr/bin/docker -d|    /usr/bin/docker -d -H 0.0.0.0|' /etc/init/docker.conf;"
-    # Add X.org Ubuntu backported 3.8 kernel
-    pkg_cmd << "add-apt-repository -y ppa:ubuntu-x-swat/r-lts-backport; " \
-      "apt-get update -qq; apt-get install -q -y linux-image-3.8.0-19-generic; "
-    # Add guest additions if local vbox VM
-    is_vbox = true
-    ARGV.each do |arg| is_vbox &&= !arg.downcase.start_with?("--provider") end
-    if is_vbox
-      pkg_cmd << "apt-get install -q -y linux-headers-3.8.0-19-generic dkms; " \
+    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
@@ -41,6 +39,8 @@ Vagrant::Config.run do |config|
         "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
+    # Add vagrant user to the docker group
+    pkg_cmd << "usermod -a -G docker vagrant; "
     # Activate new kernel
     pkg_cmd << "shutdown -r +1; "
     config.vm.provision :shell, :inline => pkg_cmd
@@ -80,19 +80,21 @@ Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
   config.vm.provider :virtualbox do |vb|
     config.vm.box = BOX_NAME
     config.vm.box_url = BOX_URI
+    vb.customize ["modifyvm", :id, "--natdnshostresolver1", "on"]
+    vb.customize ["modifyvm", :id, "--natdnsproxy1", "on"]
   end
 end
 
 if !FORWARD_DOCKER_PORTS.nil?
-    Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|
-        (49000..49900).each do |port|
-            config.vm.forward_port port, port
-        end
+  Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|
+    (49000..49900).each do |port|
+      config.vm.forward_port port, port
     end
+  end
 
-    Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
-        (49000..49900).each do |port|
-            config.vm.network :forwarded_port, :host => port, :guest => port
-        end
+  Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
+    (49000..49900).each do |port|
+      config.vm.network :forwarded_port, :host => port, :guest => port
     end
+  end
 end

api.go

@@ -1,6 +1,8 @@
 package docker
 
 import (
+	"code.google.com/p/go.net/websocket"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"github.com/dotcloud/docker/auth"
@@ -9,17 +11,24 @@ import (
 	"io"
 	"io/ioutil"
 	"log"
+	"mime"
 	"net"
 	"net/http"
 	"os"
 	"os/exec"
+	"regexp"
 	"strconv"
 	"strings"
 )
 
-const APIVERSION = 1.4
-const DEFAULTHTTPHOST string = "127.0.0.1"
-const DEFAULTHTTPPORT int = 4243
+const (
+	APIVERSION        = 1.6
+	DEFAULTHTTPHOST   = "127.0.0.1"
+	DEFAULTHTTPPORT   = 4243
+	DEFAULTUNIXSOCKET = "/var/run/docker.sock"
+)
+
+type HttpApiFunc func(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error
 
 func hijackServer(w http.ResponseWriter) (io.ReadCloser, io.Writer, error) {
 	conn, _, err := w.(http.Hijacker).Hijack()
@@ -60,14 +69,26 @@ func httpError(w http.ResponseWriter, err error) {
 		statusCode = http.StatusUnauthorized
 	} else if strings.Contains(err.Error(), "hasn't been activated") {
 		statusCode = http.StatusForbidden
-	}
-	utils.Debugf("[error %d] %s", statusCode, err)
-	http.Error(w, err.Error(), statusCode)
+	}	
+	
+	if err != nil {
+		utils.Errorf("HTTP Error: statusCode=%d %s", statusCode, err.Error())
+		http.Error(w, err.Error(), statusCode)		
+	}	
 }
 
-func writeJSON(w http.ResponseWriter, b []byte) {
+func writeJSON(w http.ResponseWriter, code int, v interface{}) error {
+	b, err := json.Marshal(v)
+
+	if err != nil {
+		return err
+	}
+
 	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(code)
 	w.Write(b)
+
+	return nil
 }
 
 func getBoolParam(value string) (bool, error) {
@@ -81,36 +102,33 @@ func getBoolParam(value string) (bool, error) {
 	return ret, nil
 }
 
+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())
+	}
+	return err == nil && mimetype == expectedType
+}
+
 func postAuth(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
 	authConfig := &auth.AuthConfig{}
 	err := json.NewDecoder(r.Body).Decode(authConfig)
 	if err != nil {
 		return err
 	}
-	status, err := auth.Login(authConfig)
+	status, err := auth.Login(authConfig, srv.HTTPRequestFactory(nil))
 	if err != nil {
 		return err
 	}
 	if status != "" {
-		b, err := json.Marshal(&APIAuth{Status: status})
-		if err != nil {
-			return err
-		}
-		writeJSON(w, b)
-		return nil
+		return writeJSON(w, http.StatusOK, &APIAuth{Status: status})
 	}
 	w.WriteHeader(http.StatusNoContent)
 	return nil
 }
 
 func getVersion(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	m := srv.DockerVersion()
-	b, err := json.Marshal(m)
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	return nil
+	return writeJSON(w, http.StatusOK, srv.DockerVersion())
 }
 
 func postContainersKill(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -132,7 +150,7 @@ func getContainersExport(srv *Server, version float64, w http.ResponseWriter, r
 	name := vars["name"]
 
 	if err := srv.ContainerExport(name, w); err != nil {
-		utils.Debugf("%s", err)
+		utils.Errorf("%s", err)
 		return err
 	}
 	return nil
@@ -153,12 +171,8 @@ func getImagesJSON(srv *Server, version float64, w http.ResponseWriter, r *http.
 	if err != nil {
 		return err
 	}
-	b, err := json.Marshal(outs)
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	return nil
+
+	return writeJSON(w, http.StatusOK, outs)
 }
 
 func getImagesViz(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -169,13 +183,7 @@ func getImagesViz(srv *Server, version float64, w http.ResponseWriter, r *http.R
 }
 
 func getInfo(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	out := srv.DockerInfo()
-	b, err := json.Marshal(out)
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	return nil
+	return writeJSON(w, http.StatusOK, srv.DockerInfo())
 }
 
 func getEvents(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -187,7 +195,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.Debugf("%s", err)
+			utils.Errorf("%s", err)
 			srv.Lock()
 			delete(srv.listeners, r.RemoteAddr)
 			srv.Unlock()
@@ -223,8 +231,7 @@ func getEvents(srv *Server, version float64, w http.ResponseWriter, r *http.Requ
 			}
 		}
 	}
-	for {
-		event := <-listener
+	for event := range listener {
 		err := sendEvent(wf, &event)
 		if err != nil && err.Error() == "JSON error" {
 			continue
@@ -245,12 +252,8 @@ func getImagesHistory(srv *Server, version float64, w http.ResponseWriter, r *ht
 	if err != nil {
 		return err
 	}
-	b, err := json.Marshal(outs)
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	return nil
+
+	return writeJSON(w, http.StatusOK, outs)
 }
 
 func getContainersChanges(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -262,12 +265,8 @@ func getContainersChanges(srv *Server, version float64, w http.ResponseWriter, r
 	if err != nil {
 		return err
 	}
-	b, err := json.Marshal(changesStr)
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	return nil
+
+	return writeJSON(w, http.StatusOK, changesStr)
 }
 
 func getContainersTop(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -286,12 +285,8 @@ func getContainersTop(srv *Server, version float64, w http.ResponseWriter, r *ht
 	if err != nil {
 		return err
 	}
-	b, err := json.Marshal(procsStr)
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	return nil
+
+	return writeJSON(w, http.StatusOK, procsStr)
 }
 
 func getContainersJSON(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -314,12 +309,17 @@ func getContainersJSON(srv *Server, version float64, w http.ResponseWriter, r *h
 	}
 
 	outs := srv.Containers(all, size, n, since, before)
-	b, err := json.Marshal(outs)
-	if err != nil {
-		return err
+
+	if version < 1.5 {
+		outs2 := []APIContainersOld{}
+		for _, ctnr := range outs {
+			outs2 = append(outs2, ctnr.ToLegacy())
+		}
+
+		return writeJSON(w, http.StatusOK, outs2)
+	} else {
+		return writeJSON(w, http.StatusOK, outs)
 	}
-	writeJSON(w, b)
-	return nil
 }
 
 func postImagesTag(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -349,8 +349,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 {
-		utils.Debugf("%s", err)
+	if err := json.NewDecoder(r.Body).Decode(config); err != nil && err != io.EOF {
+		utils.Errorf("%s", err)
 	}
 	repo := r.Form.Get("repo")
 	tag := r.Form.Get("tag")
@@ -361,13 +361,8 @@ func postCommit(srv *Server, version float64, w http.ResponseWriter, r *http.Req
 	if err != nil {
 		return err
 	}
-	b, err := json.Marshal(&APIID{id})
-	if err != nil {
-		return err
-	}
-	w.WriteHeader(http.StatusCreated)
-	writeJSON(w, b)
-	return nil
+
+	return writeJSON(w, http.StatusCreated, &APIID{id})
 }
 
 // Creates an image from Pull or from Import
@@ -381,12 +376,28 @@ func postImagesCreate(srv *Server, version float64, w http.ResponseWriter, r *ht
 	tag := r.Form.Get("tag")
 	repo := r.Form.Get("repo")
 
+	authEncoded := r.Header.Get("X-Registry-Auth")
+	authConfig := &auth.AuthConfig{}
+	if authEncoded != "" {
+		authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
+		if err := json.NewDecoder(authJson).Decode(authConfig); err != nil {
+			// for a pull it is not an error if no auth was given
+			// to increase compatibility with the existing api it is defaulting to be empty
+			authConfig = &auth.AuthConfig{}
+		}
+	}
 	if version > 1.0 {
 		w.Header().Set("Content-Type", "application/json")
 	}
 	sf := utils.NewStreamFormatter(version > 1.0)
 	if image != "" { //pull
-		if err := srv.ImagePull(image, tag, w, sf, &auth.AuthConfig{}); err != nil {
+		metaHeaders := map[string][]string{}
+		for k, v := range r.Header {
+			if strings.HasPrefix(k, "X-Meta-") {
+				metaHeaders[k] = v
+			}
+		}
+		if err := srv.ImagePull(image, tag, w, sf, authConfig, metaHeaders, version > 1.3); err != nil {
 			if sf.Used() {
 				w.Write(sf.FormatError(err))
 				return nil
@@ -415,12 +426,8 @@ func getImagesSearch(srv *Server, version float64, w http.ResponseWriter, r *htt
 	if err != nil {
 		return err
 	}
-	b, err := json.Marshal(outs)
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	return nil
+
+	return writeJSON(w, http.StatusOK, outs)
 }
 
 func postImagesInsert(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -445,22 +452,37 @@ func postImagesInsert(srv *Server, version float64, w http.ResponseWriter, r *ht
 			return nil
 		}
 	}
-	b, err := json.Marshal(&APIID{ID: imgID})
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	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 {
-	authConfig := &auth.AuthConfig{}
-	if err := json.NewDecoder(r.Body).Decode(authConfig); err != nil {
-		return err
+	metaHeaders := map[string][]string{}
+	for k, v := range r.Header {
+		if strings.HasPrefix(k, "X-Meta-") {
+			metaHeaders[k] = v
+		}
 	}
 	if err := parseForm(r); err != nil {
 		return err
 	}
+	authConfig := &auth.AuthConfig{}
+
+	authEncoded := r.Header.Get("X-Registry-Auth")
+	if authEncoded != "" {
+		// the new format is to handle the authConfig as a header
+		authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
+		if err := json.NewDecoder(authJson).Decode(authConfig); err != nil {
+			// to increase compatibility to existing api it is defaulting to be empty
+			authConfig = &auth.AuthConfig{}
+		}
+	} else {
+		// the old format is supported for compatibility if there was no authConfig header
+		if err := json.NewDecoder(r.Body).Decode(authConfig); err != nil {
+			return err
+		}
+
+	}
 
 	if vars == nil {
 		return fmt.Errorf("Missing parameter")
@@ -470,7 +492,7 @@ func postImagesPush(srv *Server, version float64, w http.ResponseWriter, r *http
 		w.Header().Set("Content-Type", "application/json")
 	}
 	sf := utils.NewStreamFormatter(version > 1.0)
-	if err := srv.ImagePush(name, w, sf, authConfig); err != nil {
+	if err := srv.ImagePush(name, w, sf, authConfig, metaHeaders); err != nil {
 		if sf.Used() {
 			w.Write(sf.FormatError(err))
 			return nil
@@ -488,7 +510,12 @@ func postContainersCreate(srv *Server, version float64, w http.ResponseWriter, r
 		return err
 	}
 
-	if len(config.Dns) == 0 && len(srv.runtime.Dns) == 0 && utils.CheckLocalDns() {
+	resolvConf, err := utils.GetResolvConf()
+	if err != nil {
+		return err
+	}
+
+	if !config.NetworkDisabled && len(config.Dns) == 0 && len(srv.runtime.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))
 		config.Dns = defaultDns
 	}
@@ -508,13 +535,12 @@ func postContainersCreate(srv *Server, version float64, w http.ResponseWriter, r
 		out.Warnings = append(out.Warnings, "Your kernel does not support memory swap capabilities. Limitation discarded.")
 	}
 
-	b, err := json.Marshal(out)
-	if err != nil {
-		return err
+	if !config.NetworkDisabled && srv.runtime.capabilities.IPv4ForwardingDisabled {
+		log.Println("Warning: IPv4 forwarding is disabled.")
+		out.Warnings = append(out.Warnings, "IPv4 forwarding is disabled.")
 	}
-	w.WriteHeader(http.StatusCreated)
-	writeJSON(w, b)
-	return nil
+
+	return writeJSON(w, http.StatusCreated, out)
 }
 
 func postContainersRestart(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -570,11 +596,7 @@ func deleteImages(srv *Server, version float64, w http.ResponseWriter, r *http.R
 	}
 	if imgs != nil {
 		if len(imgs) != 0 {
-			b, err := json.Marshal(imgs)
-			if err != nil {
-				return err
-			}
-			writeJSON(w, b)
+			return writeJSON(w, http.StatusOK, imgs)
 		} else {
 			return fmt.Errorf("Conflict, %s wasn't deleted", name)
 		}
@@ -585,11 +607,11 @@ func deleteImages(srv *Server, version float64, w http.ResponseWriter, r *http.R
 }
 
 func postContainersStart(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	hostConfig := &HostConfig{}
-
+	var hostConfig *HostConfig
 	// allow a nil body for backwards compatibility
 	if r.Body != nil {
-		if r.Header.Get("Content-Type") == "application/json" {
+		if matchesContentType(r.Header.Get("Content-Type"), "application/json") {
+			hostConfig = &HostConfig{}
 			if err := json.NewDecoder(r.Body).Decode(hostConfig); err != nil {
 				return err
 			}
@@ -637,12 +659,8 @@ func postContainersWait(srv *Server, version float64, w http.ResponseWriter, r *
 	if err != nil {
 		return err
 	}
-	b, err := json.Marshal(&APIWait{StatusCode: status})
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	return nil
+
+	return writeJSON(w, http.StatusOK, &APIWait{StatusCode: status})
 }
 
 func postContainersResize(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -697,33 +715,91 @@ func postContainersAttach(srv *Server, version float64, w http.ResponseWriter, r
 	}
 	name := vars["name"]
 
-	if _, err := srv.ContainerInspect(name); err != nil {
+	c, err := srv.ContainerInspect(name)
+	if err != nil {
 		return err
 	}
 
-	in, out, err := hijackServer(w)
+	inStream, outStream, err := hijackServer(w)
 	if err != nil {
 		return err
 	}
 	defer func() {
-		if tcpc, ok := in.(*net.TCPConn); ok {
+		if tcpc, ok := inStream.(*net.TCPConn); ok {
 			tcpc.CloseWrite()
 		} else {
-			in.Close()
+			inStream.Close()
 		}
 	}()
 	defer func() {
-		if tcpc, ok := out.(*net.TCPConn); ok {
+		if tcpc, ok := outStream.(*net.TCPConn); ok {
 			tcpc.CloseWrite()
-		} else if closer, ok := out.(io.Closer); ok {
+		} else if closer, ok := outStream.(io.Closer); ok {
 			closer.Close()
 		}
 	}()
 
-	fmt.Fprintf(out, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n")
-	if err := srv.ContainerAttach(name, logs, stream, stdin, stdout, stderr, in, out); err != nil {
-		fmt.Fprintf(out, "Error: %s\n", err)
+	var errStream io.Writer
+
+	fmt.Fprintf(outStream, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n")
+
+	if !c.Config.Tty && version >= 1.6 {
+		errStream = utils.NewStdWriter(outStream, utils.Stderr)
+		outStream = utils.NewStdWriter(outStream, utils.Stdout)
+	} else {
+		errStream = outStream
 	}
+
+	if err := srv.ContainerAttach(name, logs, stream, stdin, stdout, stderr, inStream, outStream, errStream); err != nil {
+		fmt.Fprintf(outStream, "Error: %s\n", err)
+	}
+	return nil
+}
+
+func wsContainersAttach(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
+
+	if err := parseForm(r); err != nil {
+		return err
+	}
+	logs, err := getBoolParam(r.Form.Get("logs"))
+	if err != nil {
+		return err
+	}
+	stream, err := getBoolParam(r.Form.Get("stream"))
+	if err != nil {
+		return err
+	}
+	stdin, err := getBoolParam(r.Form.Get("stdin"))
+	if err != nil {
+		return err
+	}
+	stdout, err := getBoolParam(r.Form.Get("stdout"))
+	if err != nil {
+		return err
+	}
+	stderr, err := getBoolParam(r.Form.Get("stderr"))
+	if err != nil {
+		return err
+	}
+
+	if vars == nil {
+		return fmt.Errorf("Missing parameter")
+	}
+	name := vars["name"]
+
+	if _, err := srv.ContainerInspect(name); err != nil {
+		return err
+	}
+
+	h := websocket.Handler(func(ws *websocket.Conn) {
+		defer ws.Close()
+
+		if err := srv.ContainerAttach(name, logs, stream, stdin, stdout, stderr, ws, ws, ws); err != nil {
+			utils.Errorf("Error: %s", err)
+		}
+	})
+	h.ServeHTTP(w, r)
+
 	return nil
 }
 
@@ -737,12 +813,13 @@ func getContainersByName(srv *Server, version float64, w http.ResponseWriter, r
 	if err != nil {
 		return err
 	}
-	b, err := json.Marshal(container)
-	if err != nil {
-		return err
+
+	_, err = srv.ImageInspect(name)
+	if err == nil {
+		return fmt.Errorf("Conflict between containers and images")
 	}
-	writeJSON(w, b)
-	return nil
+
+	return writeJSON(w, http.StatusOK, container)
 }
 
 func getImagesByName(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -755,35 +832,13 @@ func getImagesByName(srv *Server, version float64, w http.ResponseWriter, r *htt
 	if err != nil {
 		return err
 	}
-	b, err := json.Marshal(image)
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	return nil
-}
 
-func postImagesGetCache(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	apiConfig := &APIImageConfig{}
-	if err := json.NewDecoder(r.Body).Decode(apiConfig); err != nil {
-		return err
+	_, err = srv.ContainerInspect(name)
+	if err == nil {
+		return fmt.Errorf("Conflict between containers and images")
 	}
 
-	image, err := srv.ImageGetCached(apiConfig.ID, apiConfig.Config)
-	if err != nil {
-		return err
-	}
-	if image == nil {
-		w.WriteHeader(http.StatusNotFound)
-		return nil
-	}
-	apiID := &APIID{ID: image.ID}
-	b, err := json.Marshal(apiID)
-	if err != nil {
-		return err
-	}
-	writeJSON(w, b)
-	return nil
+	return writeJSON(w, http.StatusOK, image)
 }
 
 func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
@@ -793,12 +848,9 @@ func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Requ
 	remoteURL := r.FormValue("remote")
 	repoName := r.FormValue("t")
 	rawSuppressOutput := r.FormValue("q")
-	tag := ""
-	if strings.Contains(repoName, ":") {
-		remoteParts := strings.Split(repoName, ":")
-		tag = remoteParts[1]
-		repoName = remoteParts[0]
-	}
+	rawNoCache := r.FormValue("nocache")
+	rawRm := r.FormValue("rm")
+	repoName, tag := utils.ParseRepositoryTag(repoName)
 
 	var context io.Reader
 
@@ -844,12 +896,19 @@ func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Requ
 	if err != nil {
 		return err
 	}
+	noCache, err := getBoolParam(rawNoCache)
+	if err != nil {
+		return err
+	}
+	rm, err := getBoolParam(rawRm)
+	if err != nil {
+		return err
+	}
 
-	b := NewBuildFile(srv, utils.NewWriteFlusher(w), !suppressOutput)
+	b := NewBuildFile(srv, utils.NewWriteFlusher(w), !suppressOutput, !noCache, rm)
 	id, err := b.Build(context)
 	if err != nil {
-		fmt.Fprintf(w, "Error build: %s\n", err)
-		return err
+		return fmt.Errorf("Error build: %s", err)
 	}
 	if repoName != "" {
 		srv.runtime.repositories.Set(repoName, tag, id, false)
@@ -857,6 +916,36 @@ func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Requ
 	return nil
 }
 
+func postContainersCopy(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"]
+
+	copyData := &APICopy{}
+	contentType := r.Header.Get("Content-Type")
+	if contentType == "application/json" {
+		if err := json.NewDecoder(r.Body).Decode(copyData); err != nil {
+			return err
+		}
+	} else {
+		return fmt.Errorf("Content-Type not supported: %s", contentType)
+	}
+
+	if copyData.Resource == "" {
+		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())
+		return err
+	}
+	return nil
+}
+
 func optionsHandler(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
 	w.WriteHeader(http.StatusOK)
 	return nil
@@ -867,25 +956,61 @@ func writeCorsHeaders(w http.ResponseWriter, r *http.Request) {
 	w.Header().Add("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS")
 }
 
+func makeHttpHandler(srv *Server, logging bool, localMethod string, localRoute string, handlerFunc HttpApiFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// log the request
+		utils.Debugf("Calling %s %s", localMethod, localRoute)
+
+		if logging {
+			log.Println(r.Method, r.RequestURI)
+		}
+
+		if strings.Contains(r.Header.Get("User-Agent"), "Docker-Client/") {
+			userAgent := strings.Split(r.Header.Get("User-Agent"), "/")
+			if len(userAgent) == 2 && userAgent[1] != VERSION {
+				utils.Debugf("Warning: client and server don't have the same version (client: %s, server: %s)", userAgent[1], VERSION)
+			}
+		}
+		version, err := strconv.ParseFloat(mux.Vars(r)["version"], 64)
+		if err != nil {
+			version = APIVERSION
+		}
+		if srv.enableCors {
+			writeCorsHeaders(w, r)
+		}
+
+		if version == 0 || version > APIVERSION {
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+
+		if err := handlerFunc(srv, version, w, r, mux.Vars(r)); err != nil {
+			utils.Errorf("Error: %s", err)
+			httpError(w, err)
+		}
+	}
+}
+
 func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 	r := mux.NewRouter()
 
-	m := map[string]map[string]func(*Server, float64, http.ResponseWriter, *http.Request, map[string]string) error{
+	m := map[string]map[string]HttpApiFunc{
 		"GET": {
-			"/events":                       getEvents,
-			"/info":                         getInfo,
-			"/version":                      getVersion,
-			"/images/json":                  getImagesJSON,
-			"/images/viz":                   getImagesViz,
-			"/images/search":                getImagesSearch,
-			"/images/{name:.*}/history":     getImagesHistory,
-			"/images/{name:.*}/json":        getImagesByName,
-			"/containers/ps":                getContainersJSON,
-			"/containers/json":              getContainersJSON,
-			"/containers/{name:.*}/export":  getContainersExport,
-			"/containers/{name:.*}/changes": getContainersChanges,
-			"/containers/{name:.*}/json":    getContainersByName,
-			"/containers/{name:.*}/top":     getContainersTop,
+			"/events":                         getEvents,
+			"/info":                           getInfo,
+			"/version":                        getVersion,
+			"/images/json":                    getImagesJSON,
+			"/images/viz":                     getImagesViz,
+			"/images/search":                  getImagesSearch,
+			"/images/{name:.*}/history":       getImagesHistory,
+			"/images/{name:.*}/json":          getImagesByName,
+			"/containers/ps":                  getContainersJSON,
+			"/containers/json":                getContainersJSON,
+			"/containers/{name:.*}/export":    getContainersExport,
+			"/containers/{name:.*}/changes":   getContainersChanges,
+			"/containers/{name:.*}/json":      getContainersByName,
+			"/containers/{name:.*}/top":       getContainersTop,
+			"/containers/{name:.*}/attach/ws": wsContainersAttach,
 		},
 		"POST": {
 			"/auth":                         postAuth,
@@ -895,7 +1020,6 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			"/images/{name:.*}/insert":      postImagesInsert,
 			"/images/{name:.*}/push":        postImagesPush,
 			"/images/{name:.*}/tag":         postImagesTag,
-			"/images/getCache":              postImagesGetCache,
 			"/containers/create":            postContainersCreate,
 			"/containers/{name:.*}/kill":    postContainersKill,
 			"/containers/{name:.*}/restart": postContainersRestart,
@@ -904,6 +1028,7 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			"/containers/{name:.*}/wait":    postContainersWait,
 			"/containers/{name:.*}/resize":  postContainersResize,
 			"/containers/{name:.*}/attach":  postContainersAttach,
+			"/containers/{name:.*}/copy":    postContainersCopy,
 		},
 		"DELETE": {
 			"/containers/{name:.*}": deleteContainers,
@@ -919,37 +1044,13 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			utils.Debugf("Registering %s, %s", method, route)
 			// NOTE: scope issue, make sure the variables are local and won't be changed
 			localRoute := route
-			localMethod := method
 			localFct := fct
-			f := func(w http.ResponseWriter, r *http.Request) {
-				utils.Debugf("Calling %s %s from %s", localMethod, localRoute, r.RemoteAddr)
+			localMethod := method
 
-				if logging {
-					log.Println(r.Method, r.RequestURI)
-				}
-				if strings.Contains(r.Header.Get("User-Agent"), "Docker-Client/") {
-					userAgent := strings.Split(r.Header.Get("User-Agent"), "/")
-					if len(userAgent) == 2 && userAgent[1] != VERSION {
-						utils.Debugf("Warning: client and server don't have the same version (client: %s, server: %s)", userAgent[1], VERSION)
-					}
-				}
-				version, err := strconv.ParseFloat(mux.Vars(r)["version"], 64)
-				if err != nil {
-					version = APIVERSION
-				}
-				if srv.enableCors {
-					writeCorsHeaders(w, r)
-				}
-				if version == 0 || version > APIVERSION {
-					w.WriteHeader(http.StatusNotFound)
-					return
-				}
-
-				if err := localFct(srv, version, w, r, mux.Vars(r)); err != nil {
-					httpError(w, err)
-				}
-			}
+			// build the handler function
+			f := makeHttpHandler(srv, logging, localMethod, localRoute, localFct)
 
+			// add the new route
 			if localRoute == "" {
 				r.Methods(localMethod).HandlerFunc(f)
 			} else {
@@ -958,6 +1059,7 @@ func createRouter(srv *Server, logging bool) (*mux.Router, error) {
 			}
 		}
 	}
+
 	return r, nil
 }
 
@@ -972,9 +1074,26 @@ func ListenAndServe(proto, addr string, srv *Server, logging bool) error {
 	if e != nil {
 		return e
 	}
-	//as the daemon is launched as root, change to permission of the socket to allow non-root to connect
 	if proto == "unix" {
-		os.Chmod(addr, 0777)
+		if err := os.Chmod(addr, 0660); err != nil {
+			return err
+		}
+
+		groups, err := ioutil.ReadFile("/etc/group")
+		if err != nil {
+			return err
+		}
+		re := regexp.MustCompile("(^|\n)docker:.*?:([0-9]+)")
+		if gidMatch := re.FindStringSubmatch(string(groups)); gidMatch != nil {
+			gid, err := strconv.Atoi(gidMatch[2])
+			if err != nil {
+				return err
+			}
+			utils.Debugf("docker group found. gid: %d", gid)
+			if err := os.Chown(addr, 0, gid); err != nil {
+				return err
+			}
+		}
 	}
 	httpSrv := http.Server{Addr: addr, Handler: r}
 	return httpSrv.Serve(l)

api_params.go

@@ -1,5 +1,7 @@
 package docker
 
+import "encoding/json"
+
 type APIHistory struct {
 	ID        string   `json:"Id"`
 	Tags      []string `json:",omitempty"`
@@ -17,16 +19,18 @@ type APIImages struct {
 }
 
 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"`
-	LXCVersion      string `json:",omitempty"`
-	NEventsListener int    `json:",omitempty"`
-	KernelVersion   string `json:",omitempty"`
+	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 {
@@ -40,6 +44,30 @@ type APIRmi struct {
 }
 
 type APIContainers struct {
+	ID         string `json:"Id"`
+	Image      string
+	Command    string
+	Created    int64
+	Status     string
+	Ports      []APIPort
+	SizeRw     int64
+	SizeRootFs int64
+}
+
+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
@@ -65,7 +93,17 @@ type APIRun struct {
 }
 
 type APIPort struct {
-	Port string
+	PrivatePort int64
+	PublicPort  int64
+	Type        string
+}
+
+func (port *APIPort) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]interface{}{
+		"PrivatePort": port.PrivatePort,
+		"PublicPort":  port.PublicPort,
+		"Type":        port.Type,
+	})
 }
 
 type APIVersion struct {
@@ -86,3 +124,8 @@ type APIImageConfig struct {
 	ID string `json:"Id"`
 	*Config
 }
+
+type APICopy struct {
+	Resource string
+	HostPath string
+}

api_test.go

@@ -5,6 +5,7 @@ import (
 	"bufio"
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"github.com/dotcloud/docker/utils"
 	"io"
 	"net"
@@ -12,6 +13,7 @@ import (
 	"net/http/httptest"
 	"os"
 	"path"
+	"strings"
 	"testing"
 	"time"
 )
@@ -40,6 +42,25 @@ func TestGetBoolParam(t *testing.T) {
 	}
 }
 
+func TesthttpError(t *testing.T) {
+	r := httptest.NewRecorder()
+
+	httpError(r, fmt.Errorf("No such method"))
+	if r.Code != http.StatusNotFound {
+		t.Fatalf("Expected %d, got %d", http.StatusNotFound, r.Code)
+	}
+
+	httpError(r, fmt.Errorf("This accound hasn't been activated"))
+	if r.Code != http.StatusForbidden {
+		t.Fatalf("Expected %d, got %d", http.StatusForbidden, r.Code)
+	}
+
+	httpError(r, fmt.Errorf("Some error"))
+	if r.Code != http.StatusInternalServerError {
+		t.Fatalf("Expected %d, got %d", http.StatusInternalServerError, r.Code)
+	}
+}
+
 func TestGetVersion(t *testing.T) {
 	var err error
 	runtime := mkRuntime(t)
@@ -68,7 +89,7 @@ func TestGetInfo(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	initialImages, err := srv.runtime.graph.All()
+	initialImages, err := srv.runtime.graph.Map()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -97,8 +118,8 @@ func TestGetEvents(t *testing.T) {
 		listeners: make(map[string]chan utils.JSONMessage),
 	}
 
-	srv.LogEvent("fakeaction", "fakeid")
-	srv.LogEvent("fakeaction2", "fakeid")
+	srv.LogEvent("fakeaction", "fakeid", "fakeimage")
+	srv.LogEvent("fakeaction2", "fakeid", "fakeimage")
 
 	req, err := http.NewRequest("GET", "/events?since=1", nil)
 	if err != nil {
@@ -243,7 +264,11 @@ func TestGetImagesJSON(t *testing.T) {
 		t.Fatalf("Error expected, received none")
 	}
 
-	httpError(r4, err)
+	if !strings.HasPrefix(err.Error(), "Bad parameter") {
+		t.Fatalf("Error should starts with \"Bad parameter\"")
+	}
+	http.Error(r4, err.Error(), http.StatusBadRequest)
+
 	if r4.Code != http.StatusBadRequest {
 		t.Fatalf("%d Bad Request expected, received %d\n", http.StatusBadRequest, r4.Code)
 	}
@@ -321,7 +346,7 @@ func TestGetContainersJSON(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	container, err := NewBuilder(runtime).Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"echo", "test"},
 	})
@@ -357,10 +382,8 @@ func TestGetContainersExport(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	builder := NewBuilder(runtime)
-
 	// Create a container and remove a file
-	container, err := builder.Create(
+	container, err := runtime.Create(
 		&Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"touch", "/test"},
@@ -409,10 +432,8 @@ func TestGetContainersChanges(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	builder := NewBuilder(runtime)
-
 	// Create a container and remove a file
-	container, err := builder.Create(
+	container, err := runtime.Create(
 		&Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"/bin/rm", "/etc/passwd"},
@@ -449,6 +470,7 @@ func TestGetContainersChanges(t *testing.T) {
 }
 
 func TestGetContainersTop(t *testing.T) {
+	t.Skip("Fixme. Skipping test for now. Reported error when testing using dind: 'api_test.go:527: Expected 2 processes, found 0.'")
 	runtime, err := newTestRuntime()
 	if err != nil {
 		t.Fatal(err)
@@ -457,30 +479,50 @@ func TestGetContainersTop(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	builder := NewBuilder(runtime)
-
-	container, err := builder.Create(
+	container, err := runtime.Create(
 		&Config{
-			Image: GetTestImage(runtime).ID,
-			Cmd:   []string{"/bin/sh", "-c", "sleep 2"},
+			Image:     GetTestImage(runtime).ID,
+			Cmd:       []string{"/bin/sh", "-c", "cat"},
+			OpenStdin: true,
 		},
 	)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer runtime.Destroy(container)
+	defer func() {
+		// Make sure the process dies before destroying runtime
+		container.stdin.Close()
+		container.WaitTimeout(2 * time.Second)
+	}()
+
 	hostConfig := &HostConfig{}
 	if err := container.Start(hostConfig); err != nil {
 		t.Fatal(err)
 	}
 
-	// Give some time to the process to start
-	container.WaitTimeout(500 * time.Millisecond)
+	setTimeout(t, "Waiting for the container to be started timed out", 10*time.Second, func() {
+		for {
+			if container.State.Running {
+				break
+			}
+			time.Sleep(10 * time.Millisecond)
+		}
+	})
 
 	if !container.State.Running {
-		t.Errorf("Container should be running")
+		t.Fatalf("Container should be running")
 	}
 
+	// Make sure sh spawn up cat
+	setTimeout(t, "read/write assertion timed out", 2*time.Second, func() {
+		in, _ := container.StdinPipe()
+		out, _ := container.StdoutPipe()
+		if err := assertPipe("hello\n", "hello", out, in, 15); err != nil {
+			t.Fatal(err)
+		}
+	})
+
 	r := httptest.NewRecorder()
 	req, err := http.NewRequest("GET", "/"+container.ID+"/top?ps_args=u", bytes.NewReader([]byte{}))
 	if err != nil {
@@ -504,11 +546,11 @@ func TestGetContainersTop(t *testing.T) {
 	if len(procs.Processes) != 2 {
 		t.Fatalf("Expected 2 processes, found %d.", len(procs.Processes))
 	}
-	if procs.Processes[0][10] != "/bin/sh" && procs.Processes[0][10] != "sleep" {
-		t.Fatalf("Expected `sleep` or `/bin/sh`, found %s.", procs.Processes[0][10])
+	if procs.Processes[0][10] != "/bin/sh" && procs.Processes[0][10] != "cat" {
+		t.Fatalf("Expected `cat` or `/bin/sh`, found %s.", procs.Processes[0][10])
 	}
-	if procs.Processes[1][10] != "/bin/sh" && procs.Processes[1][10] != "sleep" {
-		t.Fatalf("Expected `sleep` or `/bin/sh`, found %s.", procs.Processes[1][10])
+	if procs.Processes[1][10] != "/bin/sh" && procs.Processes[1][10] != "cat" {
+		t.Fatalf("Expected `cat` or `/bin/sh`, found %s.", procs.Processes[1][10])
 	}
 }
 
@@ -518,10 +560,8 @@ func TestGetContainersByName(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	builder := NewBuilder(runtime)
-
 	// Create a container and remove a file
-	container, err := builder.Create(
+	container, err := runtime.Create(
 		&Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"echo", "test"},
@@ -541,7 +581,7 @@ func TestGetContainersByName(t *testing.T) {
 		t.Fatal(err)
 	}
 	if outContainer.ID != container.ID {
-		t.Fatalf("Wrong containers retrieved. Expected %s, recieved %s", container.ID, outContainer.ID)
+		t.Fatalf("Wrong containers retrieved. Expected %s, received %s", container.ID, outContainer.ID)
 	}
 }
 
@@ -551,10 +591,8 @@ func TestPostCommit(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	builder := NewBuilder(runtime)
-
 	// Create a container and remove a file
-	container, err := builder.Create(
+	container, err := runtime.Create(
 		&Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"touch", "/test"},
@@ -648,7 +686,7 @@ func TestPostContainersKill(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	container, err := NewBuilder(runtime).Create(
+	container, err := runtime.Create(
 		&Config{
 			Image:     GetTestImage(runtime).ID,
 			Cmd:       []string{"/bin/cat"},
@@ -690,7 +728,7 @@ func TestPostContainersRestart(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	container, err := NewBuilder(runtime).Create(
+	container, err := runtime.Create(
 		&Config{
 			Image:     GetTestImage(runtime).ID,
 			Cmd:       []string{"/bin/cat"},
@@ -744,7 +782,7 @@ func TestPostContainersStart(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	container, err := NewBuilder(runtime).Create(
+	container, err := runtime.Create(
 		&Config{
 			Image:     GetTestImage(runtime).ID,
 			Cmd:       []string{"/bin/cat"},
@@ -763,6 +801,8 @@ func TestPostContainersStart(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	req.Header.Set("Content-Type", "application/json")
+
 	r := httptest.NewRecorder()
 	if err := postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
 		t.Fatal(err)
@@ -780,7 +820,7 @@ func TestPostContainersStart(t *testing.T) {
 
 	r = httptest.NewRecorder()
 	if err = postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err == nil {
-		t.Fatalf("A running containter should be able to be started")
+		t.Fatalf("A running container should be able to be started")
 	}
 
 	if err := container.Kill(); err != nil {
@@ -794,7 +834,7 @@ func TestPostContainersStop(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	container, err := NewBuilder(runtime).Create(
+	container, err := runtime.Create(
 		&Config{
 			Image:     GetTestImage(runtime).ID,
 			Cmd:       []string{"/bin/cat"},
@@ -841,7 +881,7 @@ func TestPostContainersWait(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	container, err := NewBuilder(runtime).Create(
+	container, err := runtime.Create(
 		&Config{
 			Image:     GetTestImage(runtime).ID,
 			Cmd:       []string{"/bin/sleep", "1"},
@@ -883,7 +923,7 @@ func TestPostContainersAttach(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	container, err := NewBuilder(runtime).Create(
+	container, err := runtime.Create(
 		&Config{
 			Image:     GetTestImage(runtime).ID,
 			Cmd:       []string{"/bin/cat"},
@@ -904,7 +944,7 @@ func TestPostContainersAttach(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
 
-	// Try to avoid the timeoout in destroy. Best effort, don't check error
+	// Try to avoid the timeout in destroy. Best effort, don't check error
 	defer func() {
 		closeWrap(stdin, stdinPipe, stdout, stdoutPipe)
 		container.Kill()
@@ -938,7 +978,7 @@ func TestPostContainersAttach(t *testing.T) {
 	})
 
 	setTimeout(t, "read/write assertion timed out", 2*time.Second, func() {
-		if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
+		if err := assertPipe("hello\n", string([]byte{1, 0, 0, 0, 0, 0, 0, 6})+"hello", stdout, stdinPipe, 15); err != nil {
 			t.Fatal(err)
 		}
 	})
@@ -960,7 +1000,96 @@ func TestPostContainersAttach(t *testing.T) {
 		t.Fatalf("/bin/cat is not running after closing stdin")
 	}
 
-	// Try to avoid the timeoout in destroy. Best effort, don't check error
+	// Try to avoid the timeout in destroy. Best effort, don't check error
+	cStdin, _ := container.StdinPipe()
+	cStdin.Close()
+	container.Wait()
+}
+
+func TestPostContainersAttachStderr(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+
+	srv := &Server{runtime: runtime}
+
+	container, err := runtime.Create(
+		&Config{
+			Image:     GetTestImage(runtime).ID,
+			Cmd:       []string{"/bin/sh", "-c", "/bin/cat >&2"},
+			OpenStdin: true,
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container)
+
+	// Start the process
+	hostConfig := &HostConfig{}
+	if err := container.Start(hostConfig); err != nil {
+		t.Fatal(err)
+	}
+
+	stdin, stdinPipe := io.Pipe()
+	stdout, stdoutPipe := io.Pipe()
+
+	// Try to avoid the timeout in destroy. Best effort, don't check error
+	defer func() {
+		closeWrap(stdin, stdinPipe, stdout, stdoutPipe)
+		container.Kill()
+	}()
+
+	// Attach to it
+	c1 := make(chan struct{})
+	go func() {
+		defer close(c1)
+
+		r := &hijackTester{
+			ResponseRecorder: httptest.NewRecorder(),
+			in:               stdin,
+			out:              stdoutPipe,
+		}
+
+		req, err := http.NewRequest("POST", "/containers/"+container.ID+"/attach?stream=1&stdin=1&stdout=1&stderr=1", bytes.NewReader([]byte{}))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if err := postContainersAttach(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	// Acknowledge hijack
+	setTimeout(t, "hijack acknowledge timed out", 2*time.Second, func() {
+		stdout.Read([]byte{})
+		stdout.Read(make([]byte, 4096))
+	})
+
+	setTimeout(t, "read/write assertion timed out", 2*time.Second, func() {
+		if err := assertPipe("hello\n", string([]byte{2, 0, 0, 0, 0, 0, 0, 6})+"hello", stdout, stdinPipe, 15); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	// Close pipes (client disconnects)
+	if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
+		t.Fatal(err)
+	}
+
+	// Wait for attach to finish, the client disconnected, therefore, Attach finished his job
+	setTimeout(t, "Waiting for CmdAttach timed out", 10*time.Second, func() {
+		<-c1
+	})
+
+	// 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.Running {
+		t.Fatalf("/bin/cat is not running after closing stdin")
+	}
+
+	// Try to avoid the timeout in destroy. Best effort, don't check error
 	cStdin, _ := container.StdinPipe()
 	cStdin.Close()
 	container.Wait()
@@ -975,7 +1104,7 @@ func TestDeleteContainers(t *testing.T) {
 
 	srv := &Server{runtime: runtime}
 
-	container, err := NewBuilder(runtime).Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"touch", "/test"},
 	})
@@ -1142,6 +1271,82 @@ func TestDeleteImages(t *testing.T) {
 		} */
 }
 
+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()
+	}
+}
+
+func TestPostContainersCopy(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+
+	srv := &Server{runtime: runtime}
+
+	// Create a container and remove a file
+	container, err := runtime.Create(
+		&Config{
+			Image: GetTestImage(runtime).ID,
+			Cmd:   []string{"touch", "/test.txt"},
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container)
+
+	if err := container.Run(); err != nil {
+		t.Fatal(err)
+	}
+
+	r := httptest.NewRecorder()
+	copyData := APICopy{HostPath: ".", Resource: "/test.txt"}
+
+	jsonData, err := json.Marshal(copyData)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req, err := http.NewRequest("POST", "/containers/"+container.ID+"/copy", bytes.NewReader(jsonData))
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Add("Content-Type", "application/json")
+	if err = postContainersCopy(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {
+		t.Fatal(err)
+	}
+
+	if r.Code != http.StatusOK {
+		t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code)
+	}
+
+	found := false
+	for tarReader := tar.NewReader(r.Body); ; {
+		h, err := tarReader.Next()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			t.Fatal(err)
+		}
+		if h.Name == "test.txt" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("The created test file has not been found in the copied output")
+	}
+}
+
 // Mocked types for tests
 type NopConn struct {
 	io.ReadCloser

archive.go

@@ -98,7 +98,7 @@ func TarFilter(path string, compression Compression, filter []string) (io.Reader
 
 // Untar reads a stream of bytes from `archive`, parses it as a tar archive,
 // and unpacks it into the directory at `path`.
-// The archive may be compressed with one of the following algorithgms:
+// 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) error {
@@ -173,7 +173,7 @@ func CopyWithTar(src, dst string) error {
 	}
 	// Create dst, copy src's content into it
 	utils.Debugf("Creating dest directory: %s", dst)
-	if err := os.MkdirAll(dst, 0700); err != nil && !os.IsExist(err) {
+	if err := os.MkdirAll(dst, 0755); err != nil && !os.IsExist(err) {
 		return err
 	}
 	utils.Debugf("Calling TarUntar(%s, %s)", src, dst)

auth/MAINTAINERS

@@ -1 +0,0 @@
-../registry/MAINTAINERS

auth/MAINTAINERS

@@ -0,0 +1,3 @@
+Sam Alba <sam@dotcloud.com> (@samalba)
+Joffrey Fuhrer <joffrey@dotcloud.com> (@shin-)
+Ken Cochrane <ken@dotcloud.com> (@kencochrane)

auth/auth.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/dotcloud/docker/utils"
 	"io/ioutil"
 	"net/http"
 	"os"
@@ -18,17 +19,18 @@ const CONFIGFILE = ".dockercfg"
 // Only used for user auth + account creation
 const INDEXSERVER = "https://index.docker.io/v1/"
 
-//const INDEXSERVER = "http://indexstaging-docker.dotcloud.com/"
+//const INDEXSERVER = "https://indexstaging-docker.dotcloud.com/v1/"
 
 var (
 	ErrConfigFileMissing = errors.New("The Auth config file is missing")
 )
 
 type AuthConfig struct {
-	Username string `json:"username,omitempty"`
-	Password string `json:"password,omitempty"`
-	Auth     string `json:"auth"`
-	Email    string `json:"email"`
+	Username      string `json:"username,omitempty"`
+	Password      string `json:"password,omitempty"`
+	Auth          string `json:"auth"`
+	Email         string `json:"email"`
+	ServerAddress string `json:"serveraddress,omitempty"`
 }
 
 type ConfigFile struct {
@@ -75,35 +77,43 @@ func LoadConfig(rootPath string) (*ConfigFile, error) {
 	configFile := ConfigFile{Configs: make(map[string]AuthConfig), rootPath: rootPath}
 	confFile := path.Join(rootPath, CONFIGFILE)
 	if _, err := os.Stat(confFile); err != nil {
-		return &configFile, ErrConfigFileMissing
+		return &configFile, nil //missing file is not an error
 	}
 	b, err := ioutil.ReadFile(confFile)
 	if err != nil {
-		return nil, err
+		return &configFile, err
 	}
 
 	if err := json.Unmarshal(b, &configFile.Configs); err != nil {
 		arr := strings.Split(string(b), "\n")
 		if len(arr) < 2 {
-			return nil, fmt.Errorf("The Auth config file is empty")
+			return &configFile, fmt.Errorf("The Auth config file is empty")
 		}
 		authConfig := AuthConfig{}
 		origAuth := strings.Split(arr[0], " = ")
+		if len(origAuth) != 2 {
+			return &configFile, fmt.Errorf("Invalid Auth config file")
+		}
 		authConfig.Username, authConfig.Password, err = decodeAuth(origAuth[1])
 		if err != nil {
-			return nil, err
+			return &configFile, err
 		}
 		origEmail := strings.Split(arr[1], " = ")
+		if len(origEmail) != 2 {
+			return &configFile, fmt.Errorf("Invalid Auth config file")
+		}
 		authConfig.Email = origEmail[1]
+		authConfig.ServerAddress = IndexServerAddress()
 		configFile.Configs[IndexServerAddress()] = authConfig
 	} else {
 		for k, authConfig := range configFile.Configs {
 			authConfig.Username, authConfig.Password, err = decodeAuth(authConfig.Auth)
 			if err != nil {
-				return nil, err
+				return &configFile, err
 			}
 			authConfig.Auth = ""
 			configFile.Configs[k] = authConfig
+			authConfig.ServerAddress = k
 		}
 	}
 	return &configFile, nil
@@ -124,7 +134,7 @@ func SaveConfig(configFile *ConfigFile) error {
 		authCopy.Auth = encodeAuth(&authCopy)
 		authCopy.Username = ""
 		authCopy.Password = ""
-
+		authCopy.ServerAddress = ""
 		configs[k] = authCopy
 	}
 
@@ -140,19 +150,31 @@ func SaveConfig(configFile *ConfigFile) error {
 }
 
 // try to register/login to the registry server
-func Login(authConfig *AuthConfig) (string, error) {
+func Login(authConfig *AuthConfig, factory *utils.HTTPRequestFactory) (string, error) {
 	client := &http.Client{}
 	reqStatusCode := 0
 	var status string
 	var reqBody []byte
-	jsonBody, err := json.Marshal(authConfig)
+
+	serverAddress := authConfig.ServerAddress
+	if serverAddress == "" {
+		serverAddress = IndexServerAddress()
+	}
+
+	loginAgainstOfficialIndex := serverAddress == IndexServerAddress()
+
+	// to avoid sending the server address to the server it should be removed before marshalled
+	authCopy := *authConfig
+	authCopy.ServerAddress = ""
+
+	jsonBody, err := json.Marshal(authCopy)
 	if err != nil {
 		return "", fmt.Errorf("Config Error: %s", err)
 	}
 
 	// using `bytes.NewReader(jsonBody)` here causes the server to respond with a 411 status.
 	b := strings.NewReader(string(jsonBody))
-	req1, err := http.Post(IndexServerAddress()+"users/", "application/json; charset=utf-8", b)
+	req1, err := http.Post(serverAddress+"users/", "application/json; charset=utf-8", b)
 	if err != nil {
 		return "", fmt.Errorf("Server Error: %s", err)
 	}
@@ -164,14 +186,23 @@ func Login(authConfig *AuthConfig) (string, error) {
 	}
 
 	if reqStatusCode == 201 {
-		status = "Account created. Please use the confirmation link we sent" +
-			" to your e-mail to activate it."
+		if loginAgainstOfficialIndex {
+			status = "Account created. Please use the confirmation link we sent" +
+				" to your e-mail to activate it."
+		} else {
+			status = "Account created. Please see the documentation of the registry " + serverAddress + " for instructions how to activate it."
+		}
 	} else if reqStatusCode == 403 {
-		return "", fmt.Errorf("Login: Your account hasn't been activated. " +
-			"Please check your e-mail for a confirmation link.")
+		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.")
+		}
 	} else if reqStatusCode == 400 {
 		if string(reqBody) == "\"Username or email already exists\"" {
-			req, err := http.NewRequest("GET", IndexServerAddress()+"users/", nil)
+			req, err := factory.NewRequest("GET", serverAddress+"users/", nil)
 			req.SetBasicAuth(authConfig.Username, authConfig.Password)
 			resp, err := client.Do(req)
 			if err != nil {
@@ -198,3 +229,52 @@ func Login(authConfig *AuthConfig) (string, error) {
 	}
 	return status, nil
 }
+
+// this method matches a auth configuration to a server address or a url
+func (config *ConfigFile) ResolveAuthConfig(registry string) AuthConfig {
+	if registry == IndexServerAddress() || len(registry) == 0 {
+		// default to the index server
+		return config.Configs[IndexServerAddress()]
+	}
+	// if its not the index server there are three cases:
+	//
+	// 1. this is a full config url -> it should be used as is
+	// 2. it could be a full url, but with the wrong protocol
+	// 3. it can be the hostname optionally with a port
+	//
+	// as there is only one auth entry which is fully qualified we need to start
+	// parsing and matching
+
+	swapProtocol := func(url string) string {
+		if strings.HasPrefix(url, "http:") {
+			return strings.Replace(url, "http:", "https:", 1)
+		}
+		if strings.HasPrefix(url, "https:") {
+			return strings.Replace(url, "https:", "http:", 1)
+		}
+		return url
+	}
+
+	resolveIgnoringProtocol := func(url string) AuthConfig {
+		if c, found := config.Configs[url]; found {
+			return c
+		}
+		registrySwappedProtocol := swapProtocol(url)
+		// now try to match with the different protocol
+		if c, found := config.Configs[registrySwappedProtocol]; found {
+			return c
+		}
+		return AuthConfig{}
+	}
+
+	// match both protocols as it could also be a server name like httpfoo
+	if strings.HasPrefix(registry, "http:") || strings.HasPrefix(registry, "https:") {
+		return resolveIgnoringProtocol(registry)
+	}
+
+	url := "https://" + registry
+	if !strings.Contains(registry, "/") {
+		url = url + "/v1/"
+	}
+	return resolveIgnoringProtocol(url)
+}

auth/auth_test.go

@@ -33,7 +33,7 @@ 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)
+	status, err := Login(authConfig, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -53,7 +53,7 @@ func TestCreateAccount(t *testing.T) {
 	token := hex.EncodeToString(tokenBuffer)[:12]
 	username := "ut" + token
 	authConfig := &AuthConfig{Username: username, Password: "test42", Email: "docker-ut+" + token + "@example.com"}
-	status, err := Login(authConfig)
+	status, err := Login(authConfig, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -63,7 +63,7 @@ func TestCreateAccount(t *testing.T) {
 		t.Fatalf("Expected status: \"%s\", found \"%s\" instead.", expectedStatus, status)
 	}
 
-	status, err = Login(authConfig)
+	status, err = Login(authConfig, nil)
 	if err == nil {
 		t.Fatalf("Expected error but found nil instead")
 	}
@@ -75,20 +75,31 @@ func TestCreateAccount(t *testing.T) {
 	}
 }
 
-func TestSameAuthDataPostSave(t *testing.T) {
+func setupTempConfigFile() (*ConfigFile, error) {
 	root, err := ioutil.TempDir("", "docker-test")
 	if err != nil {
-		t.Fatal(err)
+		return nil, err
 	}
 	configFile := &ConfigFile{
 		rootPath: root,
-		Configs:  make(map[string]AuthConfig, 1),
+		Configs:  make(map[string]AuthConfig),
 	}
 
-	configFile.Configs["testIndex"] = AuthConfig{
-		Username: "docker-user",
-		Password: "docker-pass",
-		Email:    "docker@docker.io",
+	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()
+	if err != nil {
+		t.Fatal(err)
 	}
 
 	err = SaveConfig(configFile)
@@ -110,3 +121,68 @@ func TestSameAuthDataPostSave(t *testing.T) {
 		t.Fail()
 	}
 }
+
+func TestResolveAuthConfigIndexServer(t *testing.T) {
+	configFile, err := setupTempConfigFile()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	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)
+	}
+
+	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)
+			}
+		}
+	}
+}

builder.go

@@ -1,147 +0,0 @@
-package docker
-
-import (
-	"fmt"
-	"github.com/dotcloud/docker/utils"
-	"os"
-	"path"
-	"time"
-)
-
-var defaultDns = []string{"8.8.8.8", "8.8.4.4"}
-
-type Builder struct {
-	runtime      *Runtime
-	repositories *TagStore
-	graph        *Graph
-
-	config *Config
-	image  *Image
-}
-
-func NewBuilder(runtime *Runtime) *Builder {
-	return &Builder{
-		runtime:      runtime,
-		graph:        runtime.graph,
-		repositories: runtime.repositories,
-	}
-}
-
-func (builder *Builder) Create(config *Config) (*Container, error) {
-	// Lookup image
-	img, err := builder.repositories.LookupImage(config.Image)
-	if err != nil {
-		return nil, err
-	}
-
-	if img.Config != nil {
-		MergeConfig(config, img.Config)
-	}
-
-	if config.Cmd == nil || len(config.Cmd) == 0 {
-		return nil, fmt.Errorf("No command specified")
-	}
-
-	// Generate id
-	id := GenerateID()
-	// Generate default hostname
-	// FIXME: the lxc template no longer needs to set a default hostname
-	if config.Hostname == "" {
-		config.Hostname = id[:12]
-	}
-
-	var args []string
-	var entrypoint string
-
-	if len(config.Entrypoint) != 0 {
-		entrypoint = config.Entrypoint[0]
-		args = append(config.Entrypoint[1:], config.Cmd...)
-	} else {
-		entrypoint = config.Cmd[0]
-		args = config.Cmd[1:]
-	}
-
-	container := &Container{
-		// FIXME: we should generate the ID here instead of receiving it as an argument
-		ID:              id,
-		Created:         time.Now(),
-		Path:            entrypoint,
-		Args:            args, //FIXME: de-duplicate from config
-		Config:          config,
-		Image:           img.ID, // Always use the resolved image id
-		NetworkSettings: &NetworkSettings{},
-		// FIXME: do we need to store this in the container?
-		SysInitPath: sysInitPath,
-	}
-	container.root = builder.runtime.containerRoot(container.ID)
-	// Step 1: create the container directory.
-	// This doubles as a barrier to avoid race conditions.
-	if err := os.Mkdir(container.root, 0700); err != nil {
-		return nil, err
-	}
-
-	if len(config.Dns) == 0 && len(builder.runtime.Dns) == 0 && utils.CheckLocalDns() {
-		//"WARNING: Docker detected local DNS server on resolv.conf. Using default external servers: %v", defaultDns
-		builder.runtime.Dns = defaultDns
-	}
-
-	// If custom dns exists, then create a resolv.conf for the container
-	if len(config.Dns) > 0 || len(builder.runtime.Dns) > 0 {
-		var dns []string
-		if len(config.Dns) > 0 {
-			dns = config.Dns
-		} else {
-			dns = builder.runtime.Dns
-		}
-		container.ResolvConfPath = path.Join(container.root, "resolv.conf")
-		f, err := os.Create(container.ResolvConfPath)
-		if err != nil {
-			return nil, err
-		}
-		defer f.Close()
-		for _, dns := range dns {
-			if _, err := f.Write([]byte("nameserver " + dns + "\n")); err != nil {
-				return nil, err
-			}
-		}
-	} else {
-		container.ResolvConfPath = "/etc/resolv.conf"
-	}
-
-	// Step 2: save the container json
-	if err := container.ToDisk(); err != nil {
-		return nil, err
-	}
-	// Step 3: register the container
-	if err := builder.runtime.Register(container); err != nil {
-		return nil, err
-	}
-	return container, nil
-}
-
-// Commit creates a new filesystem image from the current state of a container.
-// The image can optionally be tagged into a repository
-func (builder *Builder) Commit(container *Container, repository, tag, comment, author string, config *Config) (*Image, error) {
-	// FIXME: freeze the container before copying it to avoid data corruption?
-	// FIXME: this shouldn't be in commands.
-	if err := container.EnsureMounted(); err != nil {
-		return nil, err
-	}
-
-	rwTar, err := container.ExportRw()
-	if err != nil {
-		return nil, err
-	}
-	// Create a new image from the container's base layers + a new layer from container changes
-	img, err := builder.graph.Create(rwTar, container, comment, author, config)
-	if err != nil {
-		return nil, err
-	}
-	// Register the image if needed
-	if repository != "" {
-		if err := builder.repositories.Set(repository, tag, img.ID, true); err != nil {
-			return img, err
-		}
-	}
-	return img, nil
-}

buildfile.go

@@ -1,7 +1,6 @@
 package docker
 
 import (
-	"bufio"
 	"encoding/json"
 	"fmt"
 	"github.com/dotcloud/docker/utils"
@@ -23,14 +22,15 @@ type BuildFile interface {
 
 type buildFile struct {
 	runtime *Runtime
-	builder *Builder
 	srv     *Server
 
-	image      string
-	maintainer string
-	config     *Config
-	context    string
-	verbose    bool
+	image        string
+	maintainer   string
+	config       *Config
+	context      string
+	verbose      bool
+	utilizeCache bool
+	rm           bool
 
 	tmpContainers map[string]struct{}
 	tmpImages     map[string]struct{}
@@ -38,15 +38,11 @@ type buildFile struct {
 	out io.Writer
 }
 
-func (b *buildFile) clearTmp(containers, images map[string]struct{}) {
+func (b *buildFile) clearTmp(containers map[string]struct{}) {
 	for c := range containers {
 		tmp := b.runtime.Get(c)
 		b.runtime.Destroy(tmp)
-		utils.Debugf("Removing container %s", c)
-	}
-	for i := range images {
-		b.runtime.graph.Delete(i)
-		utils.Debugf("Removing image %s", i)
+		fmt.Fprintf(b.out, "Removing intermediate container %s\n", utils.TruncateID(c))
 	}
 }
 
@@ -55,7 +51,7 @@ func (b *buildFile) CmdFrom(name string) error {
 	if err != nil {
 		if b.runtime.graph.IsNotExist(err) {
 			remote, tag := utils.ParseRepositoryTag(name)
-			if err := b.srv.ImagePull(remote, tag, b.out, utils.NewStreamFormatter(false), nil); err != nil {
+			if err := b.srv.ImagePull(remote, tag, b.out, utils.NewStreamFormatter(false), nil, nil, true); err != nil {
 				return err
 			}
 			image, err = b.runtime.repositories.LookupImage(name)
@@ -92,17 +88,21 @@ func (b *buildFile) CmdRun(args string) error {
 	b.config.Cmd = nil
 	MergeConfig(b.config, config)
 
+	defer func(cmd []string) { b.config.Cmd = cmd }(cmd)
+
 	utils.Debugf("Command to be executed: %v", b.config.Cmd)
 
-	if cache, err := b.srv.ImageGetCached(b.image, b.config); err != nil {
-		return err
-	} else if cache != nil {
-		fmt.Fprintf(b.out, " ---> Using cache\n")
-		utils.Debugf("[BUILDER] Use cached version")
-		b.image = cache.ID
-		return nil
-	} else {
-		utils.Debugf("[BUILDER] Cache miss")
+	if b.utilizeCache {
+		if cache, err := b.srv.ImageGetCached(b.image, b.config); err != nil {
+			return err
+		} else if cache != nil {
+			fmt.Fprintf(b.out, " ---> Using cache\n")
+			utils.Debugf("[BUILDER] Use cached version")
+			b.image = cache.ID
+			return nil
+		} else {
+			utils.Debugf("[BUILDER] Cache miss")
+		}
 	}
 
 	cid, err := b.run()
@@ -112,7 +112,7 @@ func (b *buildFile) CmdRun(args string) error {
 	if err := b.commit(cid, cmd, "run"); err != nil {
 		return err
 	}
-	b.config.Cmd = cmd
+
 	return nil
 }
 
@@ -167,9 +167,9 @@ func (b *buildFile) CmdEnv(args string) error {
 
 	if envKey >= 0 {
 		b.config.Env[envKey] = replacedVar
-		return nil
+	} else {
+		b.config.Env = append(b.config.Env, replacedVar)
 	}
-	b.config.Env = append(b.config.Env, replacedVar)
 	return b.commit("", b.config.Cmd, fmt.Sprintf("ENV %s", replacedVar))
 }
 
@@ -192,6 +192,11 @@ func (b *buildFile) CmdExpose(args string) error {
 	return b.commit("", b.config.Cmd, fmt.Sprintf("EXPOSE %v", ports))
 }
 
+func (b *buildFile) CmdUser(args string) error {
+	b.config.User = args
+	return b.commit("", b.config.Cmd, fmt.Sprintf("USER %v", args))
+}
+
 func (b *buildFile) CmdInsert(args string) error {
 	return fmt.Errorf("INSERT has been deprecated. Please use ADD instead")
 }
@@ -217,6 +222,11 @@ func (b *buildFile) CmdEntrypoint(args string) error {
 	return nil
 }
 
+func (b *buildFile) CmdWorkdir(workdir string) error {
+	b.config.WorkingDir = workdir
+	return b.commit("", b.config.Cmd, fmt.Sprintf("WORKDIR %v", workdir))
+}
+
 func (b *buildFile) CmdVolume(args string) error {
 	if args == "" {
 		return fmt.Errorf("Volume cannot be empty")
@@ -273,9 +283,12 @@ func (b *buildFile) addContext(container *Container, orig, dest string) error {
 	if strings.HasSuffix(dest, "/") {
 		destPath = destPath + "/"
 	}
+	if !strings.HasPrefix(origPath, b.context) {
+		return fmt.Errorf("Forbidden path: %s", origPath)
+	}
 	fi, err := os.Stat(origPath)
 	if err != nil {
-		return err
+		return fmt.Errorf("%s: no such file or directory", orig)
 	}
 	if fi.IsDir() {
 		if err := CopyWithTar(origPath, destPath); err != nil {
@@ -319,7 +332,7 @@ func (b *buildFile) CmdAdd(args string) error {
 
 	b.config.Image = b.image
 	// Create the container and start it
-	container, err := b.builder.Create(b.config)
+	container, err := b.runtime.Create(b.config)
 	if err != nil {
 		return err
 	}
@@ -354,7 +367,7 @@ func (b *buildFile) run() (string, error) {
 	b.config.Image = b.image
 
 	// Create the container and start it
-	c, err := b.builder.Create(b.config)
+	c, err := b.runtime.Create(b.config)
 	if err != nil {
 		return "", err
 	}
@@ -397,17 +410,20 @@ func (b *buildFile) commit(id string, autoCmd []string, comment string) error {
 		b.config.Cmd = []string{"/bin/sh", "-c", "#(nop) " + comment}
 		defer func(cmd []string) { b.config.Cmd = cmd }(cmd)
 
-		if cache, err := b.srv.ImageGetCached(b.image, b.config); err != nil {
-			return err
-		} else if cache != nil {
-			fmt.Fprintf(b.out, " ---> Using cache\n")
-			utils.Debugf("[BUILDER] Use cached version")
-			b.image = cache.ID
-			return nil
-		} else {
-			utils.Debugf("[BUILDER] Cache miss")
+		if b.utilizeCache {
+			if cache, err := b.srv.ImageGetCached(b.image, b.config); err != nil {
+				return err
+			} else if cache != nil {
+				fmt.Fprintf(b.out, " ---> Using cache\n")
+				utils.Debugf("[BUILDER] Use cached version")
+				b.image = cache.ID
+				return nil
+			} else {
+				utils.Debugf("[BUILDER] Cache miss")
+			}
 		}
-		container, err := b.builder.Create(b.config)
+
+		container, err := b.runtime.Create(b.config)
 		if err != nil {
 			return err
 		}
@@ -429,7 +445,7 @@ func (b *buildFile) commit(id string, autoCmd []string, comment string) error {
 	autoConfig := *b.config
 	autoConfig.Cmd = autoCmd
 	// Commit the container
-	image, err := b.builder.Commit(container, "", "", "", b.maintainer, &autoConfig)
+	image, err := b.runtime.Commit(container, "", "", "", b.maintainer, &autoConfig)
 	if err != nil {
 		return err
 	}
@@ -438,10 +454,12 @@ func (b *buildFile) commit(id string, autoCmd []string, comment string) error {
 	return nil
 }
 
+// Long lines can be split with a backslash
+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("/tmp", "docker-build")
+	name, err := ioutil.TempDir("", "docker-build")
 	if err != nil {
 		return "", err
 	}
@@ -450,22 +468,18 @@ func (b *buildFile) Build(context io.Reader) (string, error) {
 	}
 	defer os.RemoveAll(name)
 	b.context = name
-	dockerfile, err := os.Open(path.Join(name, "Dockerfile"))
-	if err != nil {
+	filename := path.Join(name, "Dockerfile")
+	if _, err := os.Stat(filename); os.IsNotExist(err) {
 		return "", fmt.Errorf("Can't build a directory with no Dockerfile")
 	}
-	// FIXME: "file" is also a terrible variable name ;)
-	file := bufio.NewReader(dockerfile)
+	fileBytes, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return "", err
+	}
+	dockerfile := string(fileBytes)
+	dockerfile = lineContinuation.ReplaceAllString(dockerfile, "")
 	stepN := 0
-	for {
-		line, err := file.ReadString('\n')
-		if err != nil {
-			if err == io.EOF && line == "" {
-				break
-			} else if err != io.EOF {
-				return "", err
-			}
-		}
+	for _, line := range strings.Split(dockerfile, "\n") {
 		line = strings.Trim(strings.Replace(line, "\t", " ", -1), " \t\r\n")
 		// Skip comments and empty line
 		if len(line) == 0 || line[0] == '#' {
@@ -477,15 +491,16 @@ func (b *buildFile) Build(context io.Reader) (string, error) {
 		}
 		instruction := strings.ToLower(strings.Trim(tmp[0], " "))
 		arguments := strings.Trim(tmp[1], " ")
-		stepN += 1
-		// FIXME: only count known instructions as build steps
-		fmt.Fprintf(b.out, "Step %d : %s %s\n", stepN, strings.ToUpper(instruction), arguments)
 
 		method, exists := reflect.TypeOf(b).MethodByName("Cmd" + strings.ToUpper(instruction[:1]) + strings.ToLower(instruction[1:]))
 		if !exists {
 			fmt.Fprintf(b.out, "# Skipping unknown instruction %s\n", strings.ToUpper(instruction))
 			continue
 		}
+
+		stepN += 1
+		fmt.Fprintf(b.out, "Step %d : %s %s\n", stepN, strings.ToUpper(instruction), arguments)
+
 		ret := method.Func.Call([]reflect.Value{reflect.ValueOf(b), reflect.ValueOf(arguments)})[0].Interface()
 		if ret != nil {
 			return "", ret.(error)
@@ -495,14 +510,16 @@ func (b *buildFile) Build(context io.Reader) (string, error) {
 	}
 	if b.image != "" {
 		fmt.Fprintf(b.out, "Successfully built %s\n", utils.TruncateID(b.image))
+		if b.rm {
+			b.clearTmp(b.tmpContainers)
+		}
 		return b.image, nil
 	}
-	return "", fmt.Errorf("An error occured during the build\n")
+	return "", fmt.Errorf("An error occurred during the build\n")
 }
 
-func NewBuildFile(srv *Server, out io.Writer, verbose bool) BuildFile {
+func NewBuildFile(srv *Server, out io.Writer, verbose, utilizeCache, rm bool) BuildFile {
 	return &buildFile{
-		builder:       NewBuilder(srv.runtime),
 		runtime:       srv.runtime,
 		srv:           srv,
 		config:        &Config{},
@@ -510,5 +527,7 @@ func NewBuildFile(srv *Server, out io.Writer, verbose bool) BuildFile {
 		tmpContainers: make(map[string]struct{}),
 		tmpImages:     make(map[string]struct{}),
 		verbose:       verbose,
+		utilizeCache:  utilizeCache,
+		rm:            rm,
 	}
 }

buildfile_test.go

@@ -45,6 +45,34 @@ run    [ "$(ls -d /var/run/sshd)" = "/var/run/sshd" ]
 		nil,
 	},
 
+	// Exactly the same as above, except uses a line split with a \ to test
+	// multiline support.
+	{
+		`
+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,
+	},
+
+	// Line containing literal "\n"
+	{
+		`
+from   {IMAGE}
+run    sh -c 'echo root:testpass > /tmp/passwd'
+run    echo "foo \n bar"; echo "baz"
+run    mkdir -p /var/run/sshd
+run    [ "$(cat /tmp/passwd)" = "root:testpass" ]
+run    [ "$(ls -d /var/run/sshd)" = "/var/run/sshd" ]
+`,
+		nil,
+		nil,
+	},
 	{
 		`
 from {IMAGE}
@@ -195,21 +223,23 @@ func mkTestingFileServer(files [][2]string) (*httptest.Server, error) {
 
 func TestBuild(t *testing.T) {
 	for _, ctx := range testContexts {
-		buildImage(ctx, t)
+		buildImage(ctx, t, nil, true)
 	}
 }
 
-func buildImage(context testContextTemplate, t *testing.T) *Image {
-	runtime, err := newTestRuntime()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer nuke(runtime)
+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 = &Server{
+			runtime:     runtime,
+			pullingPool: make(map[string]struct{}),
+			pushingPool: make(map[string]struct{}),
+		}
 	}
 
 	httpServer, err := mkTestingFileServer(context.remoteFiles)
@@ -224,10 +254,10 @@ func buildImage(context testContextTemplate, t *testing.T) *Image {
 	}
 	port := httpServer.URL[idx+1:]
 
-	ip := runtime.networkManager.bridgeNetwork.IP
+	ip := srv.runtime.networkManager.bridgeNetwork.IP
 	dockerfile := constructDockerfile(context.dockerfile, ip, port)
 
-	buildfile := NewBuildFile(srv, ioutil.Discard, false)
+	buildfile := NewBuildFile(srv, ioutil.Discard, false, useCache, false)
 	id, err := buildfile.Build(mkTestContext(dockerfile, context.files, t))
 	if err != nil {
 		t.Fatal(err)
@@ -245,7 +275,7 @@ func TestVolume(t *testing.T) {
         from {IMAGE}
         volume /test
         cmd Hello world
-    `, nil, nil}, t)
+    `, nil, nil}, t, nil, true)
 
 	if len(img.Config.Volumes) == 0 {
 		t.Fail()
@@ -261,19 +291,30 @@ func TestBuildMaintainer(t *testing.T) {
 	img := buildImage(testContextTemplate{`
         from {IMAGE}
         maintainer dockerio
-    `, nil, nil}, t)
+    `, nil, nil}, t, nil, true)
 
 	if img.Author != "dockerio" {
 		t.Fail()
 	}
 }
 
+func TestBuildUser(t *testing.T) {
+	img := buildImage(testContextTemplate{`
+        from {IMAGE}
+        user dockerio
+    `, nil, nil}, t, nil, true)
+
+	if img.Config.User != "dockerio" {
+		t.Fail()
+	}
+}
+
 func TestBuildEnv(t *testing.T) {
 	img := buildImage(testContextTemplate{`
         from {IMAGE}
         env port 4243
         `,
-		nil, nil}, t)
+		nil, nil}, t, nil, true)
 	hasEnv := false
 	for _, envVar := range img.Config.Env {
 		if envVar == "port=4243" {
@@ -291,7 +332,7 @@ func TestBuildCmd(t *testing.T) {
         from {IMAGE}
         cmd ["/bin/echo", "Hello World"]
         `,
-		nil, nil}, t)
+		nil, nil}, t, nil, true)
 
 	if img.Config.Cmd[0] != "/bin/echo" {
 		t.Log(img.Config.Cmd[0])
@@ -308,7 +349,7 @@ func TestBuildExpose(t *testing.T) {
         from {IMAGE}
         expose 4243
         `,
-		nil, nil}, t)
+		nil, nil}, t, nil, true)
 
 	if img.Config.PortSpecs[0] != "4243" {
 		t.Fail()
@@ -320,8 +361,201 @@ func TestBuildEntrypoint(t *testing.T) {
         from {IMAGE}
         entrypoint ["/bin/echo"]
         `,
-		nil, nil}, t)
+		nil, nil}, t, nil, true)
 
 	if img.Config.Entrypoint[0] != "/bin/echo" {
 	}
 }
+
+// testing #1405 - config.Cmd does not get cleaned up if
+// utilizing cache
+func TestBuildEntrypointRunCleanup(t *testing.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, srv, true)
+
+	img = buildImage(testContextTemplate{`
+        from {IMAGE}
+        run echo "hello"
+        add foo /foo
+        entrypoint ["/bin/echo"]
+        `,
+		[][2]string{{"foo", "HEYO"}}, nil}, t, srv, true)
+
+	if len(img.Config.Cmd) != 0 {
+		t.Fail()
+	}
+}
+
+func TestBuildImageWithCache(t *testing.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}
+        maintainer dockerio
+        `,
+		nil, nil}
+
+	img := buildImage(template, t, srv, true)
+	imageId := img.ID
+
+	img = nil
+	img = buildImage(template, t, srv, true)
+
+	if imageId != img.ID {
+		t.Logf("Image ids should match: %s != %s", imageId, img.ID)
+		t.Fail()
+	}
+}
+
+func TestBuildImageWithoutCache(t *testing.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}
+        maintainer dockerio
+        `,
+		nil, nil}
+
+	img := buildImage(template, t, srv, true)
+	imageId := img.ID
+
+	img = nil
+	img = buildImage(template, t, srv, false)
+
+	if imageId == img.ID {
+		t.Logf("Image ids should not match: %s == %s", imageId, img.ID)
+		t.Fail()
+	}
+}
+
+func TestForbiddenContextPath(t *testing.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}
+        maintainer dockerio
+        add ../../ test/
+        `,
+		[][2]string{{"test.txt", "test1"}, {"other.txt", "other"}}, nil}
+
+	httpServer, err := mkTestingFileServer(context.remoteFiles)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer httpServer.Close()
+
+	idx := strings.LastIndex(httpServer.URL, ":")
+	if idx < 0 {
+		t.Fatalf("could not get port from test http server address %s", httpServer.URL)
+	}
+	port := httpServer.URL[idx+1:]
+
+	ip := srv.runtime.networkManager.bridgeNetwork.IP
+	dockerfile := constructDockerfile(context.dockerfile, ip, port)
+
+	buildfile := NewBuildFile(srv, ioutil.Discard, false, true, false)
+	_, err = buildfile.Build(mkTestContext(dockerfile, context.files, t))
+
+	if err == nil {
+		t.Log("Error should not be nil")
+		t.Fail()
+	}
+
+	if err.Error() != "Forbidden path: /" {
+		t.Logf("Error message is not expected: %s", err.Error())
+		t.Fail()
+	}
+}
+
+func TestBuildADDFileNotFound(t *testing.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}
+        add foo /usr/local/bar
+        `,
+		nil, nil}
+
+	httpServer, err := mkTestingFileServer(context.remoteFiles)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer httpServer.Close()
+
+	idx := strings.LastIndex(httpServer.URL, ":")
+	if idx < 0 {
+		t.Fatalf("could not get port from test http server address %s", httpServer.URL)
+	}
+	port := httpServer.URL[idx+1:]
+
+	ip := srv.runtime.networkManager.bridgeNetwork.IP
+	dockerfile := constructDockerfile(context.dockerfile, ip, port)
+
+	buildfile := NewBuildFile(srv, ioutil.Discard, false, true, false)
+	_, err = buildfile.Build(mkTestContext(dockerfile, context.files, t))
+
+	if err == nil {
+		t.Log("Error should not be nil")
+		t.Fail()
+	}
+
+	if err.Error() != "foo: no such file or directory" {
+		t.Logf("Error message is not expected: %s", err.Error())
+		t.Fail()
+	}
+}

changes.go

@@ -99,7 +99,7 @@ func Changes(layers []string, rw string) ([]Change, error) {
 		changes = append(changes, change)
 		return nil
 	})
-	if err != nil {
+	if err != nil && !os.IsNotExist(err) {
 		return nil, err
 	}
 	return changes, nil

commands.go

@@ -2,11 +2,15 @@ package docker
 
 import (
 	"archive/tar"
+	"bufio"
 	"bytes"
+	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"flag"
 	"fmt"
 	"github.com/dotcloud/docker/auth"
+	"github.com/dotcloud/docker/registry"
 	"github.com/dotcloud/docker/term"
 	"github.com/dotcloud/docker/utils"
 	"io"
@@ -19,18 +23,22 @@ import (
 	"os/signal"
 	"path/filepath"
 	"reflect"
+	"runtime"
+	"sort"
 	"strconv"
 	"strings"
 	"syscall"
 	"text/tabwriter"
 	"time"
-	"unicode"
 )
 
-const VERSION = "0.5.1"
-
 var (
 	GITCOMMIT string
+	VERSION   string
+)
+
+var (
+	ErrConnectionRefused = errors.New("Can't connect to docker daemon. Is 'docker -d' running on this host?")
 )
 
 func (cli *DockerCli) getMethod(name string) (reflect.Method, bool) {
@@ -72,11 +80,12 @@ func (cli *DockerCli) CmdHelp(args ...string) error {
 			return nil
 		}
 	}
-	help := fmt.Sprintf("Usage: docker [OPTIONS] COMMAND [arg...]\n  -H=[tcp://%s:%d]: tcp://host:port to bind/connect to or unix://path/to/socket to use\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n", DEFAULTHTTPHOST, DEFAULTHTTPPORT)
+	help := fmt.Sprintf("Usage: docker [OPTIONS] COMMAND [arg...]\n -H=[unix://%s]: tcp://host:port to bind/connect to or unix://path/to/socket to use\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n", DEFAULTUNIXSOCKET)
 	for _, command := range [][]string{
 		{"attach", "Attach to a running container"},
 		{"build", "Build a container from a Dockerfile"},
 		{"commit", "Create a new image from a container's changes"},
+		{"cp", "Copy files/folders from the containers filesystem to the host path"},
 		{"diff", "Inspect changes on a container's filesystem"},
 		{"events", "Get real time events from the server"},
 		{"export", "Stream the contents of a container as a tar archive"},
@@ -125,7 +134,7 @@ func (cli *DockerCli) CmdInsert(args ...string) error {
 	v.Set("url", cmd.Arg(1))
 	v.Set("path", cmd.Arg(2))
 
-	if err := cli.stream("POST", "/images/"+cmd.Arg(0)+"/insert?"+v.Encode(), nil, cli.out); err != nil {
+	if err := cli.stream("POST", "/images/"+cmd.Arg(0)+"/insert?"+v.Encode(), nil, cli.out, nil); err != nil {
 		return err
 	}
 	return nil
@@ -158,9 +167,10 @@ func mkBuildContext(dockerfile string, files [][2]string) (Archive, error) {
 
 func (cli *DockerCli) CmdBuild(args ...string) error {
 	cmd := Subcmd("build", "[OPTIONS] PATH | URL | -", "Build a new container image from the source code at PATH")
-	tag := cmd.String("t", "", "Tag to be applied to the resulting image in case of success")
+	tag := cmd.String("t", "", "Repository name (and optionally a tag) to be applied to the resulting image in case of success")
 	suppressOutput := cmd.Bool("q", false, "Suppress verbose build output")
-
+	noCache := cmd.Bool("no-cache", false, "Do not use cache when building the image")
+	rm := cmd.Bool("rm", false, "Remove intermediate containers after a successful build")
 	if err := cmd.Parse(args); err != nil {
 		return nil
 	}
@@ -193,10 +203,10 @@ func (cli *DockerCli) CmdBuild(args ...string) error {
 	}
 	var body io.Reader
 	// Setup an upload progress bar
-	// FIXME: ProgressReader shouldn't be this annoyning to use
+	// FIXME: ProgressReader shouldn't be this annoying to use
 	if context != nil {
 		sf := utils.NewStreamFormatter(false)
-		body = utils.ProgressReader(ioutil.NopCloser(context), 0, cli.err, sf.FormatProgress("Uploading context", "%v bytes%0.0s%0.0s"), sf)
+		body = utils.ProgressReader(ioutil.NopCloser(context), 0, cli.err, sf.FormatProgress("", "Uploading context", "%v bytes%0.0s%0.0s"), sf, true)
 	}
 	// Upload the build context
 	v := &url.Values{}
@@ -208,6 +218,12 @@ func (cli *DockerCli) CmdBuild(args ...string) error {
 	if isRemote {
 		v.Set("remote", cmd.Arg(0))
 	}
+	if *noCache {
+		v.Set("nocache", "1")
+	}
+	if *rm {
+		v.Set("rm", "1")
+	}
 	req, err := http.NewRequest("POST", fmt.Sprintf("/v%g/build?%s", APIVERSION, v.Encode()), body)
 	if err != nil {
 		return err
@@ -248,73 +264,27 @@ func (cli *DockerCli) CmdBuild(args ...string) error {
 
 // 'docker login': login / register a user to registry service.
 func (cli *DockerCli) CmdLogin(args ...string) error {
-	var readStringOnRawTerminal = func(stdin io.Reader, stdout io.Writer, echo bool) string {
-		char := make([]byte, 1)
-		buffer := make([]byte, 64)
-		var i = 0
-		for i < len(buffer) {
-			n, err := stdin.Read(char)
-			if n > 0 {
-				if char[0] == '\r' || char[0] == '\n' {
-					stdout.Write([]byte{'\r', '\n'})
-					break
-				} else if char[0] == 127 || char[0] == '\b' {
-					if i > 0 {
-						if echo {
-							stdout.Write([]byte{'\b', ' ', '\b'})
-						}
-						i--
-					}
-				} else if !unicode.IsSpace(rune(char[0])) &&
-					!unicode.IsControl(rune(char[0])) {
-					if echo {
-						stdout.Write(char)
-					}
-					buffer[i] = char[0]
-					i++
-				}
-			}
-			if err != nil {
-				if err != io.EOF {
-					fmt.Fprintf(stdout, "Read error: %v\r\n", err)
-				}
-				break
-			}
-		}
-		return string(buffer[:i])
-	}
-	var readAndEchoString = func(stdin io.Reader, stdout io.Writer) string {
-		return readStringOnRawTerminal(stdin, stdout, true)
-	}
-	var readString = func(stdin io.Reader, stdout io.Writer) string {
-		return readStringOnRawTerminal(stdin, stdout, false)
-	}
+	cmd := Subcmd("login", "[OPTIONS] [SERVER]", "Register or Login to a docker registry server, if no server is specified \""+auth.IndexServerAddress()+"\" is the default.")
 
-	cmd := Subcmd("login", "[OPTIONS]", "Register or Login to the docker registry server")
-	flUsername := cmd.String("u", "", "username")
-	flPassword := cmd.String("p", "", "password")
-	flEmail := cmd.String("e", "", "email")
+	var username, password, email string
+
+	cmd.StringVar(&username, "u", "", "username")
+	cmd.StringVar(&password, "p", "", "password")
+	cmd.StringVar(&email, "e", "", "email")
 	err := cmd.Parse(args)
 	if err != nil {
 		return nil
 	}
-
-	var oldState *term.State
-	if *flUsername == "" || *flPassword == "" || *flEmail == "" {
-		oldState, err = term.SetRawTerminal(cli.terminalFd)
+	serverAddress := auth.IndexServerAddress()
+	if len(cmd.Args()) > 0 {
+		serverAddress, err = registry.ExpandAndVerifyRegistryUrl(cmd.Arg(0))
 		if err != nil {
 			return err
 		}
-		defer term.RestoreTerminal(cli.terminalFd, oldState)
+		fmt.Fprintf(cli.out, "Login against server at %s\n", serverAddress)
 	}
 
-	var (
-		username string
-		password string
-		email    string
-	)
-
-	var promptDefault = func(prompt string, configDefault string) {
+	promptDefault := func(prompt string, configDefault string) {
 		if configDefault == "" {
 			fmt.Fprintf(cli.out, "%s: ", prompt)
 		} else {
@@ -322,55 +292,64 @@ func (cli *DockerCli) CmdLogin(args ...string) error {
 		}
 	}
 
-	authconfig, ok := cli.configFile.Configs[auth.IndexServerAddress()]
+	readInput := func(in io.Reader, out io.Writer) string {
+		reader := bufio.NewReader(in)
+		line, _, err := reader.ReadLine()
+		if err != nil {
+			fmt.Fprintln(out, err.Error())
+			os.Exit(1)
+		}
+		return string(line)
+	}
+
+	cli.LoadConfigFile()
+	authconfig, ok := cli.configFile.Configs[serverAddress]
 	if !ok {
 		authconfig = auth.AuthConfig{}
 	}
 
-	if *flUsername == "" {
+	if username == "" {
 		promptDefault("Username", authconfig.Username)
-		username = readAndEchoString(cli.in, cli.out)
+		username = readInput(cli.in, cli.out)
 		if username == "" {
 			username = authconfig.Username
 		}
-	} else {
-		username = *flUsername
 	}
 	if username != authconfig.Username {
-		if *flPassword == "" {
+		if password == "" {
+			oldState, _ := term.SaveState(cli.terminalFd)
 			fmt.Fprintf(cli.out, "Password: ")
-			password = readString(cli.in, cli.out)
+			term.DisableEcho(cli.terminalFd, oldState)
+
+			password = readInput(cli.in, cli.out)
+			fmt.Fprint(cli.out, "\n")
+
+			term.RestoreTerminal(cli.terminalFd, oldState)
 			if password == "" {
 				return fmt.Errorf("Error : Password Required")
 			}
-		} else {
-			password = *flPassword
 		}
 
-		if *flEmail == "" {
+		if email == "" {
 			promptDefault("Email", authconfig.Email)
-			email = readAndEchoString(cli.in, cli.out)
+			email = readInput(cli.in, cli.out)
 			if email == "" {
 				email = authconfig.Email
 			}
-		} else {
-			email = *flEmail
 		}
 	} else {
 		password = authconfig.Password
 		email = authconfig.Email
 	}
-	if oldState != nil {
-		term.RestoreTerminal(cli.terminalFd, oldState)
-	}
 	authconfig.Username = username
 	authconfig.Password = password
 	authconfig.Email = email
-	cli.configFile.Configs[auth.IndexServerAddress()] = authconfig
+	authconfig.ServerAddress = serverAddress
+	cli.configFile.Configs[serverAddress] = authconfig
 
-	body, statusCode, err := cli.call("POST", "/auth", cli.configFile.Configs[auth.IndexServerAddress()])
+	body, statusCode, err := cli.call("POST", "/auth", cli.configFile.Configs[serverAddress])
 	if statusCode == 401 {
-		delete(cli.configFile.Configs, auth.IndexServerAddress())
+		delete(cli.configFile.Configs, serverAddress)
 		auth.SaveConfig(cli.configFile)
 		return err
 	}
@@ -402,16 +381,11 @@ func (cli *DockerCli) CmdWait(args ...string) error {
 		return nil
 	}
 	for _, name := range cmd.Args() {
-		body, _, err := cli.call("POST", "/containers/"+name+"/wait", nil)
+		status, err := waitForExit(cli, name)
 		if err != nil {
 			fmt.Fprintf(cli.err, "%s", err)
 		} else {
-			var out APIWait
-			err = json.Unmarshal(body, &out)
-			if err != nil {
-				return err
-			}
-			fmt.Fprintf(cli.out, "%d\n", out.StatusCode)
+			fmt.Fprintf(cli.out, "%d\n", status)
 		}
 	}
 	return nil
@@ -428,6 +402,13 @@ func (cli *DockerCli) CmdVersion(args ...string) error {
 		cmd.Usage()
 		return nil
 	}
+	if VERSION != "" {
+		fmt.Fprintf(cli.out, "Client version: %s\n", VERSION)
+	}
+	fmt.Fprintf(cli.out, "Go version (client): %s\n", runtime.Version())
+	if GITCOMMIT != "" {
+		fmt.Fprintf(cli.out, "Git commit (client): %s\n", GITCOMMIT)
+	}
 
 	body, _, err := cli.call("GET", "/version", nil)
 	if err != nil {
@@ -437,16 +418,26 @@ func (cli *DockerCli) CmdVersion(args ...string) error {
 	var out APIVersion
 	err = json.Unmarshal(body, &out)
 	if err != nil {
-		utils.Debugf("Error unmarshal: body: %s, err: %s\n", body, err)
+		utils.Errorf("Error unmarshal: body: %s, err: %s\n", body, err)
 		return err
 	}
-	fmt.Fprintf(cli.out, "Client version: %s\n", VERSION)
-	fmt.Fprintf(cli.out, "Server version: %s\n", out.Version)
+	if out.Version != "" {
+		fmt.Fprintf(cli.out, "Server version: %s\n", out.Version)
+	}
 	if out.GitCommit != "" {
-		fmt.Fprintf(cli.out, "Git commit: %s\n", out.GitCommit)
+		fmt.Fprintf(cli.out, "Git commit (server): %s\n", out.GitCommit)
 	}
 	if out.GoVersion != "" {
-		fmt.Fprintf(cli.out, "Go version: %s\n", out.GoVersion)
+		fmt.Fprintf(cli.out, "Go version (server): %s\n", out.GoVersion)
+	}
+
+	release := utils.GetReleaseVersion()
+	if release != "" {
+		fmt.Fprintf(cli.out, "Last stable version: %s", release)
+		if (VERSION != "" || out.Version != "") && (strings.Trim(VERSION, "-dev") != release || strings.Trim(out.Version, "-dev") != release) {
+			fmt.Fprintf(cli.out, ", please update docker")
+		}
+		fmt.Fprintf(cli.out, "\n")
 	}
 	return nil
 }
@@ -483,12 +474,24 @@ func (cli *DockerCli) CmdInfo(args ...string) error {
 		fmt.Fprintf(cli.out, "EventsListeners: %d\n", out.NEventsListener)
 		fmt.Fprintf(cli.out, "Kernel Version: %s\n", out.KernelVersion)
 	}
+
+	if len(out.IndexServerAddress) != 0 {
+		cli.LoadConfigFile()
+		u := cli.configFile.Configs[out.IndexServerAddress].Username
+		if len(u) > 0 {
+			fmt.Fprintf(cli.out, "Username: %v\n", u)
+			fmt.Fprintf(cli.out, "Registry: %v\n", out.IndexServerAddress)
+		}
+	}
 	if !out.MemoryLimit {
 		fmt.Fprintf(cli.err, "WARNING: No memory limit support\n")
 	}
 	if !out.SwapLimit {
 		fmt.Fprintf(cli.err, "WARNING: No swap limit support\n")
 	}
+	if !out.IPv4Forwarding {
+		fmt.Fprintf(cli.err, "WARNING: IPv4 forwarding is disabled.\n")
+	}
 	return nil
 }
 
@@ -552,15 +555,17 @@ func (cli *DockerCli) CmdStart(args ...string) error {
 		return nil
 	}
 
+	var encounteredError error
 	for _, name := range args {
 		_, _, err := cli.call("POST", "/containers/"+name+"/start", nil)
 		if err != nil {
 			fmt.Fprintf(cli.err, "%s\n", err)
+			encounteredError = fmt.Errorf("Error: failed to start one or more containers")
 		} else {
 			fmt.Fprintf(cli.out, "%s\n", name)
 		}
 	}
-	return nil
+	return encounteredError
 }
 
 func (cli *DockerCli) CmdInspect(args ...string) error {
@@ -581,7 +586,7 @@ func (cli *DockerCli) CmdInspect(args ...string) error {
 		if err != nil {
 			obj, _, err = cli.call("GET", "/images/"+name+"/json", nil)
 			if err != nil {
-				fmt.Fprintf(cli.err, "%s\n", err)
+				fmt.Fprintf(cli.err, "No such image or container: %s\n", name)
 				continue
 			}
 		}
@@ -795,11 +800,13 @@ func (cli *DockerCli) CmdImport(args ...string) error {
 	v.Set("tag", tag)
 	v.Set("fromSrc", src)
 
-	err := cli.stream("POST", "/images/create?"+v.Encode(), cli.in, cli.out)
-	if err != nil {
-		return err
+	var in io.Reader
+
+	if src == "-" {
+		in = cli.in
 	}
-	return nil
+
+	return cli.stream("POST", "/images/create?"+v.Encode(), in, cli.out, nil)
 }
 
 func (cli *DockerCli) CmdPush(args ...string) error {
@@ -814,25 +821,51 @@ func (cli *DockerCli) CmdPush(args ...string) error {
 		return nil
 	}
 
-	if err := cli.checkIfLogged("push"); err != nil {
+	cli.LoadConfigFile()
+
+	// Resolve the Repository name from fqn to endpoint + name
+	endpoint, _, err := registry.ResolveRepositoryName(name)
+	if err != nil {
 		return err
 	}
-
+	// Resolve the Auth config relevant for this server
+	authConfig := cli.configFile.ResolveAuthConfig(endpoint)
 	// If we're not using a custom registry, we know the restrictions
 	// applied to repository names and can warn the user in advance.
 	// Custom repositories can have different rules, and we must also
 	// allow pushing by image ID.
 	if len(strings.SplitN(name, "/", 2)) == 1 {
-		return fmt.Errorf("Impossible to push a \"root\" repository. Please rename your repository in <user>/<repo> (ex: %s/%s)", cli.configFile.Configs[auth.IndexServerAddress()].Username, name)
-	}
-
-	buf, err := json.Marshal(cli.configFile.Configs[auth.IndexServerAddress()])
-	if err != nil {
-		return err
+		username := cli.configFile.Configs[auth.IndexServerAddress()].Username
+		if username == "" {
+			username = "<user>"
+		}
+		return fmt.Errorf("Impossible to push a \"root\" repository. Please rename your repository in <user>/<repo> (ex: %s/%s)", username, name)
 	}
 
 	v := url.Values{}
-	if err := cli.stream("POST", "/images/"+name+"/push?"+v.Encode(), bytes.NewBuffer(buf), cli.out); err != nil {
+	push := func(authConfig auth.AuthConfig) error {
+		buf, err := json.Marshal(authConfig)
+		if err != nil {
+			return err
+		}
+		registryAuthHeader := []string{
+			base64.URLEncoding.EncodeToString(buf),
+		}
+
+		return cli.stream("POST", "/images/"+name+"/push?"+v.Encode(), nil, cli.out, map[string][]string{
+			"X-Registry-Auth": registryAuthHeader,
+		})
+	}
+
+	if err := push(authConfig); err != nil {
+		if err.Error() == registry.ErrLoginRequired.Error() {
+			fmt.Fprintln(cli.out, "\nPlease login prior to push:")
+			if err := cli.CmdLogin(endpoint); err != nil {
+				return err
+			}
+			authConfig := cli.configFile.ResolveAuthConfig(endpoint)
+			return push(authConfig)
+		}
 		return err
 	}
 	return nil
@@ -855,11 +888,43 @@ func (cli *DockerCli) CmdPull(args ...string) error {
 		*tag = parsedTag
 	}
 
+	// Resolve the Repository name from fqn to endpoint + name
+	endpoint, _, err := registry.ResolveRepositoryName(remote)
+	if err != nil {
+		return err
+	}
+
+	cli.LoadConfigFile()
+
+	// Resolve the Auth config relevant for this server
+	authConfig := cli.configFile.ResolveAuthConfig(endpoint)
 	v := url.Values{}
 	v.Set("fromImage", remote)
 	v.Set("tag", *tag)
 
-	if err := cli.stream("POST", "/images/create?"+v.Encode(), nil, cli.out); err != nil {
+	pull := func(authConfig auth.AuthConfig) error {
+		buf, err := json.Marshal(authConfig)
+		if err != nil {
+			return err
+		}
+		registryAuthHeader := []string{
+			base64.URLEncoding.EncodeToString(buf),
+		}
+
+		return cli.stream("POST", "/images/create?"+v.Encode(), nil, cli.out, map[string][]string{
+			"X-Registry-Auth": registryAuthHeader,
+		})
+	}
+
+	if err := pull(authConfig); err != nil {
+		if err.Error() == registry.ErrLoginRequired.Error() {
+			fmt.Fprintln(cli.out, "\nPlease login prior to push:")
+			if err := cli.CmdLogin(endpoint); err != nil {
+				return err
+			}
+			authConfig := cli.configFile.ResolveAuthConfig(endpoint)
+			return pull(authConfig)
+		}
 		return err
 	}
 
@@ -949,6 +1014,19 @@ func (cli *DockerCli) CmdImages(args ...string) error {
 	return nil
 }
 
+func displayablePorts(ports []APIPort) string {
+	result := []string{}
+	for _, port := range ports {
+		if port.Type == "tcp" {
+			result = append(result, fmt.Sprintf("%d->%d", port.PublicPort, port.PrivatePort))
+		} else {
+			result = append(result, fmt.Sprintf("%d->%d/%s", port.PublicPort, port.PrivatePort, port.Type))
+		}
+	}
+	sort.Strings(result)
+	return strings.Join(result, ", ")
+}
+
 func (cli *DockerCli) CmdPs(args ...string) error {
 	cmd := Subcmd("ps", "[OPTIONS]", "List containers")
 	quiet := cmd.Bool("q", false, "Only display numeric IDs")
@@ -1006,9 +1084,9 @@ func (cli *DockerCli) CmdPs(args ...string) error {
 	for _, out := range outs {
 		if !*quiet {
 			if *noTrunc {
-				fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t%s\t%s\t", out.ID, out.Image, out.Command, utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0))), out.Status, out.Ports)
+				fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t%s\t%s\t", out.ID, out.Image, out.Command, utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0))), out.Status, displayablePorts(out.Ports))
 			} else {
-				fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t%s\t%s\t", utils.TruncateID(out.ID), out.Image, utils.Trunc(out.Command, 20), utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0))), out.Status, out.Ports)
+				fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t%s\t%s\t", utils.TruncateID(out.ID), out.Image, utils.Trunc(out.Command, 20), utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0))), out.Status, displayablePorts(out.Ports))
 			}
 			if *size {
 				if out.SizeRootFs > 0 {
@@ -1093,7 +1171,7 @@ func (cli *DockerCli) CmdEvents(args ...string) error {
 		v.Set("since", *since)
 	}
 
-	if err := cli.stream("GET", "/events?"+v.Encode(), nil, cli.out); err != nil {
+	if err := cli.stream("GET", "/events?"+v.Encode(), nil, cli.out, nil); err != nil {
 		return err
 	}
 	return nil
@@ -1110,7 +1188,7 @@ func (cli *DockerCli) CmdExport(args ...string) error {
 		return nil
 	}
 
-	if err := cli.stream("GET", "/containers/"+cmd.Arg(0)+"/export", nil, cli.out); err != nil {
+	if err := cli.stream("GET", "/containers/"+cmd.Arg(0)+"/export", nil, cli.out, nil); err != nil {
 		return err
 	}
 	return nil
@@ -1152,7 +1230,7 @@ func (cli *DockerCli) CmdLogs(args ...string) error {
 		return nil
 	}
 
-	if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?logs=1&stdout=1&stderr=1", false, nil, cli.out); err != nil {
+	if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?logs=1&stdout=1&stderr=1", false, nil, cli.out, cli.err); err != nil {
 		return err
 	}
 	return nil
@@ -1185,7 +1263,7 @@ func (cli *DockerCli) CmdAttach(args ...string) error {
 
 	if container.Config.Tty {
 		if err := cli.monitorTtySize(cmd.Arg(0)); err != nil {
-			return err
+			utils.Debugf("Error monitoring tty size: %s", err)
 		}
 	}
 
@@ -1195,7 +1273,7 @@ func (cli *DockerCli) CmdAttach(args ...string) error {
 	v.Set("stdout", "1")
 	v.Set("stderr", "1")
 
-	if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), container.Config.Tty, cli.in, cli.out); err != nil {
+	if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), container.Config.Tty, cli.in, cli.out, cli.err); err != nil {
 		return err
 	}
 	return nil
@@ -1355,6 +1433,9 @@ func (cli *DockerCli) CmdRun(args ...string) error {
 		return nil
 	}
 
+	flRm := cmd.Lookup("rm")
+	autoRemove, _ := strconv.ParseBool(flRm.Value.String())
+
 	var containerIDFile *os.File
 	if len(hostConfig.ContainerIDFile) > 0 {
 		if _, err := ioutil.ReadFile(hostConfig.ContainerIDFile); err == nil {
@@ -1371,11 +1452,41 @@ func (cli *DockerCli) CmdRun(args ...string) error {
 	body, statusCode, err := cli.call("POST", "/containers/create", config)
 	//if image not found try to pull it
 	if statusCode == 404 {
+		_, tag := utils.ParseRepositoryTag(config.Image)
+		if tag == "" {
+			tag = DEFAULTTAG
+		}
+
+		fmt.Fprintf(cli.err, "Unable to find image '%s' (tag: %s) locally\n", config.Image, tag)
+
 		v := url.Values{}
 		repos, tag := utils.ParseRepositoryTag(config.Image)
 		v.Set("fromImage", repos)
 		v.Set("tag", tag)
-		err = cli.stream("POST", "/images/create?"+v.Encode(), nil, cli.err)
+
+		// Resolve the Repository name from fqn to endpoint + name
+		var endpoint string
+		endpoint, _, err = registry.ResolveRepositoryName(repos)
+		if err != nil {
+			return err
+		}
+
+		// Load the auth config file, to be able to pull the image
+		cli.LoadConfigFile()
+
+		// Resolve the Auth config relevant for this server
+		authConfig := cli.configFile.ResolveAuthConfig(endpoint)
+		buf, err := json.Marshal(authConfig)
+		if err != nil {
+			return err
+		}
+
+		registryAuthHeader := []string{
+			base64.URLEncoding.EncodeToString(buf),
+		}
+		err = cli.stream("POST", "/images/create?"+v.Encode(), nil, cli.err, map[string][]string{
+			"X-Registry-Auth": registryAuthHeader,
+		})
 		if err != nil {
 			return err
 		}
@@ -1422,45 +1533,101 @@ func (cli *DockerCli) CmdRun(args ...string) error {
 	if config.AttachStdin || config.AttachStdout || config.AttachStderr {
 		if config.Tty {
 			if err := cli.monitorTtySize(runResult.ID); err != nil {
-				utils.Debugf("Error monitoring TTY size: %s\n", err)
+				utils.Errorf("Error monitoring TTY size: %s\n", err)
 			}
 		}
 
 		v := url.Values{}
 		v.Set("logs", "1")
 		v.Set("stream", "1")
+		var out, stderr io.Writer
 
 		if config.AttachStdin {
 			v.Set("stdin", "1")
 		}
 		if config.AttachStdout {
 			v.Set("stdout", "1")
+			out = cli.out
 		}
 		if config.AttachStderr {
 			v.Set("stderr", "1")
+			if config.Tty {
+				stderr = cli.out
+			} else {
+				stderr = cli.err
+			}
 		}
 
-		if err := cli.hijack("POST", "/containers/"+runResult.ID+"/attach?"+v.Encode(), config.Tty, cli.in, cli.out); err != nil {
+		signals := make(chan os.Signal, 1)
+		signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
+		go func() {
+			for sig := range signals {
+				fmt.Printf("\nReceived signal: %s; cleaning up\n", sig)
+				if err := cli.CmdStop("-t", "4", runResult.ID); err != nil {
+					fmt.Printf("failed to stop container: %v", err)
+				}
+			}
+		}()
+
+		if err := cli.hijack("POST", "/containers/"+runResult.ID+"/attach?"+v.Encode(), config.Tty, cli.in, out, stderr); err != nil {
 			utils.Debugf("Error hijack: %s", err)
 			return err
 		}
 	}
 
 	if !config.AttachStdout && !config.AttachStderr {
+		// Detached mode
 		<-wait
+	} else {
+		status, err := getExitCode(cli, runResult.ID)
+		if err != nil {
+			return err
+		}
+		if autoRemove {
+			_, _, err = cli.call("DELETE", "/containers/"+runResult.ID, nil)
+			if err != nil {
+				return err
+			}
+		}
+		if status != 0 {
+			return &utils.StatusError{Status: status}
+		}
 	}
+
 	return nil
 }
 
-func (cli *DockerCli) checkIfLogged(action string) error {
-	// If condition AND the login failed
-	if cli.configFile.Configs[auth.IndexServerAddress()].Username == "" {
-		if err := cli.CmdLogin(""); err != nil {
+func (cli *DockerCli) CmdCp(args ...string) error {
+	cmd := Subcmd("cp", "CONTAINER:RESOURCE HOSTPATH", "Copy files/folders from the RESOURCE to the HOSTPATH")
+	if err := cmd.Parse(args); err != nil {
+		return nil
+	}
+
+	if cmd.NArg() != 2 {
+		cmd.Usage()
+		return nil
+	}
+
+	var copyData APICopy
+	info := strings.Split(cmd.Arg(0), ":")
+
+	if len(info) != 2 {
+		return fmt.Errorf("Error: Resource not specified")
+	}
+
+	copyData.Resource = info[1]
+	copyData.HostPath = cmd.Arg(1)
+
+	data, statusCode, err := cli.call("POST", "/containers/"+info[0]+"/copy", copyData)
+	if err != nil {
+		return err
+	}
+
+	if statusCode == 200 {
+		r := bytes.NewReader(data)
+		if err := Untar(r, copyData.HostPath); err != nil {
 			return err
 		}
-		if cli.configFile.Configs[auth.IndexServerAddress()].Username == "" {
-			return fmt.Errorf("Please login prior to %s. ('docker login')", action)
-		}
 	}
 	return nil
 }
@@ -1480,6 +1647,7 @@ func (cli *DockerCli) call(method, path string, data interface{}) ([]byte, int,
 		return nil, -1, err
 	}
 	req.Header.Set("User-Agent", "Docker-Client/"+VERSION)
+	req.Host = cli.addr
 	if data != nil {
 		req.Header.Set("Content-Type", "application/json")
 	} else if method == "POST" {
@@ -1487,6 +1655,9 @@ func (cli *DockerCli) call(method, path string, data interface{}) ([]byte, int,
 	}
 	dial, err := net.Dial(cli.proto, cli.addr)
 	if err != nil {
+		if strings.Contains(err.Error(), "connection refused") {
+			return nil, -1, ErrConnectionRefused
+		}
 		return nil, -1, err
 	}
 	clientconn := httputil.NewClientConn(dial, nil)
@@ -1494,7 +1665,7 @@ func (cli *DockerCli) call(method, path string, data interface{}) ([]byte, int,
 	defer clientconn.Close()
 	if err != nil {
 		if strings.Contains(err.Error(), "connection refused") {
-			return nil, -1, fmt.Errorf("Can't connect to docker daemon. Is 'docker -d' running on this host?")
+			return nil, -1, ErrConnectionRefused
 		}
 		return nil, -1, err
 	}
@@ -1512,7 +1683,7 @@ func (cli *DockerCli) call(method, path string, data interface{}) ([]byte, int,
 	return body, resp.StatusCode, nil
 }
 
-func (cli *DockerCli) stream(method, path string, in io.Reader, out io.Writer) error {
+func (cli *DockerCli) stream(method, path string, in io.Reader, out io.Writer, headers map[string][]string) error {
 	if (method == "POST" || method == "PUT") && in == nil {
 		in = bytes.NewReader([]byte{})
 	}
@@ -1521,11 +1692,22 @@ func (cli *DockerCli) stream(method, path string, in io.Reader, out io.Writer) e
 		return err
 	}
 	req.Header.Set("User-Agent", "Docker-Client/"+VERSION)
+	req.Host = cli.addr
 	if method == "POST" {
 		req.Header.Set("Content-Type", "plain/text")
 	}
+
+	if headers != nil {
+		for k, v := range headers {
+			req.Header[k] = v
+		}
+	}
+
 	dial, err := net.Dial(cli.proto, cli.addr)
 	if err != nil {
+		if strings.Contains(err.Error(), "connection refused") {
+			return fmt.Errorf("Can't connect to docker daemon. Is 'docker -d' running on this host?")
+		}
 		return err
 	}
 	clientconn := httputil.NewClientConn(dial, nil)
@@ -1550,17 +1732,8 @@ func (cli *DockerCli) stream(method, path string, in io.Reader, out io.Writer) e
 		return fmt.Errorf("Error: %s", body)
 	}
 
-	if resp.Header.Get("Content-Type") == "application/json" {
-		dec := json.NewDecoder(resp.Body)
-		for {
-			var jm utils.JSONMessage
-			if err := dec.Decode(&jm); err == io.EOF {
-				break
-			} else if err != nil {
-				return err
-			}
-			jm.Display(out)
-		}
+	if matchesContentType(resp.Header.Get("Content-Type"), "application/json") {
+		return utils.DisplayJSONMessagesStream(resp.Body, out)
 	} else {
 		if _, err := io.Copy(out, resp.Body); err != nil {
 			return err
@@ -1569,7 +1742,7 @@ func (cli *DockerCli) stream(method, path string, in io.Reader, out io.Writer) e
 	return nil
 }
 
-func (cli *DockerCli) hijack(method, path string, setRawTerminal bool, in io.ReadCloser, out io.Writer) error {
+func (cli *DockerCli) hijack(method, path string, setRawTerminal bool, in io.ReadCloser, stdout, stderr io.Writer) error {
 
 	req, err := http.NewRequest(method, fmt.Sprintf("/v%g%s", APIVERSION, path), nil)
 	if err != nil {
@@ -1577,9 +1750,13 @@ func (cli *DockerCli) hijack(method, path string, setRawTerminal bool, in io.Rea
 	}
 	req.Header.Set("User-Agent", "Docker-Client/"+VERSION)
 	req.Header.Set("Content-Type", "plain/text")
+	req.Host = cli.addr
 
 	dial, err := net.Dial(cli.proto, cli.addr)
 	if err != nil {
+		if strings.Contains(err.Error(), "connection refused") {
+			return fmt.Errorf("Can't connect to docker daemon. Is 'docker -d' running on this host?")
+		}
 		return err
 	}
 	clientconn := httputil.NewClientConn(dial, nil)
@@ -1591,11 +1768,20 @@ func (cli *DockerCli) hijack(method, path string, setRawTerminal bool, in io.Rea
 	rwc, br := clientconn.Hijack()
 	defer rwc.Close()
 
-	receiveStdout := utils.Go(func() error {
-		_, err := io.Copy(out, br)
-		utils.Debugf("[hijack] End of stdout")
-		return err
-	})
+	var receiveStdout chan error
+
+	if stdout != nil {
+		receiveStdout = utils.Go(func() (err error) {
+			// When TTY is ON, use regular copy
+			if setRawTerminal {
+				_, err = io.Copy(stdout, br)
+			} else {
+				_, err = utils.StdCopy(stdout, stderr, br)
+			}
+			utils.Debugf("[hijack] End of stdout")
+			return err
+		})
+	}
 
 	if in != nil && setRawTerminal && cli.isTerminal && os.Getenv("NORAW") == "" {
 		oldState, err := term.SetRawTerminal(cli.terminalFd)
@@ -1612,25 +1798,27 @@ func (cli *DockerCli) hijack(method, path string, setRawTerminal bool, in io.Rea
 		}
 		if tcpc, ok := rwc.(*net.TCPConn); ok {
 			if err := tcpc.CloseWrite(); err != nil {
-				utils.Debugf("Couldn't send EOF: %s\n", err)
+				utils.Errorf("Couldn't send EOF: %s\n", err)
 			}
 		} else if unixc, ok := rwc.(*net.UnixConn); ok {
 			if err := unixc.CloseWrite(); err != nil {
-				utils.Debugf("Couldn't send EOF: %s\n", err)
+				utils.Errorf("Couldn't send EOF: %s\n", err)
 			}
 		}
 		// Discard errors due to pipe interruption
 		return nil
 	})
 
-	if err := <-receiveStdout; err != nil {
-		utils.Debugf("Error receiveStdout: %s", err)
-		return err
+	if stdout != nil {
+		if err := <-receiveStdout; err != nil {
+			utils.Errorf("Error receiveStdout: %s", err)
+			return err
+		}
 	}
 
 	if !cli.isTerminal {
 		if err := <-sendStdin; err != nil {
-			utils.Debugf("Error sendStdin: %s", err)
+			utils.Errorf("Error sendStdin: %s", err)
 			return err
 		}
 	}
@@ -1644,7 +1832,7 @@ func (cli *DockerCli) getTtySize() (int, int) {
 	}
 	ws, err := term.GetWinsize(cli.terminalFd)
 	if err != nil {
-		utils.Debugf("Error getting size: %s", err)
+		utils.Errorf("Error getting size: %s", err)
 		if ws == nil {
 			return 0, 0
 		}
@@ -1661,7 +1849,7 @@ func (cli *DockerCli) resizeTty(id string) {
 	v.Set("h", strconv.Itoa(height))
 	v.Set("w", strconv.Itoa(width))
 	if _, _, err := cli.call("POST", "/containers/"+id+"/resize?"+v.Encode(), nil); err != nil {
-		utils.Debugf("Error resize: %s", err)
+		utils.Errorf("Error resize: %s", err)
 	}
 }
 
@@ -1674,8 +1862,7 @@ func (cli *DockerCli) monitorTtySize(id string) error {
 	sigchan := make(chan os.Signal, 1)
 	signal.Notify(sigchan, syscall.SIGWINCH)
 	go func() {
-		for {
-			<-sigchan
+		for _ = range sigchan {
 			cli.resizeTty(id)
 		}
 	}()
@@ -1692,6 +1879,47 @@ func Subcmd(name, signature, description string) *flag.FlagSet {
 	return flags
 }
 
+func (cli *DockerCli) LoadConfigFile() (err error) {
+	cli.configFile, err = auth.LoadConfig(os.Getenv("HOME"))
+	if err != nil {
+		fmt.Fprintf(cli.err, "WARNING: %s\n", err)
+	}
+	return err
+}
+
+func waitForExit(cli *DockerCli, containerId string) (int, error) {
+	body, _, err := cli.call("POST", "/containers/"+containerId+"/wait", nil)
+	if err != nil {
+		// If we can't connect, then the daemon probably died.
+		if err != ErrConnectionRefused {
+			return -1, err
+		}
+		return -1, nil
+	}
+
+	var out APIWait
+	if err := json.Unmarshal(body, &out); err != nil {
+		return -1, err
+	}
+	return out.StatusCode, nil
+}
+
+func getExitCode(cli *DockerCli, containerId string) (int, error) {
+	body, _, err := cli.call("GET", "/containers/"+containerId+"/json", nil)
+	if err != nil {
+		// If we can't connect, then the daemon probably died.
+		if err != ErrConnectionRefused {
+			return -1, err
+		}
+		return -1, nil
+	}
+	c := &Container{}
+	if err := json.Unmarshal(body, c); err != nil {
+		return -1, err
+	}
+	return c.State.ExitCode, nil
+}
+
 func NewDockerCli(in io.ReadCloser, out, err io.Writer, proto, addr string) *DockerCli {
 	var (
 		isTerminal = false
@@ -1708,12 +1936,9 @@ func NewDockerCli(in io.ReadCloser, out, err io.Writer, proto, addr string) *Doc
 	if err == nil {
 		err = out
 	}
-
-	configFile, _ := auth.LoadConfig(os.Getenv("HOME"))
 	return &DockerCli{
 		proto:      proto,
 		addr:       addr,
-		configFile: configFile,
 		in:         in,
 		out:        out,
 		err:        err,

commands_test.go

@@ -90,6 +90,68 @@ func TestRunHostname(t *testing.T) {
 
 }
 
+// TestRunWorkdir checks that 'docker run -w' correctly sets a custom working directory
+func TestRunWorkdir(t *testing.T) {
+	stdout, stdoutPipe := io.Pipe()
+
+	cli := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)
+
+	c := make(chan struct{})
+	go func() {
+		defer close(c)
+		if err := cli.CmdRun("-w", "/foo/bar", unitTestImageID, "pwd"); err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	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 cmdOutput != "/foo/bar\n" {
+			t.Fatalf("'pwd' should display '%s', not '%s'", "/foo/bar\n", cmdOutput)
+		}
+	})
+
+	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
+		<-c
+	})
+
+}
+
+// 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 := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)
+
+	c := make(chan struct{})
+	go func() {
+		defer close(c)
+		if err := cli.CmdRun("-w", "/proc", unitTestImageID, "pwd"); err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	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 cmdOutput != "/proc\n" {
+			t.Fatalf("'pwd' should display '%s', not '%s'", "/proc\n", cmdOutput)
+		}
+	})
+
+	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
+		<-c
+	})
+
+}
+
 func TestRunExit(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
 	stdout, stdoutPipe := io.Pipe()
@@ -255,7 +317,7 @@ func TestRunAttachStdin(t *testing.T) {
 	ch := make(chan struct{})
 	go func() {
 		defer close(ch)
-		cli.CmdRun("-i", "-a", "stdin", unitTestImageID, "sh", "-c", "echo hello && cat")
+		cli.CmdRun("-i", "-a", "stdin", unitTestImageID, "sh", "-c", "echo hello && cat && sleep 5")
 	}()
 
 	// Send input to the command, close stdin
@@ -283,12 +345,10 @@ func TestRunAttachStdin(t *testing.T) {
 
 	// wait for CmdRun to return
 	setTimeout(t, "Waiting for CmdRun timed out", 5*time.Second, func() {
-		// Unblock hijack end
-		stdout.Read([]byte{})
 		<-ch
 	})
 
-	setTimeout(t, "Waiting for command to exit timed out", 5*time.Second, func() {
+	setTimeout(t, "Waiting for command to exit timed out", 10*time.Second, func() {
 		container.Wait()
 	})
 
@@ -309,6 +369,110 @@ func TestRunAttachStdin(t *testing.T) {
 	}
 }
 
+// TestRunDetach checks attaching and detaching with the escape sequence.
+func TestRunDetach(t *testing.T) {
+
+	stdin, stdinPipe := io.Pipe()
+	stdout, stdoutPipe := io.Pipe()
+
+	cli := NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)
+
+	ch := make(chan struct{})
+	go func() {
+		defer close(ch)
+		cli.CmdRun("-i", "-t", unitTestImageID, "cat")
+	}()
+
+	setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
+		if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	container := globalRuntime.List()[0]
+
+	setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {
+		stdinPipe.Write([]byte{'', ''})
+		if err := stdinPipe.Close(); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	// wait for CmdRun to return
+	setTimeout(t, "Waiting for CmdRun timed out", 15*time.Second, func() {
+		<-ch
+	})
+
+	time.Sleep(500 * time.Millisecond)
+	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
+func TestAttachDetach(t *testing.T) {
+	stdin, stdinPipe := io.Pipe()
+	stdout, stdoutPipe := io.Pipe()
+
+	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() {
+		if err := cli.CmdRun("-i", "-t", "-d", unitTestImageID, "cat"); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	container := globalRuntime.List()[0]
+
+	stdin, stdinPipe = io.Pipe()
+	stdout, stdoutPipe = io.Pipe()
+	cli = NewDockerCli(stdin, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+
+	ch := make(chan struct{})
+	go func() {
+		defer close(ch)
+		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 {
+			t.Fatal(err)
+		}
+	})
+
+	setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {
+		stdinPipe.Write([]byte{'', ''})
+		if err := stdinPipe.Close(); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	// 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.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()
+	})
+}
+
 // Expected behaviour, the process stays alive when the client disconnects
 func TestAttachDisconnect(t *testing.T) {
 	stdin, stdinPipe := io.Pipe()
@@ -373,8 +537,46 @@ func TestAttachDisconnect(t *testing.T) {
 		t.Fatalf("/bin/cat is not running after closing stdin")
 	}
 
-	// Try to avoid the timeoout in destroy. Best effort, don't check error
+	// Try to avoid the timeout in destroy. Best effort, don't check error
 	cStdin, _ := container.StdinPipe()
 	cStdin.Close()
 	container.Wait()
 }
+
+// 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 := NewDockerCli(nil, stdoutPipe, ioutil.Discard, testDaemonProto, testDaemonAddr)
+	defer cleanup(globalRuntime)
+
+	c := make(chan struct{})
+	go func() {
+		defer close(c)
+		if err := cli.CmdRun("-rm", unitTestImageID, "hostname"); err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	var temporaryContainerID string
+	setTimeout(t, "Reading command output time out", 2*time.Second, func() {
+		cmdOutput, err := bufio.NewReader(stdout).ReadString('\n')
+		if err != nil {
+			t.Fatal(err)
+		}
+		temporaryContainerID = cmdOutput
+		if err := closeWrap(stdout, stdoutPipe); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
+		<-c
+	})
+
+	time.Sleep(500 * time.Millisecond)
+
+	if len(globalRuntime.List()) > 0 {
+		t.Fatalf("failed to remove container automatically: container %s still exists", temporaryContainerID)
+	}
+}

container.go

@@ -2,6 +2,7 @@ package docker
 
 import (
 	"encoding/json"
+	"errors"
 	"flag"
 	"fmt"
 	"github.com/dotcloud/docker/term"
@@ -10,11 +11,11 @@ import (
 	"io"
 	"io/ioutil"
 	"log"
+	"net"
 	"os"
 	"os/exec"
 	"path"
 	"path/filepath"
-	"sort"
 	"strconv"
 	"strings"
 	"syscall"
@@ -40,6 +41,8 @@ type Container struct {
 
 	SysInitPath    string
 	ResolvConfPath string
+	HostnamePath   string
+	HostsPath      string
 
 	cmd       *exec.Cmd
 	stdout    *utils.WriteBroadcaster
@@ -59,6 +62,7 @@ type Container struct {
 
 type Config struct {
 	Hostname        string
+	Domainname      string
 	User            string
 	Memory          int64 // Memory limit (in bytes)
 	MemorySwap      int64 // Total memory usage (memory + swap); set `-1' to disable swap
@@ -76,13 +80,16 @@ type Config struct {
 	Image           string // Name of the image as it was passed by the operator (eg. could be symbolic)
 	Volumes         map[string]struct{}
 	VolumesFrom     string
+	WorkingDir      string
 	Entrypoint      []string
 	NetworkDisabled bool
+	Privileged      bool
 }
 
 type HostConfig struct {
 	Binds           []string
 	ContainerIDFile string
+	LxcConf         []KeyValuePair
 }
 
 type BindMap struct {
@@ -91,14 +98,24 @@ type BindMap struct {
 	Mode    string
 }
 
+var (
+	ErrInvaidWorikingDirectory = errors.New("The working directory is invalid. It needs to be an absolute path.")
+)
+
+type KeyValuePair struct {
+	Key   string
+	Value string
+}
+
 func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig, *flag.FlagSet, error) {
 	cmd := Subcmd("run", "[OPTIONS] IMAGE [COMMAND] [ARG...]", "Run a command in a new container")
-	if len(args) > 0 && args[0] != "--help" {
+	if os.Getenv("TEST") != "" {
 		cmd.SetOutput(ioutil.Discard)
 		cmd.Usage = nil
 	}
 
 	flHostname := cmd.String("h", "", "Container host name")
+	flWorkingDir := cmd.String("w", "", "Working directory inside the container")
 	flUser := cmd.String("u", "", "Username or UID")
 	flDetach := cmd.Bool("d", false, "Detached mode: Run container in the background, print new container id")
 	flAttach := NewAttachOpts()
@@ -108,6 +125,8 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 	flMemory := cmd.Int64("m", 0, "Memory limit (in bytes)")
 	flContainerIDFile := cmd.String("cidfile", "", "Write the container ID to the file")
 	flNetwork := cmd.Bool("n", true, "Enable networking for this container")
+	flPrivileged := cmd.Bool("privileged", false, "Give extended privileges to this container")
+	flAutoRemove := cmd.Bool("rm", false, "Automatically remove the container when it exits (incompatible with -d)")
 
 	if capabilities != nil && *flMemory > 0 && !capabilities.MemoryLimit {
 		//fmt.Fprintf(stdout, "WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.\n")
@@ -128,15 +147,23 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 	flVolumes := NewPathOpts()
 	cmd.Var(flVolumes, "v", "Bind mount a volume (e.g. from the host: -v /host:/container, from docker: -v /container)")
 
-	flVolumesFrom := cmd.String("volumes-from", "", "Mount volumes from the specified container")
+	var flVolumesFrom ListOpts
+	cmd.Var(&flVolumesFrom, "volumes-from", "Mount volumes from the specified container")
+
 	flEntrypoint := cmd.String("entrypoint", "", "Overwrite the default entrypoint of the image")
 
+	var flLxcOpts ListOpts
+	cmd.Var(&flLxcOpts, "lxc-conf", "Add custom lxc options -lxc-conf=\"lxc.cgroup.cpuset.cpus = 0,1\"")
+
 	if err := cmd.Parse(args); err != nil {
 		return nil, nil, cmd, err
 	}
 	if *flDetach && len(flAttach) > 0 {
 		return nil, nil, cmd, fmt.Errorf("Conflicting options: -a and -d")
 	}
+	if *flWorkingDir != "" && !path.IsAbs(*flWorkingDir) {
+		return nil, nil, cmd, ErrInvaidWorikingDirectory
+	}
 	// If neither -d or -a are set, attach to everything by default
 	if len(flAttach) == 0 && !*flDetach {
 		if !*flDetach {
@@ -148,6 +175,10 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 		}
 	}
 
+	if *flDetach && *flAutoRemove {
+		return nil, nil, cmd, fmt.Errorf("Conflicting options: -rm and -d")
+	}
+
 	var binds []string
 
 	// add any bind targets to the list of container volumes
@@ -175,8 +206,23 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 		entrypoint = []string{*flEntrypoint}
 	}
 
+	var lxcConf []KeyValuePair
+	lxcConf, err := parseLxcConfOpts(flLxcOpts)
+	if err != nil {
+		return nil, nil, cmd, err
+	}
+
+	hostname := *flHostname
+	domainname := ""
+
+	parts := strings.SplitN(hostname, ".", 2)
+	if len(parts) > 1 {
+		hostname = parts[0]
+		domainname = parts[1]
+	}
 	config := &Config{
-		Hostname:        *flHostname,
+		Hostname:        hostname,
+		Domainname:      domainname,
 		PortSpecs:       flPorts,
 		User:            *flUser,
 		Tty:             *flTty,
@@ -192,12 +238,15 @@ func ParseRun(args []string, capabilities *Capabilities) (*Config, *HostConfig,
 		Dns:             flDns,
 		Image:           image,
 		Volumes:         flVolumes,
-		VolumesFrom:     *flVolumesFrom,
+		VolumesFrom:     strings.Join(flVolumesFrom, ","),
 		Entrypoint:      entrypoint,
+		Privileged:      *flPrivileged,
+		WorkingDir:      *flWorkingDir,
 	}
 	hostConfig := &HostConfig{
 		Binds:           binds,
 		ContainerIDFile: *flContainerIDFile,
+		LxcConf:         lxcConf,
 	}
 
 	if capabilities != nil && *flMemory > 0 && !capabilities.SwapLimit {
@@ -222,17 +271,28 @@ type NetworkSettings struct {
 	PortMapping map[string]PortMapping
 }
 
-// String returns a human-readable description of the port mapping defined in the settings
-func (settings *NetworkSettings) PortMappingHuman() string {
-	var mapping []string
+// returns a more easy to process description of the port mapping defined in the settings
+func (settings *NetworkSettings) PortMappingAPI() []APIPort {
+	var mapping []APIPort
 	for private, public := range settings.PortMapping["Tcp"] {
-		mapping = append(mapping, fmt.Sprintf("%s->%s", public, private))
+		pubint, _ := strconv.ParseInt(public, 0, 0)
+		privint, _ := strconv.ParseInt(private, 0, 0)
+		mapping = append(mapping, APIPort{
+			PrivatePort: privint,
+			PublicPort:  pubint,
+			Type:        "tcp",
+		})
 	}
 	for private, public := range settings.PortMapping["Udp"] {
-		mapping = append(mapping, fmt.Sprintf("%s->%s/udp", public, private))
+		pubint, _ := strconv.ParseInt(public, 0, 0)
+		privint, _ := strconv.ParseInt(private, 0, 0)
+		mapping = append(mapping, APIPort{
+			PrivatePort: privint,
+			PublicPort:  pubint,
+			Type:        "udp",
+		})
 	}
-	sort.Strings(mapping)
-	return strings.Join(mapping, ", ")
+	return mapping
 }
 
 // Inject the io.Reader at the given path. Note: do not close the reader
@@ -266,7 +326,8 @@ func (container *Container) FromDisk() error {
 		return err
 	}
 	// Load container settings
-	if err := json.Unmarshal(data, container); err != nil {
+	// udp broke compat of docker.PortMapping, but it's not used when loading a container, we can skip it
+	if err := json.Unmarshal(data, container); err != nil && !strings.Contains(err.Error(), "docker.PortMapping") {
 		return err
 	}
 	return nil
@@ -300,7 +361,7 @@ func (container *Container) SaveHostConfig(hostConfig *HostConfig) (err error) {
 	return ioutil.WriteFile(container.hostConfigPath(), data, 0666)
 }
 
-func (container *Container) generateLXCConfig() error {
+func (container *Container) generateLXCConfig(hostConfig *HostConfig) error {
 	fo, err := os.Create(container.lxcConfigPath())
 	if err != nil {
 		return err
@@ -309,6 +370,11 @@ func (container *Container) generateLXCConfig() error {
 	if err := LxcTemplateCompiled.Execute(fo, container); err != nil {
 		return err
 	}
+	if hostConfig != nil {
+		if err := LxcHostConfigTemplateCompiled.Execute(fo, hostConfig); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
@@ -324,20 +390,20 @@ func (container *Container) startPty() error {
 	// Copy the PTYs to our broadcasters
 	go func() {
 		defer container.stdout.CloseWriters()
-		utils.Debugf("[startPty] Begin of stdout pipe")
+		utils.Debugf("startPty: begin of stdout pipe")
 		io.Copy(container.stdout, ptyMaster)
-		utils.Debugf("[startPty] End of stdout pipe")
+		utils.Debugf("startPty: end of stdout pipe")
 	}()
 
 	// stdin
 	if container.Config.OpenStdin {
 		container.cmd.Stdin = ptySlave
-		container.cmd.SysProcAttr = &syscall.SysProcAttr{Setctty: true, Setsid: true}
+		container.cmd.SysProcAttr.Setctty = true
 		go func() {
 			defer container.stdin.Close()
-			utils.Debugf("[startPty] Begin of stdin pipe")
+			utils.Debugf("startPty: begin of stdin pipe")
 			io.Copy(ptyMaster, container.stdin)
-			utils.Debugf("[startPty] End of stdin pipe")
+			utils.Debugf("startPty: end of stdin pipe")
 		}()
 	}
 	if err := container.cmd.Start(); err != nil {
@@ -357,9 +423,9 @@ func (container *Container) start() error {
 		}
 		go func() {
 			defer stdin.Close()
-			utils.Debugf("Begin of stdin pipe [start]")
+			utils.Debugf("start: begin of stdin pipe")
 			io.Copy(stdin, container.stdin)
-			utils.Debugf("End of stdin pipe [start]")
+			utils.Debugf("start: end of stdin pipe")
 		}()
 	}
 	return container.cmd.Start()
@@ -376,8 +442,8 @@ func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, s
 			errors <- err
 		} else {
 			go func() {
-				utils.Debugf("[start] attach stdin\n")
-				defer utils.Debugf("[end] attach stdin\n")
+				utils.Debugf("attach: stdin: begin")
+				defer utils.Debugf("attach: stdin: end")
 				// No matter what, when stdin is closed (io.Copy unblock), close stdout and stderr
 				if container.Config.StdinOnce && !container.Config.Tty {
 					defer cStdin.Close()
@@ -395,7 +461,7 @@ func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, s
 					_, err = io.Copy(cStdin, stdin)
 				}
 				if err != nil {
-					utils.Debugf("[error] attach stdin: %s\n", err)
+					utils.Errorf("attach: stdin: %s", err)
 				}
 				// Discard error, expecting pipe error
 				errors <- nil
@@ -409,20 +475,21 @@ func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, s
 		} else {
 			cStdout = p
 			go func() {
-				utils.Debugf("[start] attach stdout\n")
-				defer utils.Debugf("[end]  attach stdout\n")
+				utils.Debugf("attach: stdout: begin")
+				defer utils.Debugf("attach: stdout: end")
 				// If we are in StdinOnce mode, then close stdin
-				if container.Config.StdinOnce {
-					if stdin != nil {
-						defer stdin.Close()
-					}
-					if stdinCloser != nil {
-						defer stdinCloser.Close()
-					}
+				if container.Config.StdinOnce && stdin != nil {
+					defer stdin.Close()
+				}
+				if stdinCloser != nil {
+					defer stdinCloser.Close()
 				}
 				_, err := io.Copy(stdout, cStdout)
+				if err == io.ErrClosedPipe {
+					err = nil
+				}
 				if err != nil {
-					utils.Debugf("[error] attach stdout: %s\n", err)
+					utils.Errorf("attach: stdout: %s", err)
 				}
 				errors <- err
 			}()
@@ -432,9 +499,8 @@ func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, s
 			if stdinCloser != nil {
 				defer stdinCloser.Close()
 			}
-
 			if cStdout, err := container.StdoutPipe(); err != nil {
-				utils.Debugf("Error stdout pipe")
+				utils.Errorf("attach: stdout pipe: %s", err)
 			} else {
 				io.Copy(&utils.NopWriter{}, cStdout)
 			}
@@ -447,20 +513,21 @@ func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, s
 		} else {
 			cStderr = p
 			go func() {
-				utils.Debugf("[start] attach stderr\n")
-				defer utils.Debugf("[end]  attach stderr\n")
+				utils.Debugf("attach: stderr: begin")
+				defer utils.Debugf("attach: stderr: end")
 				// If we are in StdinOnce mode, then close stdin
-				if container.Config.StdinOnce {
-					if stdin != nil {
-						defer stdin.Close()
-					}
-					if stdinCloser != nil {
-						defer stdinCloser.Close()
-					}
+				if container.Config.StdinOnce && stdin != nil {
+					defer stdin.Close()
+				}
+				if stdinCloser != nil {
+					defer stdinCloser.Close()
 				}
 				_, err := io.Copy(stderr, cStderr)
+				if err == io.ErrClosedPipe {
+					err = nil
+				}
 				if err != nil {
-					utils.Debugf("[error] attach stderr: %s\n", err)
+					utils.Errorf("attach: stderr: %s", err)
 				}
 				errors <- err
 			}()
@@ -472,7 +539,7 @@ func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, s
 			}
 
 			if cStderr, err := container.StderrPipe(); err != nil {
-				utils.Debugf("Error stdout pipe")
+				utils.Errorf("attach: stdout pipe: %s", err)
 			} else {
 				io.Copy(&utils.NopWriter{}, cStderr)
 			}
@@ -486,26 +553,31 @@ func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, s
 		if cStderr != nil {
 			defer cStderr.Close()
 		}
-		// FIXME: how do clean up the stdin goroutine without the unwanted side effect
+		// FIXME: how to clean up the stdin goroutine without the unwanted side effect
 		// of closing the passed stdin? Add an intermediary io.Pipe?
 		for i := 0; i < nJobs; i += 1 {
-			utils.Debugf("Waiting for job %d/%d\n", i+1, nJobs)
+			utils.Debugf("attach: waiting for job %d/%d", i+1, nJobs)
 			if err := <-errors; err != nil {
-				utils.Debugf("Job %d returned error %s. Aborting all jobs\n", i+1, err)
+				utils.Errorf("attach: job %d returned error %s, aborting all jobs", i+1, err)
 				return err
 			}
-			utils.Debugf("Job %d completed successfully\n", i+1)
+			utils.Debugf("attach: job %d completed successfully", i+1)
 		}
-		utils.Debugf("All jobs completed successfully\n")
+		utils.Debugf("attach: all jobs completed successfully")
 		return nil
 	})
 }
 
-func (container *Container) Start(hostConfig *HostConfig) error {
+func (container *Container) Start(hostConfig *HostConfig) (err error) {
 	container.State.Lock()
 	defer container.State.Unlock()
+	defer func() {
+		if err != nil {
+			container.cleanup()
+		}
+	}()
 
-	if len(hostConfig.Binds) == 0 {
+	if hostConfig == nil { // in docker start of docker restart we want to reuse previous HostConfigFile
 		hostConfig, _ = container.ReadHostConfig()
 	}
 
@@ -533,6 +605,10 @@ func (container *Container) Start(hostConfig *HostConfig) error {
 		container.Config.MemorySwap = -1
 	}
 
+	if container.runtime.capabilities.IPv4ForwardingDisabled {
+		log.Printf("WARNING: IPv4 forwarding is disabled. Networking will not work")
+	}
+
 	// Create the requested bind mounts
 	binds := make(map[string]BindMap)
 	// Define illegal container destinations
@@ -569,60 +645,110 @@ func (container *Container) Start(hostConfig *HostConfig) error {
 		binds[path.Clean(dst)] = bindMap
 	}
 
-	// FIXME: evaluate volumes-from before individual volumes, so that the latter can override the former.
-	// Create the requested volumes volumes
 	if container.Volumes == nil || len(container.Volumes) == 0 {
 		container.Volumes = make(map[string]string)
 		container.VolumesRW = make(map[string]bool)
-
-		for volPath := range container.Config.Volumes {
-			volPath = path.Clean(volPath)
-			// If an external bind is defined for this volume, use that as a source
-			if bindMap, exists := binds[volPath]; exists {
-				container.Volumes[volPath] = bindMap.SrcPath
-				if strings.ToLower(bindMap.Mode) == "rw" {
-					container.VolumesRW[volPath] = true
-				}
-				// Otherwise create an directory in $ROOT/volumes/ and use that
-			} else {
-				c, err := container.runtime.volumes.Create(nil, container, "", "", nil)
-				if err != nil {
-					return err
-				}
-				srcPath, err := c.layer()
-				if err != nil {
-					return err
-				}
-				container.Volumes[volPath] = srcPath
-				container.VolumesRW[volPath] = true // RW by default
-			}
-			// Create the mountpoint
-			if err := os.MkdirAll(path.Join(container.RootfsPath(), volPath), 0755); err != nil {
-				return nil
-			}
-		}
 	}
 
+	// Apply volumes from another container if requested
 	if container.Config.VolumesFrom != "" {
-		c := container.runtime.Get(container.Config.VolumesFrom)
-		if c == nil {
-			return fmt.Errorf("Container %s not found. Impossible to mount its volumes", container.ID)
+		volumes := strings.Split(container.Config.VolumesFrom, ",")
+		for _, v := range volumes {
+			c := container.runtime.Get(v)
+			if c == nil {
+				return fmt.Errorf("Container %s not found. Impossible to mount its volumes", container.ID)
+			}
+			for volPath, id := range c.Volumes {
+				if _, exists := container.Volumes[volPath]; exists {
+					continue
+				}
+				if err := os.MkdirAll(path.Join(container.RootfsPath(), volPath), 0755); err != nil {
+					return err
+				}
+				container.Volumes[volPath] = id
+				if isRW, exists := c.VolumesRW[volPath]; exists {
+					container.VolumesRW[volPath] = isRW
+				}
+			}
+
 		}
-		for volPath, id := range c.Volumes {
-			if _, exists := container.Volumes[volPath]; exists {
-				return fmt.Errorf("The requested volume %s overlap one of the volume of the container %s", volPath, c.ID)
+	}
+
+	// Create the requested volumes if they don't exist
+	for volPath := range container.Config.Volumes {
+		volPath = path.Clean(volPath)
+		// Skip existing volumes
+		if _, exists := container.Volumes[volPath]; exists {
+			continue
+		}
+		var srcPath string
+		var isBindMount bool
+		srcRW := false
+		// If an external bind is defined for this volume, use that as a source
+		if bindMap, exists := binds[volPath]; exists {
+			isBindMount = true
+			srcPath = bindMap.SrcPath
+			if strings.ToLower(bindMap.Mode) == "rw" {
+				srcRW = true
 			}
-			if err := os.MkdirAll(path.Join(container.RootfsPath(), volPath), 0755); err != nil {
-				return nil
+			// Otherwise create an directory in $ROOT/volumes/ and use that
+		} else {
+			c, err := container.runtime.volumes.Create(nil, container, "", "", nil)
+			if err != nil {
+				return err
 			}
-			container.Volumes[volPath] = id
-			if isRW, exists := c.VolumesRW[volPath]; exists {
-				container.VolumesRW[volPath] = isRW
+			srcPath, err = c.layer()
+			if err != nil {
+				return err
+			}
+			srcRW = true // RW by default
+		}
+		container.Volumes[volPath] = srcPath
+		container.VolumesRW[volPath] = srcRW
+		// Create the mountpoint
+		rootVolPath := path.Join(container.RootfsPath(), volPath)
+		if err := os.MkdirAll(rootVolPath, 0755); err != nil {
+			return nil
+		}
+
+		// Do not copy or change permissions if we are mounting from the host
+		if srcRW && !isBindMount {
+			volList, err := ioutil.ReadDir(rootVolPath)
+			if err != nil {
+				return err
+			}
+			if len(volList) > 0 {
+				srcList, err := ioutil.ReadDir(srcPath)
+				if err != nil {
+					return err
+				}
+				if len(srcList) == 0 {
+					// If the source volume is empty copy files from the root into the volume
+					if err := CopyWithTar(rootVolPath, srcPath); err != nil {
+						return err
+					}
+
+					var stat syscall.Stat_t
+					if err := syscall.Stat(rootVolPath, &stat); err != nil {
+						return err
+					}
+					var srcStat syscall.Stat_t
+					if err := syscall.Stat(srcPath, &srcStat); err != nil {
+						return err
+					}
+					// Change the source volume's ownership if it differs from the root
+					// files that where just copied
+					if stat.Uid != srcStat.Uid || stat.Gid != srcStat.Gid {
+						if err := os.Chown(srcPath, int(stat.Uid), int(stat.Gid)); err != nil {
+							return err
+						}
+					}
+				}
 			}
 		}
 	}
 
-	if err := container.generateLXCConfig(); err != nil {
+	if err := container.generateLXCConfig(hostConfig); err != nil {
 		return err
 	}
 
@@ -630,7 +756,7 @@ func (container *Container) Start(hostConfig *HostConfig) error {
 		"-n", container.ID,
 		"-f", container.lxcConfigPath(),
 		"--",
-		"/sbin/init",
+		"/.dockerinit",
 	}
 
 	// Networking
@@ -652,7 +778,20 @@ func (container *Container) Start(hostConfig *HostConfig) error {
 		"-e", "HOME=/",
 		"-e", "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
 		"-e", "container=lxc",
+		"-e", "HOSTNAME="+container.Config.Hostname,
 	)
+	if container.Config.WorkingDir != "" {
+		workingDir := path.Clean(container.Config.WorkingDir)
+		utils.Debugf("[working dir] working dir is %s", workingDir)
+
+		if err := os.MkdirAll(path.Join(container.RootfsPath(), workingDir), 0755); err != nil {
+			return nil
+		}
+
+		params = append(params,
+			"-w", workingDir,
+		)
+	}
 
 	for _, elem := range container.Config.Env {
 		params = append(params, "-e", elem)
@@ -672,7 +811,8 @@ func (container *Container) Start(hostConfig *HostConfig) error {
 		return err
 	}
 
-	var err error
+	container.cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
+
 	if container.Config.Tty {
 		err = container.startPty()
 	} else {
@@ -690,7 +830,7 @@ func (container *Container) Start(hostConfig *HostConfig) error {
 
 	container.ToDisk()
 	container.SaveHostConfig(hostConfig)
-	go container.monitor()
+	go container.monitor(hostConfig)
 	return nil
 }
 
@@ -718,9 +858,14 @@ func (container *Container) Output() (output []byte, err error) {
 	return output, err
 }
 
-// StdinPipe() returns a pipe connected to the standard input of the container's
-// active process.
-//
+// Container.StdinPipe returns a WriteCloser which can be used to feed data
+// to the standard input of the container's active process.
+// Container.StdoutPipe and Container.StderrPipe each return a ReadCloser
+// which can be used to retrieve the standard output (and error) generated
+// by the container's active process. The output (and error) are actually
+// copied and delivered to all StdoutPipe and StderrPipe consumers, using
+// a kind of "broadcaster".
+
 func (container *Container) StdinPipe() (io.WriteCloser, error) {
 	return container.stdinPipe, nil
 }
@@ -742,14 +887,44 @@ func (container *Container) allocateNetwork() error {
 		return nil
 	}
 
-	iface, err := container.runtime.networkManager.Allocate()
-	if err != nil {
-		return err
+	var iface *NetworkInterface
+	var err error
+	if !container.State.Ghost {
+		iface, err = container.runtime.networkManager.Allocate()
+		if err != nil {
+			return err
+		}
+	} else {
+		manager := container.runtime.networkManager
+		if manager.disabled {
+			iface = &NetworkInterface{disabled: true}
+		} else {
+			iface = &NetworkInterface{
+				IPNet:   net.IPNet{IP: net.ParseIP(container.NetworkSettings.IPAddress), Mask: manager.bridgeNetwork.Mask},
+				Gateway: manager.bridgeNetwork.IP,
+				manager: manager,
+			}
+			ipNum := ipToInt(iface.IPNet.IP)
+			manager.ipAllocator.inUse[ipNum] = struct{}{}
+		}
 	}
+
+	var portSpecs []string
+	if !container.State.Ghost {
+		portSpecs = container.Config.PortSpecs
+	} else {
+		for backend, frontend := range container.NetworkSettings.PortMapping["Tcp"] {
+			portSpecs = append(portSpecs, fmt.Sprintf("%s:%s/tcp", frontend, backend))
+		}
+		for backend, frontend := range container.NetworkSettings.PortMapping["Udp"] {
+			portSpecs = append(portSpecs, fmt.Sprintf("%s:%s/udp", frontend, backend))
+		}
+	}
+
 	container.NetworkSettings.PortMapping = make(map[string]PortMapping)
 	container.NetworkSettings.PortMapping["Tcp"] = make(PortMapping)
 	container.NetworkSettings.PortMapping["Udp"] = make(PortMapping)
-	for _, spec := range container.Config.PortSpecs {
+	for _, spec := range portSpecs {
 		nat, err := iface.AllocatePort(spec)
 		if err != nil {
 			iface.Release()
@@ -768,7 +943,7 @@ func (container *Container) allocateNetwork() error {
 }
 
 func (container *Container) releaseNetwork() {
-	if container.Config.NetworkDisabled {
+	if container.Config.NetworkDisabled || container.network == nil {
 		return
 	}
 	container.network.Release()
@@ -790,62 +965,46 @@ func (container *Container) waitLxc() error {
 	}
 }
 
-func (container *Container) monitor() {
+func (container *Container) monitor(hostConfig *HostConfig) {
 	// Wait for the program to exit
-	utils.Debugf("Waiting for process")
 
-	// If the command does not exists, try to wait via lxc
+	// If the command does not exist, try to wait via lxc
+	// (This probably happens only for ghost containers, i.e. containers that were running when Docker started)
 	if container.cmd == nil {
+		utils.Debugf("monitor: waiting for container %s using waitLxc", container.ID)
 		if err := container.waitLxc(); err != nil {
-			utils.Debugf("%s: Process: %s", container.ID, err)
+			utils.Errorf("monitor: while waiting for container %s, waitLxc had a problem: %s", container.ID, err)
 		}
 	} else {
+		utils.Debugf("monitor: waiting for container %s using cmd.Wait", container.ID)
 		if err := container.cmd.Wait(); err != nil {
-			// Discard the error as any signals or non 0 returns will generate an error
-			utils.Debugf("%s: Process: %s", container.ID, err)
+			// Since non-zero exit status and signal terminations will cause err to be non-nil,
+			// we have to actually discard it. Still, log it anyway, just in case.
+			utils.Debugf("monitor: cmd.Wait reported exit status %s for container %s", err, container.ID)
 		}
 	}
-	utils.Debugf("Process finished")
-	if container.runtime != nil && container.runtime.srv != nil {
-		container.runtime.srv.LogEvent("die", container.ShortID())
-	}
+	utils.Debugf("monitor: container %s finished", container.ID)
+
 	exitCode := -1
 	if container.cmd != nil {
 		exitCode = container.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
 	}
 
+	// Report status back
+	container.State.setStopped(exitCode)
+
+	if container.runtime != nil && container.runtime.srv != nil {
+		container.runtime.srv.LogEvent("die", container.ShortID(), container.runtime.repositories.ImageName(container.Image))
+	}
+
 	// Cleanup
-	container.releaseNetwork()
-	if container.Config.OpenStdin {
-		if err := container.stdin.Close(); err != nil {
-			utils.Debugf("%s: Error close stdin: %s", container.ID, err)
-		}
-	}
-	if err := container.stdout.CloseWriters(); err != nil {
-		utils.Debugf("%s: Error close stdout: %s", container.ID, err)
-	}
-	if err := container.stderr.CloseWriters(); err != nil {
-		utils.Debugf("%s: Error close stderr: %s", container.ID, err)
-	}
-
-	if container.ptyMaster != nil {
-		if err := container.ptyMaster.Close(); err != nil {
-			utils.Debugf("%s: Error closing Pty master: %s", container.ID, err)
-		}
-	}
-
-	if err := container.Unmount(); err != nil {
-		log.Printf("%v: Failed to umount filesystem: %v", container.ID, err)
-	}
+	container.cleanup()
 
 	// Re-create a brand new stdin pipe once the container exited
 	if container.Config.OpenStdin {
 		container.stdin, container.stdinPipe = io.Pipe()
 	}
 
-	// Report status back
-	container.State.setStopped(exitCode)
-
 	// Release the lock
 	close(container.waitLock)
 
@@ -860,6 +1019,31 @@ func (container *Container) monitor() {
 	}
 }
 
+func (container *Container) cleanup() {
+	container.releaseNetwork()
+	if container.Config.OpenStdin {
+		if err := container.stdin.Close(); err != nil {
+			utils.Errorf("%s: Error close stdin: %s", container.ID, err)
+		}
+	}
+	if err := container.stdout.CloseWriters(); err != nil {
+		utils.Errorf("%s: Error close stdout: %s", container.ID, err)
+	}
+	if err := container.stderr.CloseWriters(); err != nil {
+		utils.Errorf("%s: Error close stderr: %s", container.ID, err)
+	}
+
+	if container.ptyMaster != nil {
+		if err := container.ptyMaster.Close(); err != nil {
+			utils.Errorf("%s: Error closing Pty master: %s", container.ID, err)
+		}
+	}
+
+	if err := container.Unmount(); err != nil {
+		log.Printf("%v: Failed to umount filesystem: %v", container.ID, err)
+	}
+}
+
 func (container *Container) kill() error {
 	if !container.State.Running {
 		return nil
@@ -1087,3 +1271,24 @@ func (container *Container) GetSize() (int64, int64) {
 	}
 	return sizeRw, sizeRootfs
 }
+
+func (container *Container) Copy(resource string) (Archive, error) {
+	if err := container.EnsureMounted(); err != nil {
+		return nil, err
+	}
+	var filter []string
+	basePath := path.Join(container.RootfsPath(), resource)
+	stat, err := os.Stat(basePath)
+	if err != nil {
+		return nil, err
+	}
+	if !stat.IsDir() {
+		d, f := path.Split(basePath)
+		basePath = d
+		filter = []string{f}
+	} else {
+		filter = []string{path.Base(basePath)}
+		basePath = path.Dir(basePath)
+	}
+	return TarFilter(basePath, Uncompressed, filter)
+}

container_test.go

@@ -18,7 +18,7 @@ import (
 func TestIDFormat(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container1, err := NewBuilder(runtime).Create(
+	container1, err := runtime.Create(
 		&Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"/bin/sh", "-c", "echo hello world"},
@@ -138,12 +138,21 @@ func TestDiff(t *testing.T) {
 	container1, _, _ := mkContainer(runtime, []string{"_", "/bin/rm", "/etc/passwd"}, t)
 	defer runtime.Destroy(container1)
 
+	// The changelog should be empty and not fail before run. See #1705
+	c, err := container1.Changes()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(c) != 0 {
+		t.Fatalf("Changelog should be empty before run")
+	}
+
 	if err := container1.Run(); err != nil {
 		t.Fatal(err)
 	}
 
 	// Check the changelog
-	c, err := container1.Changes()
+	c, err = container1.Changes()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -186,7 +195,7 @@ func TestDiff(t *testing.T) {
 		}
 	}
 
-	// Create a new containere
+	// Create a new container
 	container3, _, _ := mkContainer(runtime, []string{"_", "rm", "/bin/httpd"}, t)
 	defer runtime.Destroy(container3)
 
@@ -351,10 +360,10 @@ func TestStart(t *testing.T) {
 		t.Errorf("Container should be running")
 	}
 	if err := container.Start(hostConfig); err == nil {
-		t.Fatalf("A running containter should be able to be started")
+		t.Fatalf("A running container should be able to be started")
 	}
 
-	// Try to avoid the timeoout in destroy. Best effort, don't check error
+	// Try to avoid the timeout in destroy. Best effort, don't check error
 	cStdin.Close()
 	container.WaitTimeout(2 * time.Second)
 }
@@ -379,7 +388,7 @@ func TestRun(t *testing.T) {
 func TestOutput(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, err := NewBuilder(runtime).Create(
+	container, err := runtime.Create(
 		&Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"echo", "-n", "foobar"},
@@ -401,22 +410,24 @@ func TestOutput(t *testing.T) {
 func TestKillDifferentUser(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, err := NewBuilder(runtime).Create(&Config{
-		Image: GetTestImage(runtime).ID,
-		Cmd:   []string{"tail", "-f", "/etc/resolv.conf"},
-		User:  "daemon",
+
+	container, err := runtime.Create(&Config{
+		Image:     GetTestImage(runtime).ID,
+		Cmd:       []string{"cat"},
+		OpenStdin: true,
+		User:      "daemon",
 	},
 	)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer runtime.Destroy(container)
+	defer container.stdin.Close()
 
 	if container.State.Running {
 		t.Errorf("Container shouldn't be running")
 	}
-	hostConfig := &HostConfig{}
-	if err := container.Start(hostConfig); err != nil {
+	if err := container.Start(&HostConfig{}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -426,8 +437,13 @@ func TestKillDifferentUser(t *testing.T) {
 		}
 	})
 
-	// Even if the state is running, lets give some time to lxc to spawn the process
-	container.WaitTimeout(500 * time.Millisecond)
+	setTimeout(t, "read/write assertion timed out", 2*time.Second, func() {
+		out, _ := container.StdoutPipe()
+		in, _ := container.StdinPipe()
+		if err := assertPipe("hello\n", "hello", out, in, 15); err != nil {
+			t.Fatal(err)
+		}
+	})
 
 	if err := container.Kill(); err != nil {
 		t.Fatal(err)
@@ -455,7 +471,7 @@ func TestCreateVolume(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	c, err := NewBuilder(runtime).Create(config)
+	c, err := runtime.Create(config)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -470,7 +486,7 @@ func TestCreateVolume(t *testing.T) {
 func TestKill(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, err := NewBuilder(runtime).Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"sleep", "2"},
 	},
@@ -514,9 +530,7 @@ func TestExitCode(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	builder := NewBuilder(runtime)
-
-	trueContainer, err := builder.Create(&Config{
+	trueContainer, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"/bin/true", ""},
 	})
@@ -531,7 +545,7 @@ func TestExitCode(t *testing.T) {
 		t.Errorf("Unexpected exit code %d (expected 0)", trueContainer.State.ExitCode)
 	}
 
-	falseContainer, err := builder.Create(&Config{
+	falseContainer, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"/bin/false", ""},
 	})
@@ -550,7 +564,7 @@ func TestExitCode(t *testing.T) {
 func TestRestart(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, err := NewBuilder(runtime).Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"echo", "-n", "foobar"},
 	},
@@ -580,7 +594,7 @@ func TestRestart(t *testing.T) {
 func TestRestartStdin(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, err := NewBuilder(runtime).Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"cat"},
 
@@ -657,10 +671,8 @@ func TestUser(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	builder := NewBuilder(runtime)
-
 	// Default user must be root
-	container, err := builder.Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 	},
@@ -678,7 +690,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a username
-	container, err = builder.Create(&Config{
+	container, err = runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 
@@ -698,7 +710,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a UID
-	container, err = builder.Create(&Config{
+	container, err = runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 
@@ -718,7 +730,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a different user by uid
-	container, err = builder.Create(&Config{
+	container, err = runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 
@@ -740,7 +752,7 @@ func TestUser(t *testing.T) {
 	}
 
 	// Set a different user by username
-	container, err = builder.Create(&Config{
+	container, err = runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 
@@ -760,11 +772,11 @@ func TestUser(t *testing.T) {
 	}
 
 	// Test an wrong username
-	container, err = builder.Create(&Config{
+	container, err = runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"id"},
 
-		User: "unkownuser",
+		User: "unknownuser",
 	},
 	)
 	if err != nil {
@@ -781,9 +793,7 @@ func TestMultipleContainers(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	builder := NewBuilder(runtime)
-
-	container1, err := builder.Create(&Config{
+	container1, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"sleep", "2"},
 	},
@@ -793,7 +803,7 @@ func TestMultipleContainers(t *testing.T) {
 	}
 	defer runtime.Destroy(container1)
 
-	container2, err := builder.Create(&Config{
+	container2, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"sleep", "2"},
 	},
@@ -837,7 +847,7 @@ func TestMultipleContainers(t *testing.T) {
 func TestStdin(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, err := NewBuilder(runtime).Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"cat"},
 
@@ -882,7 +892,7 @@ func TestStdin(t *testing.T) {
 func TestTty(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, err := NewBuilder(runtime).Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"cat"},
 
@@ -927,7 +937,7 @@ func TestTty(t *testing.T) {
 func TestEnv(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, err := NewBuilder(runtime).Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"env"},
 	},
@@ -960,6 +970,7 @@ func TestEnv(t *testing.T) {
 		"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
 		"HOME=/",
 		"container=lxc",
+		"HOSTNAME=" + container.ShortID(),
 	}
 	sort.Strings(goodEnv)
 	if len(goodEnv) != len(actualEnv) {
@@ -975,7 +986,7 @@ func TestEnv(t *testing.T) {
 func TestEntrypoint(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, err := NewBuilder(runtime).Create(
+	container, err := runtime.Create(
 		&Config{
 			Image:      GetTestImage(runtime).ID,
 			Entrypoint: []string{"/bin/echo"},
@@ -995,6 +1006,28 @@ func TestEntrypoint(t *testing.T) {
 	}
 }
 
+func TestEntrypointNoCmd(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+	container, err := runtime.Create(
+		&Config{
+			Image:      GetTestImage(runtime).ID,
+			Entrypoint: []string{"/bin/echo", "foobar"},
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container)
+	output, err := container.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Trim(string(output), "\r\n") != "foobar" {
+		t.Error(string(output))
+	}
+}
+
 func grepFile(t *testing.T, path string, pattern string) {
 	f, err := os.Open(path)
 	if err != nil {
@@ -1027,7 +1060,7 @@ func TestLXCConfig(t *testing.T) {
 	cpuMin := 100
 	cpuMax := 10000
 	cpu := cpuMin + rand.Intn(cpuMax-cpuMin)
-	container, err := NewBuilder(runtime).Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image: GetTestImage(runtime).ID,
 		Cmd:   []string{"/bin/true"},
 
@@ -1040,7 +1073,7 @@ func TestLXCConfig(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer runtime.Destroy(container)
-	container.generateLXCConfig()
+	container.generateLXCConfig(nil)
 	grepFile(t, container.lxcConfigPath(), "lxc.utsname = foobar")
 	grepFile(t, container.lxcConfigPath(),
 		fmt.Sprintf("lxc.cgroup.memory.limit_in_bytes = %d", mem))
@@ -1048,11 +1081,41 @@ func TestLXCConfig(t *testing.T) {
 		fmt.Sprintf("lxc.cgroup.memory.memsw.limit_in_bytes = %d", mem*2))
 }
 
+func TestCustomLxcConfig(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+	container, err := runtime.Create(&Config{
+		Image: GetTestImage(runtime).ID,
+		Cmd:   []string{"/bin/true"},
+
+		Hostname: "foobar",
+	},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container)
+	hostConfig := &HostConfig{LxcConf: []KeyValuePair{
+		{
+			Key:   "lxc.utsname",
+			Value: "docker",
+		},
+		{
+			Key:   "lxc.cgroup.cpuset.cpus",
+			Value: "0,1",
+		},
+	}}
+
+	container.generateLXCConfig(hostConfig)
+	grepFile(t, container.lxcConfigPath(), "lxc.utsname = docker")
+	grepFile(t, container.lxcConfigPath(), "lxc.cgroup.cpuset.cpus = 0,1")
+}
+
 func BenchmarkRunSequencial(b *testing.B) {
 	runtime := mkRuntime(b)
 	defer nuke(runtime)
 	for i := 0; i < b.N; i++ {
-		container, err := NewBuilder(runtime).Create(&Config{
+		container, err := runtime.Create(&Config{
 			Image: GetTestImage(runtime).ID,
 			Cmd:   []string{"echo", "-n", "foo"},
 		},
@@ -1084,7 +1147,7 @@ func BenchmarkRunParallel(b *testing.B) {
 		complete := make(chan error)
 		tasks = append(tasks, complete)
 		go func(i int, complete chan error) {
-			container, err := NewBuilder(runtime).Create(&Config{
+			container, err := runtime.Create(&Config{
 				Image: GetTestImage(runtime).ID,
 				Cmd:   []string{"echo", "-n", "foo"},
 			},
@@ -1133,6 +1196,80 @@ func tempDir(t *testing.T) string {
 	return tmpDir
 }
 
+// Test for #1737
+func TestCopyVolumeUidGid(t *testing.T) {
+	r := mkRuntime(t)
+	defer nuke(r)
+
+	// Add directory not owned by root
+	container1, _, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello && touch /hello/test.txt && chown daemon.daemon /hello"}, t)
+	defer r.Destroy(container1)
+
+	if container1.State.Running {
+		t.Errorf("Container shouldn't be running")
+	}
+	if err := container1.Run(); err != nil {
+		t.Fatal(err)
+	}
+	if container1.State.Running {
+		t.Errorf("Container shouldn't be running")
+	}
+
+	rwTar, err := container1.ExportRw()
+	if err != nil {
+		t.Error(err)
+	}
+	img, err := r.graph.Create(rwTar, container1, "unit test commited image", "", nil)
+	if err != nil {
+		t.Error(err)
+	}
+
+	// Test that the uid and gid is copied from the image to the volume
+	tmpDir1 := tempDir(t)
+	defer os.RemoveAll(tmpDir1)
+	stdout1, _ := runContainer(r, []string{"-v", "/hello", img.ID, "stat", "-c", "%U %G", "/hello"}, t)
+	if !strings.Contains(stdout1, "daemon daemon") {
+		t.Fatal("Container failed to transfer uid and gid to volume")
+	}
+}
+
+// Test for #1582
+func TestCopyVolumeContent(t *testing.T) {
+	r := mkRuntime(t)
+	defer nuke(r)
+
+	// Put some content in a directory of a container and commit it
+	container1, _, _ := mkContainer(r, []string{"_", "/bin/sh", "-c", "mkdir -p /hello/local && echo hello > /hello/local/world"}, t)
+	defer r.Destroy(container1)
+
+	if container1.State.Running {
+		t.Errorf("Container shouldn't be running")
+	}
+	if err := container1.Run(); err != nil {
+		t.Fatal(err)
+	}
+	if container1.State.Running {
+		t.Errorf("Container shouldn't be running")
+	}
+
+	rwTar, err := container1.ExportRw()
+	if err != nil {
+		t.Error(err)
+	}
+	img, err := r.graph.Create(rwTar, container1, "unit test commited image", "", nil)
+	if err != nil {
+		t.Error(err)
+	}
+
+	// Test that the content is copied from the image to the volume
+	tmpDir1 := tempDir(t)
+	defer os.RemoveAll(tmpDir1)
+	stdout1, _ := runContainer(r, []string{"-v", "/hello", img.ID, "find", "/hello"}, t)
+	if !(strings.Contains(stdout1, "/hello/local/world") && strings.Contains(stdout1, "/hello/local")) {
+		t.Fatal("Container failed to transfer content to volume")
+	}
+}
+
 func TestBindMounts(t *testing.T) {
 	r := mkRuntime(t)
 	defer nuke(r)
@@ -1151,7 +1288,7 @@ func TestBindMounts(t *testing.T) {
 	readFile(path.Join(tmpDir, "holla"), t) // Will fail if the file doesn't exist
 
 	// test mounting to an illegal destination directory
-	if _, err := runContainer(r, []string{"-v", fmt.Sprintf("%s:.", tmpDir), "ls", "."}, nil); err == nil {
+	if _, err := runContainer(r, []string{"-v", fmt.Sprintf("%s:.", tmpDir), "_", "ls", "."}, nil); err == nil {
 		t.Fatal("Container bind mounted illegal directory")
 	}
 }
@@ -1160,7 +1297,7 @@ func TestBindMounts(t *testing.T) {
 func TestVolumesFromReadonlyMount(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
-	container, err := NewBuilder(runtime).Create(
+	container, err := runtime.Create(
 		&Config{
 			Image:   GetTestImage(runtime).ID,
 			Cmd:     []string{"/bin/echo", "-n", "foobar"},
@@ -1179,7 +1316,7 @@ func TestVolumesFromReadonlyMount(t *testing.T) {
 		t.Fail()
 	}
 
-	container2, err := NewBuilder(runtime).Create(
+	container2, err := runtime.Create(
 		&Config{
 			Image:       GetTestImage(runtime).ID,
 			Cmd:         []string{"/bin/echo", "-n", "foobar"},
@@ -1215,7 +1352,7 @@ func TestRestartWithVolumes(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
 
-	container, err := NewBuilder(runtime).Create(&Config{
+	container, err := runtime.Create(&Config{
 		Image:   GetTestImage(runtime).ID,
 		Cmd:     []string{"echo", "-n", "foobar"},
 		Volumes: map[string]struct{}{"/test": {}},
@@ -1253,6 +1390,71 @@ func TestRestartWithVolumes(t *testing.T) {
 	}
 }
 
+// Test for #1351
+func TestVolumesFromWithVolumes(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+
+	container, err := runtime.Create(&Config{
+		Image:   GetTestImage(runtime).ID,
+		Cmd:     []string{"sh", "-c", "echo -n bar > /test/foo"},
+		Volumes: map[string]struct{}{"/test": {}},
+	},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container)
+
+	for key := range container.Config.Volumes {
+		if key != "/test" {
+			t.Fail()
+		}
+	}
+
+	_, err = container.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := container.Volumes["/test"]
+	if expected == "" {
+		t.Fail()
+	}
+
+	container2, err := runtime.Create(
+		&Config{
+			Image:       GetTestImage(runtime).ID,
+			Cmd:         []string{"cat", "/test/foo"},
+			VolumesFrom: container.ID,
+			Volumes:     map[string]struct{}{"/test": {}},
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container2)
+
+	output, err := container2.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(output) != "bar" {
+		t.Fail()
+	}
+
+	if container.Volumes["/test"] != container2.Volumes["/test"] {
+		t.Fail()
+	}
+
+	// Ensure it restarts successfully
+	_, err = container2.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
 func TestOnlyLoopbackExistsWhenUsingDisableNetworkOption(t *testing.T) {
 	runtime := mkRuntime(t)
 	defer nuke(runtime)
@@ -1261,7 +1463,7 @@ func TestOnlyLoopbackExistsWhenUsingDisableNetworkOption(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	c, err := NewBuilder(runtime).Create(config)
+	c, err := runtime.Create(config)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1283,10 +1485,119 @@ func TestOnlyLoopbackExistsWhenUsingDisableNetworkOption(t *testing.T) {
 
 	interfaces := regexp.MustCompile(`(?m)^[0-9]+: [a-zA-Z0-9]+`).FindAllString(string(output), -1)
 	if len(interfaces) != 1 {
-		t.Fatalf("Wrong interface count in test container: expected [1: lo], got [%s]", interfaces)
+		t.Fatalf("Wrong interface count in test container: expected [*: lo], got %s", interfaces)
 	}
-	if interfaces[0] != "1: lo" {
-		t.Fatalf("Wrong interface in test container: expected [1: lo], got [%s]", interfaces)
+	if !strings.HasSuffix(interfaces[0], ": lo") {
+		t.Fatalf("Wrong interface in test container: expected [*: lo], got %s", interfaces)
 	}
 
 }
+
+func TestPrivilegedCanMknod(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+	if output, _ := runContainer(runtime, []string{"-privileged", "_", "sh", "-c", "mknod /tmp/sda b 8 0 && echo ok"}, t); output != "ok\n" {
+		t.Fatal("Could not mknod into privileged container")
+	}
+}
+
+func TestPrivilegedCanMount(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+	if output, _ := runContainer(runtime, []string{"-privileged", "_", "sh", "-c", "mount -t tmpfs none /tmp && echo ok"}, t); output != "ok\n" {
+		t.Fatal("Could not mount into privileged container")
+	}
+}
+
+func TestPrivilegedCannotMknod(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+	if output, _ := runContainer(runtime, []string{"_", "sh", "-c", "mknod /tmp/sda b 8 0 || echo ok"}, t); output != "ok\n" {
+		t.Fatal("Could mknod into secure container")
+	}
+}
+
+func TestPrivilegedCannotMount(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+	if output, _ := runContainer(runtime, []string{"_", "sh", "-c", "mount -t tmpfs none /tmp || echo ok"}, t); output != "ok\n" {
+		t.Fatal("Could mount into secure container")
+	}
+}
+
+func TestMultipleVolumesFrom(t *testing.T) {
+	runtime := mkRuntime(t)
+	defer nuke(runtime)
+
+	container, err := runtime.Create(&Config{
+		Image:   GetTestImage(runtime).ID,
+		Cmd:     []string{"sh", "-c", "echo -n bar > /test/foo"},
+		Volumes: map[string]struct{}{"/test": {}},
+	},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container)
+
+	for key := range container.Config.Volumes {
+		if key != "/test" {
+			t.Fail()
+		}
+	}
+
+	_, err = container.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := container.Volumes["/test"]
+	if expected == "" {
+		t.Fail()
+	}
+
+	container2, err := runtime.Create(
+		&Config{
+			Image:   GetTestImage(runtime).ID,
+			Cmd:     []string{"sh", "-c", "echo -n bar > /other/foo"},
+			Volumes: map[string]struct{}{"/other": {}},
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container2)
+
+	for key := range container2.Config.Volumes {
+		if key != "/other" {
+			t.FailNow()
+		}
+	}
+	if _, err := container2.Output(); err != nil {
+		t.Fatal(err)
+	}
+
+	container3, err := runtime.Create(
+		&Config{
+			Image:       GetTestImage(runtime).ID,
+			Cmd:         []string{"/bin/echo", "-n", "foobar"},
+			VolumesFrom: strings.Join([]string{container.ID, container2.ID}, ","),
+		})
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Destroy(container3)
+
+	if _, err := container3.Output(); err != nil {
+		t.Fatal(err)
+	}
+
+	t.Log(container3.Volumes)
+	if container3.Volumes["/test"] != container.Volumes["/test"] {
+		t.Fail()
+	}
+	if container3.Volumes["/other"] != container2.Volumes["/other"] {
+		t.Fail()
+	}
+}

contrib/Dockerfile.tmLanguage/Dockerfile.YAML-tmLanguage

@@ -0,0 +1,23 @@
+# [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*#.*$
+...

contrib/Dockerfile.tmLanguage/Dockerfile.tmLanguage

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

contrib/Dockerfile.tmLanguage/MAINTAINERS

@@ -0,0 +1 @@
+Asbjorn Enge <asbjorn@hanafjedle.net> (@asbjornenge)

contrib/Dockerfile.tmLanguage/README.md

@@ -0,0 +1,9 @@
+# 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.

contrib/MAINTAINERS

@@ -1 +1 @@
-# Maintainer wanted! Enroll on #docker@freenode
+Tianon Gravi <admwiggin@gmail.com> (@tianon)

contrib/brew/.gitignore

@@ -0,0 +1 @@
+*.pyc

contrib/brew/README.md

@@ -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.

contrib/brew/brew/__init__.py

@@ -0,0 +1 @@
+from brew import build_library, DEFAULT_REPOSITORY, DEFAULT_BRANCH

contrib/brew/brew/brew.py

@@ -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

contrib/brew/brew/git.py

@@ -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

contrib/brew/docker-brew

@@ -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)

contrib/brew/requirements.txt

@@ -0,0 +1,2 @@
+dulwich==0.9.0
+-e git://github.com/dotcloud/docker-py.git#egg=docker-py

contrib/brew/setup.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'],
+    )

contrib/completion/bash/docker

@@ -0,0 +1,543 @@
+#!bash
+#
+# bash completion file for core docker commands
+#
+# This script provides supports completion of:
+#  - commands and their options
+#  - container ids
+#  - image repos and tags
+#  - filepaths
+#
+# To enable the completions either:
+#  - place this file in /etc/bash_completion.d
+#  or
+#  - copy this file and add the line below to your .bashrc after
+#    bash completion features are loaded
+#     . docker.bash
+#
+# Note:
+# Currently, the completions will not work if the docker daemon is not
+# bound to the default communication port/socket
+# If the docker daemon is using a unix socket for communication your user
+# must have access to the socket for the completions to function correctly
+
+__docker_containers_all()
+{
+	local containers
+	containers="$( docker ps -a -q )"
+	COMPREPLY=( $( compgen -W "$containers" -- "$cur" ) )
+}
+
+__docker_containers_running()
+{
+	local containers
+	containers="$( docker ps -q )"
+	COMPREPLY=( $( compgen -W "$containers" -- "$cur" ) )
+}
+
+__docker_containers_stopped()
+{
+	local containers
+	containers="$( comm -13 <(docker ps -q | sort -u) <(docker ps -a -q | sort -u) )"
+	COMPREPLY=( $( compgen -W "$containers" -- "$cur" ) )
+}
+
+__docker_image_repos()
+{
+	local repos
+	repos="$( docker images | awk 'NR>1{print $1}' )"
+	COMPREPLY=( $( compgen -W "$repos" -- "$cur" ) )
+}
+
+__docker_images()
+{
+	local images
+	images="$( docker images | awk 'NR>1{print $1":"$2}' )"
+	COMPREPLY=( $( compgen -W "$images" -- "$cur" ) )
+	__ltrim_colon_completions "$cur"
+}
+
+__docker_image_repos_and_tags()
+{
+	local repos images
+	repos="$( docker images | awk 'NR>1{print $1}' )"
+	images="$( docker images | awk 'NR>1{print $1":"$2}' )"
+	COMPREPLY=( $( compgen -W "$repos $images" -- "$cur" ) )
+	__ltrim_colon_completions "$cur"
+}
+
+__docker_containers_and_images()
+{
+	local containers images
+	containers="$( docker ps -a -q )"
+	images="$( docker images | awk 'NR>1{print $1":"$2}' )"
+	COMPREPLY=( $( compgen -W "$images $containers" -- "$cur" ) )
+	__ltrim_colon_completions "$cur"
+}
+
+_docker_docker()
+{
+	case "$prev" in
+		-H)
+			return
+			;;
+		*)
+			;;
+	esac
+
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-H" -- "$cur" ) )
+			;;
+		*)
+			COMPREPLY=( $( compgen -W "$commands help" -- "$cur" ) )
+			;;
+	esac
+}
+
+_docker_attach()
+{
+	if [ $cpos -eq $cword ]; then
+		__docker_containers_running
+	fi
+}
+
+_docker_build()
+{
+	case "$prev" in
+		-t)
+			return
+			;;
+		*)
+			;;
+	esac
+
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-no-cache -t -q -rm" -- "$cur" ) )
+			;;
+		*)
+			_filedir
+			;;
+	esac
+}
+
+_docker_commit()
+{
+	case "$prev" in
+		-author|-m|-run)
+			return
+			;;
+		*)
+			;;
+	esac
+
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-author -m -run" -- "$cur" ) )
+			;;
+		*)
+			local counter=$cpos
+			while [ $counter -le $cword ]; do
+				case "${words[$counter]}" in
+					-author|-m|-run)
+						(( counter++ ))
+						;;
+					-*)
+						;;
+					*)
+						break
+						;;
+				esac
+				(( counter++ ))
+			done
+
+			if [ $counter -eq $cword ]; then
+				__docker_containers_all
+			fi
+			;;
+	esac
+}
+
+_docker_cp()
+{
+	if [ $cpos -eq $cword ]; then
+		__docker_containers_all
+	else
+		_filedir
+	fi
+}
+
+_docker_diff()
+{
+	if [ $cpos -eq $cword ]; then
+		__docker_containers_all
+	fi
+}
+
+_docker_events()
+{
+	case "$prev" in
+		-since)
+			return
+			;;
+		*)
+			;;
+	esac
+
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-since" -- "$cur" ) )
+			;;
+		*)
+			;;
+	esac
+}
+
+_docker_export()
+{
+	if [ $cpos -eq $cword ]; then
+		__docker_containers_all
+	fi
+}
+
+_docker_help()
+{
+	if [ $cpos -eq $cword ]; then
+		COMPREPLY=( $( compgen -W "$commands" -- "$cur" ) )
+	fi
+}
+
+_docker_history()
+{
+	if [ $cpos -eq $cword ]; then
+		__docker_image_repos_and_tags
+	fi
+}
+
+_docker_images()
+{
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-a -notrunc -q -viz" -- "$cur" ) )
+			;;
+		*)
+			local counter=$cpos
+			while [ $counter -le $cword ]; do
+				case "${words[$counter]}" in
+					-*)
+						;;
+					*)
+						break
+						;;
+				esac
+				(( counter++ ))
+			done
+
+			if [ $counter -eq $cword ]; then
+				__docker_image_repos
+			fi
+			;;
+	esac
+}
+
+_docker_import()
+{
+	return
+}
+
+_docker_info()
+{
+	return
+}
+
+_docker_insert()
+{
+	if [ $cpos -eq $cword ]; then
+		__docker_image_repos_and_tags
+	fi
+}
+
+_docker_inspect()
+{
+	__docker_containers_and_images
+}
+
+_docker_kill()
+{
+	__docker_containers_running
+}
+
+_docker_login()
+{
+	case "$prev" in
+		-e|-p|-u)
+			return
+			;;
+		*)
+			;;
+	esac
+
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-e -p -u" -- "$cur" ) )
+			;;
+		*)
+			;;
+	esac
+}
+
+_docker_logs()
+{
+	if [ $cpos -eq $cword ]; then
+		__docker_containers_all
+	fi
+}
+
+_docker_port()
+{
+	if [ $cpos -eq $cword ]; then
+		__docker_containers_all
+	fi
+}
+
+_docker_ps()
+{
+	case "$prev" in
+		-beforeId|-n|-sinceId)
+			return
+			;;
+		*)
+			;;
+	esac
+
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-a -beforeId -l -n -notrunc -q -s -sinceId" -- "$cur" ) )
+			;;
+		*)
+			;;
+	esac
+}
+
+_docker_pull()
+{
+	case "$prev" in
+		-t)
+			return
+			;;
+		*)
+			;;
+	esac
+
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-t" -- "$cur" ) )
+			;;
+		*)
+			;;
+	esac
+}
+
+_docker_push()
+{
+	__docker_image_repos
+}
+
+_docker_restart()
+{
+	case "$prev" in
+		-t)
+			return
+			;;
+		*)
+			;;
+	esac
+
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-t" -- "$cur" ) )
+			;;
+		*)
+			__docker_containers_all
+			;;
+	esac
+}
+
+_docker_rm()
+{
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-v" -- "$cur" ) )
+			;;
+		*)
+			__docker_containers_stopped
+			;;
+	esac
+}
+
+_docker_rmi()
+{
+	__docker_image_repos_and_tags
+}
+
+_docker_run()
+{
+	case "$prev" in
+		-cidfile)
+			_filedir
+			;;
+		-volumes-from)
+			__docker_containers_all
+			;;
+		-a|-c|-dns|-e|-entrypoint|-h|-lxc-conf|-m|-p|-u|-v|-w)
+			return
+			;;
+		*)
+			;;
+	esac
+
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-a -c -cidfile -d -dns -e -entrypoint -h -i -lxc-conf -m -n -p -privileged -t -u -v -volumes-from -w" -- "$cur" ) )
+			;;
+		*)
+			local counter=$cpos
+			while [ $counter -le $cword ]; do
+				case "${words[$counter]}" in
+					-a|-c|-cidfile|-dns|-e|-entrypoint|-h|-lxc-conf|-m|-p|-u|-v|-volumes-from|-w)
+						(( counter++ ))
+						;;
+					-*)
+						;;
+					*)
+						break
+						;;
+				esac
+				(( counter++ ))
+			done
+
+			if [ $counter -eq $cword ]; then
+				__docker_image_repos_and_tags
+			fi
+			;;
+	esac
+}
+
+_docker_search()
+{
+	COMPREPLY=( $( compgen -W "-notrunc" -- "$cur" ) )
+}
+
+_docker_start()
+{
+	__docker_containers_stopped
+}
+
+_docker_stop()
+{
+	case "$prev" in
+		-t)
+			return
+			;;
+		*)
+			;;
+	esac
+
+	case "$cur" in
+		-*)
+			COMPREPLY=( $( compgen -W "-t" -- "$cur" ) )
+			;;
+		*)
+			__docker_containers_running
+			;;
+	esac
+}
+
+_docker_tag()
+{
+	COMPREPLY=( $( compgen -W "-f" -- "$cur" ) )
+}
+
+_docker_top()
+{
+	if [ $cpos -eq $cword ]; then
+		__docker_containers_running
+	fi
+}
+
+_docker_version()
+{
+	return
+}
+
+_docker_wait()
+{
+	__docker_containers_all
+}
+
+_docker()
+{
+	local cur prev words cword command="docker" counter=1 word cpos
+	local commands="
+			attach
+			build
+			commit
+			cp
+			diff
+			events
+			export
+			history
+			images
+			import
+			info
+			insert
+			inspect
+			kill
+			login
+			logs
+			port
+			ps
+			pull
+			push
+			restart
+			rm
+			rmi
+			run
+			search
+			start
+			stop
+			tag
+			top
+			version
+			wait
+		"
+
+	COMPREPLY=()
+	_get_comp_words_by_ref -n : cur prev words cword
+
+	while [ $counter -lt $cword ]; do
+		word="${words[$counter]}"
+		case "$word" in
+			-H)
+				(( counter++ ))
+				;;
+			-*)
+				;;
+			*)
+				command="$word"
+				cpos=$counter
+				(( cpos++ ))
+				break
+				;;
+		esac
+		(( counter++ ))
+	done
+
+	local completions_func=_docker_${command}
+	declare -F $completions_func >/dev/null && $completions_func
+
+	return 0
+}
+
+complete -F _docker docker

contrib/completion/zsh/_docker

@@ -0,0 +1,242 @@
+#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 "$@"

contrib/crashTest.go

@@ -77,7 +77,7 @@ func crashTest() error {
 			stop = false
 			for i := 0; i < 100 && !stop; {
 				func() error {
-					cmd := exec.Command(DOCKERPATH, "run", "base", "echo", fmt.Sprintf("%d", totalTestCount))
+					cmd := exec.Command(DOCKERPATH, "run", "ubuntu", "echo", fmt.Sprintf("%d", totalTestCount))
 					i++
 					totalTestCount++
 					outPipe, err := cmd.StdoutPipe()

contrib/install.sh

@@ -1,55 +0,0 @@
-#!/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 http://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 and uncompressing into /usr/local/bin..."
-curl -s http://get.docker.io/builds/$(uname -s)/$(uname -m)/docker-latest.tgz |
-tar -C /usr/local/bin --strip-components=1 -zxf- \
-docker-latest/docker
-
-if [ -f /etc/init/dockerd.conf ]
-then
-  echo "Upstart script already exists."
-else
-  echo "Creating /etc/init/dockerd.conf..."
-  echo "exec env LANG=\"en_US.UTF-8\" /usr/local/bin/docker -d" > /etc/init/dockerd.conf
-fi
-
-echo "Starting dockerd..."
-start dockerd > /dev/null
-
-echo "Done."
-echo

contrib/mkimage-arch.sh

@@ -0,0 +1,65 @@
+#!/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 -c "
+  set timeout 60
+  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 }
+  }"
+
+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 -C $ROOTFS -c . | docker import - archlinux
+docker run -i -t archlinux echo Success.
+rm -rf $ROOTFS

contrib/mkimage-centos.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+# Create a CentOS base image for Docker
+# From unclejack https://github.com/dotcloud/docker/issues/290
+set -e
+
+MIRROR_URL="http://centos.netnitco.net/6.4/os/x86_64/"
+MIRROR_URL_UPDATES="http://centos.netnitco.net/6.4/updates/x86_64/"
+
+yum install -y febootstrap xz
+
+febootstrap -i bash -i coreutils -i tar -i bzip2 -i gzip -i vim-minimal -i wget -i patch -i diffutils -i iproute -i yum centos centos64  $MIRROR_URL -u $MIRROR_URL_UPDATES
+touch centos64/etc/resolv.conf
+touch centos64/sbin/init
+
+tar --numeric-owner -Jcpf centos-64.tar.xz -C centos64 .

contrib/mkimage-debian.sh

@@ -10,12 +10,18 @@ variant='minbase'
 include='iproute,iputils-ping'
 
 repo="$1"
-suite="${2:-$stableSuite}"
+suite="$2"
 mirror="${3:-}" # stick to the default debootstrap mirror if one is not provided
 
-if [ ! "$repo" ]; then
-	echo >&2 "usage: $0 repo [suite [mirror]]"
+if [ ! "$repo" ] || [ ! "$suite" ]; then
+	echo >&2 "usage: $0 repo suite [mirror]"
+	echo >&2
 	echo >&2 "   ie: $0 tianon/debian squeeze"
+	echo >&2 "       $0 tianon/debian squeeze http://ftp.uk.debian.org/debian/"
+	echo >&2
+	echo >&2 "   ie: $0 tianon/ubuntu precise"
+	echo >&2 "       $0 tianon/ubuntu precise http://mirrors.melbourne.co.uk/ubuntu/"
+	echo >&2
 	exit 1
 fi
 
@@ -32,22 +38,44 @@ sudo debootstrap --verbose --variant="$variant" --include="$include" "$suite" "$
 
 cd "$target"
 
-# create the image
-img=$(sudo tar -c . | docker import -)
+# 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
 
-# tag suite
-docker tag $img $repo $suite
+# 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
+
+# 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 $img $repo latest
+	docker tag $repo:$suite $repo latest
 	
 	# tag the specific debian release version
 	ver=$(docker run $repo:$suite cat /etc/debian_version)
-	docker tag $img $repo $ver
+	docker tag $repo:$suite $repo $ver
 fi
 
 # cleanup

contrib/vim-syntax/LICENSE

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

contrib/vim-syntax/README.md

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

contrib/vim-syntax/doc/dockerfile.txt

@@ -0,0 +1,18 @@
+*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:

contrib/vim-syntax/ftdetect/dockerfile.vim

@@ -0,0 +1 @@
+au BufNewFile,BufRead Dockerfile set filetype=dockerfile

contrib/vim-syntax/syntax/dockerfile.vim

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

docker/docker.go

@@ -16,28 +16,34 @@ import (
 
 var (
 	GITCOMMIT string
+	VERSION   string
 )
 
 func main() {
-	if utils.SelfPath() == "/sbin/init" {
+	if selfPath := utils.SelfPath(); selfPath == "/sbin/init" || selfPath == "/.dockerinit" {
 		// Running in init mode
 		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, "Daemon mode")
 	flDebug := flag.Bool("D", false, "Debug mode")
-	flAutoRestart := flag.Bool("r", false, "Restart previously running containers")
+	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", "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("tcp://%s:%d", docker.DEFAULTHTTPHOST, docker.DEFAULTHTTPPORT)}
+	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")
 	flag.Parse()
+	if *flVersion {
+		showVersion()
+		return
+	}
 	if len(flHosts) > 1 {
-		flHosts = flHosts[1:] //trick to display a nice defaul value in the usage
+		flHosts = flHosts[1:] //trick to display a nice default value in the usage
 	}
 	for i, flHost := range flHosts {
 		flHosts[i] = utils.ParseHost(docker.DEFAULTHTTPHOST, docker.DEFAULTHTTPPORT, flHost)
@@ -52,6 +58,7 @@ func main() {
 		os.Setenv("DEBUG", "1")
 	}
 	docker.GITCOMMIT = GITCOMMIT
+	docker.VERSION = VERSION
 	if *flDaemon {
 		if flag.NArg() != 0 {
 			flag.Usage()
@@ -68,12 +75,19 @@ func main() {
 		}
 		protoAddrParts := strings.SplitN(flHosts[0], "://", 2)
 		if err := docker.ParseCommands(protoAddrParts[0], protoAddrParts[1], flag.Args()...); err != nil {
+			if sterr, ok := err.(*utils.StatusError); ok {
+				os.Exit(sterr.Status)
+			}
 			log.Fatal(err)
 			os.Exit(-1)
 		}
 	}
 }
 
+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))

docs/Dockerfile

@@ -0,0 +1,15 @@
+from ubuntu:12.04
+maintainer Nick Stinemates
+
+run apt-get update
+run apt-get install -y python-setuptools make
+run easy_install pip
+add . /docs
+run pip install -r /docs/requirements.txt
+run cd /docs; make docs
+
+expose 8000
+
+workdir /docs/_build/html
+
+entrypoint ["python", "-m", "SimpleHTTPServer"]

docs/MAINTAINERS

@@ -1,2 +1,2 @@
-Andy Rothfusz <andy@dotcloud.com>
-Ken Cochrane <ken@dotcloud.com>
+Andy Rothfusz <andy@dotcloud.com> (@metalivedev)
+Ken Cochrane <ken@dotcloud.com> (@kencochrane)

docs/README.md

@@ -1,53 +1,102 @@
-Docker documentation and website
-================================
+Docker Documentation
+====================
 
-Documentation
--------------
-This is your definite place to contribute to the docker documentation. The documentation is generated from the
-.rst files under sources.
+Overview
+--------
 
-The folder also contains the other files to create the http://docker.io website, but you can generally ignore
-most of those.
+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.
 
+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. 
 
-Installation
-------------
+**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
+...................
 
-* 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.
+
 Usage
 -----
-* 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.
+* 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.
 
 Working using GitHub's file editor
 ----------------------------------
-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 carefull not to create many commits.
+
+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.
 
 Images
 ------
-When you need to add images, try to make them as small as possible (e.g. as gif).
 
+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.
 
 Notes
 -----
-* The index.html and gettingstarted.html files are copied from the source dir to the output dir without modification.
-So changes to those pages should be made directly in html
 * For the template the css is compiled from less. When changes are needed they can be compiled using
 lessc ``lessc main.less`` or watched using watch-lessc ``watch-lessc -i main.less -o main.css``
 
-
 Guides on using sphinx
 ----------------------
-* To make links to certain pages create a link target like so:
+* To make links to certain sections create a link target like so:
 
   ```
     .. _hello_world:
@@ -58,7 +107,10 @@ Guides on using sphinx
     This is.. (etc.)
   ```
 
-  The ``_hello_world:`` will make it possible to link to this position (page and marker) from all other pages.
+  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.
 
 * Notes, warnings and alarms
 
@@ -74,4 +126,17 @@ Guides on using sphinx
 
 * Code examples
 
-  Start without $, so it's easy to copy and paste.
+  * 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).
+
+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
+

docs/sources/api/MAINTAINERS

@@ -1 +1 @@
-Solomon Hykes <solomon@dotcloud.com>
+Solomon Hykes <solomon@dotcloud.com> (@shykes)

docs/sources/api/docker_remote_api.rst

@@ -9,13 +9,13 @@
 Docker Remote API
 =================
 
-.. contents:: Table of Contents
 
 1. Brief introduction
 =====================
 
 - The Remote API is replacing rcli
-- Default port in the docker deamon is 4243 
+- By default the Docker daemon listens on unix:///var/run/docker.sock and the client must have root access to interact with the daemon
+- If a group named *docker* exists on your system, docker will apply ownership of the socket to the group
 - 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
@@ -26,29 +26,94 @@ Docker Remote API
 2. Versions
 ===========
 
-The current verson of the API is 1.4
+The current version of the API is 1.6
 
 Calling /images/<name>/insert is the same as calling
-/v1.4/images/<name>/insert 
+/v1.6/images/<name>/insert
 
 You can still call an old version of the api using
 /v1.0/images/<name>/insert
 
-:doc:`docker_remote_api_v1.4`
-*****************************
+v1.6
+****
+
+Full Documentation
+------------------
+
+:doc:`docker_remote_api_v1.6`
 
 What's new
 ----------
 
+.. http:post:: /containers/(id)/attach
+
+   **New!** You can now split stderr from stdout. This is done by prefixing
+   a header to each transmition. See :http:post:`/containers/(id)/attach`.
+   The WebSocket attach is unchanged.
+   Note that attach calls on the previous API version didn't change. Stdout and
+   stderr are merged.
+
+
+v1.5
+****
+
+Full Documentation
+------------------
+
+:doc:`docker_remote_api_v1.5`
+
+What's new
+----------
+
+.. http:post:: /images/create
+
+   **New!** You can now pass registry credentials (via an AuthConfig object)
+   through the `X-Registry-Auth` header
+
+.. http:post:: /images/(name)/push
+
+   **New!** The AuthConfig object now needs to be passed through 
+   the `X-Registry-Auth` header
+
+.. http:get:: /containers/json
+
+   **New!** The format of the `Ports` entry has been changed to a list of
+   dicts each containing `PublicPort`, `PrivatePort` and `Type` describing a
+   port mapping.
+
+v1.4
+****
+
+Full Documentation
+------------------
+
+:doc:`docker_remote_api_v1.4`
+
+What's new
+----------
+
+.. http:post:: /images/create
+
+   **New!** When pulling a repo, all images are now downloaded in parallel.
+
 .. http:get:: /containers/(id)/top
 
    **New!** You can now use ps args with docker top, like `docker top <container_id> aux`
 
-:doc:`docker_remote_api_v1.3`
-*****************************
+.. http:get:: /events:
+
+   **New!** Image's name added in the events
+
+v1.3
+****
 
 docker v0.5.0 51f6c4a_
 
+Full Documentation
+------------------
+
+:doc:`docker_remote_api_v1.3`
+
 What's new
 ----------
 
@@ -81,11 +146,16 @@ Start containers (/containers/<id>/start):
 - You can now pass host-specific configuration (e.g. bind mounts) in
   the POST body for start calls
 
-:doc:`docker_remote_api_v1.2`
-*****************************
+v1.2
+****
 
 docker v0.4.2 2e7649b_
 
+Full Documentation
+------------------
+
+:doc:`docker_remote_api_v1.2`
+
 What's new
 ----------
 
@@ -103,7 +173,7 @@ The client should send it's authConfig as POST on each call of
   Only checks the configuration but doesn't store it on the server
 
   Deleting an image is now improved, will only untag the image if it
-  has chidren and remove all the untagged parents if has any.
+  has children and remove all the untagged parents if has any.
 
 .. http:post:: /images/<name>/delete 
 
@@ -111,11 +181,16 @@ The client should send it's authConfig as POST on each call of
   deleted/untagged.
 
 
-:doc:`docker_remote_api_v1.1`
-*****************************
+v1.1
+****
 
 docker v0.4.0 a8ae398_
 
+Full Documentation
+------------------
+
+:doc:`docker_remote_api_v1.1`
+
 What's new
 ----------
 
@@ -135,12 +210,16 @@ What's new
 	   {"error":"Invalid..."}
 	   ...
 
-
-:doc:`docker_remote_api_v1.0`
-*****************************
+v1.0
+****
 
 docker v0.3.4 8d73740_
 
+Full Documentation
+------------------
+
+:doc:`docker_remote_api_v1.0`
+
 What's new
 ----------
 
@@ -151,32 +230,3 @@ Initial version
 .. _8d73740: https://github.com/dotcloud/docker/commit/8d73740343778651c09160cde9661f5f387b36f4
 .. _2e7649b: https://github.com/dotcloud/docker/commit/2e7649beda7c820793bd46766cbc2cfeace7b168
 .. _51f6c4a: https://github.com/dotcloud/docker/commit/51f6c4a7372450d164c61e0054daf0223ddbd909
-
-==================================
-Docker Remote API Client Libraries
-==================================
-
-These libraries have been not tested by the Docker Maintainers for
-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                                 |
-+======================+================+============================================+
-| Python               | docker-py      | https://github.com/dotcloud/docker-py      |
-+----------------------+----------------+--------------------------------------------+
-| Ruby                 | docker-ruby    | https://github.com/ActiveState/docker-ruby |
-+----------------------+----------------+--------------------------------------------+
-| Ruby                 | docker-client  | https://github.com/geku/docker-client      |
-+----------------------+----------------+--------------------------------------------+
-| Ruby                 | docker-api     | https://github.com/swipely/docker-api      |
-+----------------------+----------------+--------------------------------------------+
-| 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     |
-+----------------------+----------------+--------------------------------------------+
-

docs/sources/api/docker_remote_api_v1.0.rst

@@ -17,7 +17,7 @@ Docker Remote API v1.0
 =====================
 
 - The Remote API is replacing rcli
-- Default port in the docker deamon is 4243 
+- 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
@@ -49,28 +49,28 @@ List containers
 	   [
 		{
 			"Id": "8dfafdbc3a40",
-			"Image": "base:latest",
+			"Image": "ubuntu:latest",
 			"Command": "echo 1",
 			"Created": 1367854155,
 			"Status": "Exit 0"
 		},
 		{
 			"Id": "9cd87474be90",
-			"Image": "base:latest",
+			"Image": "ubuntu:latest",
 			"Command": "echo 222222",
 			"Created": 1367854155,
 			"Status": "Exit 0"
 		},
 		{
 			"Id": "3176a2479c92",
-			"Image": "base:latest",
+			"Image": "centos:latest",
 			"Command": "echo 3333333333333333",
 			"Created": 1367854154,
 			"Status": "Exit 0"
 		},
 		{
 			"Id": "4cb07b47f9fb",
-			"Image": "base:latest",
+			"Image": "fedora:latest",
 			"Command": "echo 444444444444444444444444444444444",
 			"Created": 1367854152,
 			"Status": "Exit 0"
@@ -117,7 +117,7 @@ Create a container
 			"date"
 		],
 		"Dns":null,
-		"Image":"base",
+		"Image":"ubuntu",
 		"Volumes":{},
 		"VolumesFrom":""
 	   }
@@ -183,7 +183,7 @@ Inspect a container
 					"date"
 				],
 				"Dns": null,
-				"Image": "base",
+				"Image": "ubuntu",
 				"Volumes": {},
 				"VolumesFrom": ""
 			},
@@ -490,14 +490,14 @@ List Images
 	   
 	   [
 		{
-			"Repository":"base",
-			"Tag":"ubuntu-12.10",
+			"Repository":"ubuntu",
+			"Tag":"precise",
 			"Id":"b750fe79269d",
 			"Created":1364102658
 		},
 		{
-			"Repository":"base",
-			"Tag":"ubuntu-quantal",
+			"Repository":"ubuntu",
+			"Tag":"12.04",
 			"Id":"b750fe79269d",
 			"Created":1364102658
 		}
@@ -529,9 +529,9 @@ List Images
 	   "d6434d954665" -> "d82cbacda43a"
 	   base -> "e9aa60c60128" [style=invis]
 	   "074be284591f" -> "f71189fff3de"
-	   "b750fe79269d" [label="b750fe79269d\nbase",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
-	   "e9aa60c60128" [label="e9aa60c60128\nbase2",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
-	   "9a33b36209ed" [label="9a33b36209ed\ntest",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "b750fe79269d" [label="b750fe79269d\nubuntu",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "e9aa60c60128" [label="e9aa60c60128\ncentos",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "9a33b36209ed" [label="9a33b36209ed\nfedora",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
 	   base [style=invisible]
 	   }
  
@@ -552,7 +552,7 @@ Create an image
 
         .. sourcecode:: http
 
-           POST /images/create?fromImage=base HTTP/1.1
+           POST /images/create?fromImage=ubuntu HTTP/1.1
 
         **Example response**:
 
@@ -572,8 +572,8 @@ Create an image
         :statuscode 500: server error
 
 
-Insert a file in a image
-************************
+Insert a file in an image
+*************************
 
 .. http:post:: /images/(name)/insert
 
@@ -608,7 +608,7 @@ Inspect an image
 
 	.. sourcecode:: http
 
-	   GET /images/base/json HTTP/1.1
+	   GET /images/centos/json HTTP/1.1
 
 	**Example response**:
 
@@ -638,7 +638,7 @@ Inspect an image
 				"Env":null,
 				"Cmd": ["/bin/bash"]
 				,"Dns":null,
-				"Image":"base",
+				"Image":"centos",
 				"Volumes":null,
 				"VolumesFrom":""
 			}
@@ -660,7 +660,7 @@ Get the history of an image
 
         .. sourcecode:: http
 
-           GET /images/base/history HTTP/1.1
+           GET /images/fedora/history HTTP/1.1
 
         **Example response**:
 
@@ -832,7 +832,7 @@ Build an image from Dockerfile via stdin
 	   
 	   {{ STREAM }}
 
-	:query t: tag to be applied to the resulting image in case of success
+	:query t: repository name to be applied to the resulting image in case of success
 	:statuscode 200: no error
         :statuscode 500: server error
 

docs/sources/api/docker_remote_api_v1.1.rst

@@ -17,7 +17,7 @@ Docker Remote API v1.1
 =====================
 
 - The Remote API is replacing rcli
-- Default port in the docker deamon is 4243 
+- 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
@@ -49,28 +49,28 @@ List containers
 	   [
 		{
 			"Id": "8dfafdbc3a40",
-			"Image": "base:latest",
+			"Image": "ubuntu:latest",
 			"Command": "echo 1",
 			"Created": 1367854155,
 			"Status": "Exit 0"
 		},
 		{
 			"Id": "9cd87474be90",
-			"Image": "base:latest",
+			"Image": "ubuntu:latest",
 			"Command": "echo 222222",
 			"Created": 1367854155,
 			"Status": "Exit 0"
 		},
 		{
 			"Id": "3176a2479c92",
-			"Image": "base:latest",
+			"Image": "centos:latest",
 			"Command": "echo 3333333333333333",
 			"Created": 1367854154,
 			"Status": "Exit 0"
 		},
 		{
 			"Id": "4cb07b47f9fb",
-			"Image": "base:latest",
+			"Image": "fedora:latest",
 			"Command": "echo 444444444444444444444444444444444",
 			"Created": 1367854152,
 			"Status": "Exit 0"
@@ -117,7 +117,7 @@ Create a container
 			"date"
 		],
 		"Dns":null,
-		"Image":"base",
+		"Image":"ubuntu",
 		"Volumes":{},
 		"VolumesFrom":""
 	   }
@@ -183,7 +183,7 @@ Inspect a container
 					"date"
 				],
 				"Dns": null,
-				"Image": "base",
+				"Image": "ubuntu",
 				"Volumes": {},
 				"VolumesFrom": ""
 			},
@@ -305,8 +305,8 @@ Start a container
 	:statuscode 500: server error
 
 
-Stop a contaier
-***************
+Stop a container
+****************
 
 .. http:post:: /containers/(id)/stop
 
@@ -490,14 +490,14 @@ List Images
 	   
 	   [
 		{
-			"Repository":"base",
-			"Tag":"ubuntu-12.10",
+			"Repository":"ubuntu",
+			"Tag":"precise",
 			"Id":"b750fe79269d",
 			"Created":1364102658
 		},
 		{
-			"Repository":"base",
-			"Tag":"ubuntu-quantal",
+			"Repository":"ubuntu",
+			"Tag":"12.04",
 			"Id":"b750fe79269d",
 			"Created":1364102658
 		}
@@ -529,9 +529,9 @@ List Images
 	   "d6434d954665" -> "d82cbacda43a"
 	   base -> "e9aa60c60128" [style=invis]
 	   "074be284591f" -> "f71189fff3de"
-	   "b750fe79269d" [label="b750fe79269d\nbase",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
-	   "e9aa60c60128" [label="e9aa60c60128\nbase2",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
-	   "9a33b36209ed" [label="9a33b36209ed\ntest",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "b750fe79269d" [label="b750fe79269d\nubuntu",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "e9aa60c60128" [label="e9aa60c60128\ncentos",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "9a33b36209ed" [label="9a33b36209ed\nfedora",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
 	   base [style=invisible]
 	   }
  
@@ -552,7 +552,7 @@ Create an image
 
         .. sourcecode:: http
 
-           POST /images/create?fromImage=base HTTP/1.1
+           POST /images/create?fromImage=ubuntu HTTP/1.1
 
         **Example response**:
 
@@ -575,8 +575,8 @@ Create an image
         :statuscode 500: server error
 
 
-Insert a file in a image
-************************
+Insert a file in an image
+*************************
 
 .. http:post:: /images/(name)/insert
 
@@ -615,7 +615,7 @@ Inspect an image
 
 	.. sourcecode:: http
 
-	   GET /images/base/json HTTP/1.1
+	   GET /images/centos/json HTTP/1.1
 
 	**Example response**:
 
@@ -645,7 +645,7 @@ Inspect an image
 				"Env":null,
 				"Cmd": ["/bin/bash"]
 				,"Dns":null,
-				"Image":"base",
+				"Image":"centos",
 				"Volumes":null,
 				"VolumesFrom":""
 			}
@@ -667,7 +667,7 @@ Get the history of an image
 
         .. sourcecode:: http
 
-           GET /images/base/history HTTP/1.1
+           GET /images/fedora/history HTTP/1.1
 
         **Example response**:
 

docs/sources/api/docker_remote_api_v1.2.rst

@@ -17,7 +17,7 @@ Docker Remote API v1.2
 =====================
 
 - The Remote API is replacing rcli
-- Default port in the docker deamon is 4243 
+- 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
@@ -49,7 +49,7 @@ List containers
 	   [
 		{
 			"Id": "8dfafdbc3a40",
-			"Image": "base:latest",
+			"Image": "ubuntu:latest",
 			"Command": "echo 1",
 			"Created": 1367854155,
 			"Status": "Exit 0",
@@ -59,7 +59,7 @@ List containers
 		},
 		{
 			"Id": "9cd87474be90",
-			"Image": "base:latest",
+			"Image": "ubuntu:latest",
 			"Command": "echo 222222",
 			"Created": 1367854155,
 			"Status": "Exit 0",
@@ -69,7 +69,7 @@ List containers
 		},
 		{
 			"Id": "3176a2479c92",
-			"Image": "base:latest",
+			"Image": "centos:latest",
 			"Command": "echo 3333333333333333",
 			"Created": 1367854154,
 			"Status": "Exit 0",
@@ -79,7 +79,7 @@ List containers
 		},
 		{
 			"Id": "4cb07b47f9fb",
-			"Image": "base:latest",
+			"Image": "fedora:latest",
 			"Command": "echo 444444444444444444444444444444444",
 			"Created": 1367854152,
 			"Status": "Exit 0",
@@ -129,7 +129,7 @@ Create a container
 			"date"
 		],
 		"Dns":null,
-		"Image":"base",
+		"Image":"ubuntu",
 		"Volumes":{},
 		"VolumesFrom":""
 	   }
@@ -195,7 +195,7 @@ Inspect a container
 					"date"
 				],
 				"Dns": null,
-				"Image": "base",
+				"Image": "ubuntu",
 				"Volumes": {},
 				"VolumesFrom": ""
 			},
@@ -317,8 +317,8 @@ Start a container
 	:statuscode 500: server error
 
 
-Stop a contaier
-***************
+Stop a container
+****************
 
 .. http:post:: /containers/(id)/stop
 
@@ -502,16 +502,16 @@ List Images
 	   
 	   [
 		{
-			"Repository":"base",
-			"Tag":"ubuntu-12.10",
+			"Repository":"ubuntu",
+			"Tag":"precise",
 			"Id":"b750fe79269d",
 			"Created":1364102658,
 			"Size":24653,
 			"VirtualSize":180116135
 		},
 		{
-			"Repository":"base",
-			"Tag":"ubuntu-quantal",
+			"Repository":"ubuntu",
+			"Tag":"12.04",
 			"Id":"b750fe79269d",
 			"Created":1364102658,
 			"Size":24653,
@@ -545,9 +545,9 @@ List Images
 	   "d6434d954665" -> "d82cbacda43a"
 	   base -> "e9aa60c60128" [style=invis]
 	   "074be284591f" -> "f71189fff3de"
-	   "b750fe79269d" [label="b750fe79269d\nbase",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
-	   "e9aa60c60128" [label="e9aa60c60128\nbase2",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
-	   "9a33b36209ed" [label="9a33b36209ed\ntest",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "b750fe79269d" [label="b750fe79269d\nubuntu",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "e9aa60c60128" [label="e9aa60c60128\ncentos",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "9a33b36209ed" [label="9a33b36209ed\nfedora",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
 	   base [style=invisible]
 	   }
  
@@ -568,7 +568,7 @@ Create an image
 
         .. sourcecode:: http
 
-           POST /images/create?fromImage=base HTTP/1.1
+           POST /images/create?fromImage=ubuntu HTTP/1.1
 
         **Example response**:
 
@@ -591,8 +591,8 @@ Create an image
         :statuscode 500: server error
 
 
-Insert a file in a image
-************************
+Insert a file in an image
+*************************
 
 .. http:post:: /images/(name)/insert
 
@@ -631,7 +631,7 @@ Inspect an image
 
 	.. sourcecode:: http
 
-	   GET /images/base/json HTTP/1.1
+	   GET /images/centos/json HTTP/1.1
 
 	**Example response**:
 
@@ -661,7 +661,7 @@ Inspect an image
 				"Env":null,
 				"Cmd": ["/bin/bash"]
 				,"Dns":null,
-				"Image":"base",
+				"Image":"centos",
 				"Volumes":null,
 				"VolumesFrom":""
 			},
@@ -684,7 +684,7 @@ Get the history of an image
 
         .. sourcecode:: http
 
-           GET /images/base/history HTTP/1.1
+           GET /images/fedora/history HTTP/1.1
 
         **Example response**:
 
@@ -696,7 +696,7 @@ Get the history of an image
 	   [
 		{
 			"Id":"b750fe79269d",
-			"Tag":["base:latest"],
+			"Tag":["ubuntu:latest"],
 			"Created":1364102658,
 			"CreatedBy":"/bin/bash"
 		},
@@ -870,7 +870,7 @@ Build an image from Dockerfile via stdin
 	   
 	   {{ STREAM }}
 
-	:query t: tag to be applied to the resulting image in case of success
+	:query t: repository name to be applied to the resulting image in case of success
 	:query remote: resource to fetch, as URI
 	:statuscode 200: no error
         :statuscode 500: server error

docs/sources/api/docker_remote_api_v1.3.rst

@@ -17,7 +17,7 @@ Docker Remote API v1.3
 =====================
 
 - The Remote API is replacing rcli
-- Default port in the docker deamon is 4243 
+- 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
@@ -49,7 +49,7 @@ List containers
 	   [
 		{
 			"Id": "8dfafdbc3a40",
-			"Image": "base:latest",
+			"Image": "ubuntu:latest",
 			"Command": "echo 1",
 			"Created": 1367854155,
 			"Status": "Exit 0",
@@ -59,7 +59,7 @@ List containers
 		},
 		{
 			"Id": "9cd87474be90",
-			"Image": "base:latest",
+			"Image": "ubuntu:latest",
 			"Command": "echo 222222",
 			"Created": 1367854155,
 			"Status": "Exit 0",
@@ -69,7 +69,7 @@ List containers
 		},
 		{
 			"Id": "3176a2479c92",
-			"Image": "base:latest",
+			"Image": "centos:latest",
 			"Command": "echo 3333333333333333",
 			"Created": 1367854154,
 			"Status": "Exit 0",
@@ -79,7 +79,7 @@ List containers
 		},
 		{
 			"Id": "4cb07b47f9fb",
-			"Image": "base:latest",
+			"Image": "fedora:latest",
 			"Command": "echo 444444444444444444444444444444444",
 			"Created": 1367854152,
 			"Status": "Exit 0",
@@ -130,7 +130,7 @@ Create a container
 			"date"
 		],
 		"Dns":null,
-		"Image":"base",
+		"Image":"ubuntu",
 		"Volumes":{},
 		"VolumesFrom":""
 	   }
@@ -196,7 +196,7 @@ Inspect a container
 					"date"
 				],
 				"Dns": null,
-				"Image": "base",
+				"Image": "ubuntu",
 				"Volumes": {},
 				"VolumesFrom": ""
 			},
@@ -365,8 +365,8 @@ Start a container
         :statuscode 500: server error
 
 
-Stop a contaier
-***************
+Stop a container
+****************
 
 .. http:post:: /containers/(id)/stop
 
@@ -550,16 +550,16 @@ List Images
 	   
 	   [
 		{
-			"Repository":"base",
-			"Tag":"ubuntu-12.10",
+			"Repository":"ubuntu",
+			"Tag":"precise",
 			"Id":"b750fe79269d",
 			"Created":1364102658,
 			"Size":24653,
 			"VirtualSize":180116135
 		},
 		{
-			"Repository":"base",
-			"Tag":"ubuntu-quantal",
+			"Repository":"ubuntu",
+			"Tag":"12.04",
 			"Id":"b750fe79269d",
 			"Created":1364102658,
 			"Size":24653,
@@ -593,9 +593,9 @@ List Images
 	   "d6434d954665" -> "d82cbacda43a"
 	   base -> "e9aa60c60128" [style=invis]
 	   "074be284591f" -> "f71189fff3de"
-	   "b750fe79269d" [label="b750fe79269d\nbase",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
-	   "e9aa60c60128" [label="e9aa60c60128\nbase2",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
-	   "9a33b36209ed" [label="9a33b36209ed\ntest",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "b750fe79269d" [label="b750fe79269d\nubuntu",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "e9aa60c60128" [label="e9aa60c60128\ncentos",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "9a33b36209ed" [label="9a33b36209ed\nfedora",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
 	   base [style=invisible]
 	   }
  
@@ -616,7 +616,7 @@ Create an image
 
         .. sourcecode:: http
 
-           POST /images/create?fromImage=base HTTP/1.1
+           POST /images/create?fromImage=ubuntu HTTP/1.1
 
         **Example response**:
 
@@ -639,8 +639,8 @@ Create an image
         :statuscode 500: server error
 
 
-Insert a file in a image
-************************
+Insert a file in an image
+*************************
 
 .. http:post:: /images/(name)/insert
 
@@ -679,7 +679,7 @@ Inspect an image
 
 	.. sourcecode:: http
 
-	   GET /images/base/json HTTP/1.1
+	   GET /images/centos/json HTTP/1.1
 
 	**Example response**:
 
@@ -709,7 +709,7 @@ Inspect an image
 				"Env":null,
 				"Cmd": ["/bin/bash"]
 				,"Dns":null,
-				"Image":"base",
+				"Image":"centos",
 				"Volumes":null,
 				"VolumesFrom":""
 			},
@@ -732,7 +732,7 @@ Get the history of an image
 
         .. sourcecode:: http
 
-           GET /images/base/history HTTP/1.1
+           GET /images/fedora/history HTTP/1.1
 
         **Example response**:
 
@@ -925,7 +925,7 @@ Build an image from Dockerfile via stdin
 
         The Content-type header should be set to "application/tar".
 
-	:query t: tag to be applied to the resulting image in case of success
+	: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
 	:statuscode 200: no error
         :statuscode 500: server error

docs/sources/api/docker_remote_api_v1.4.rst

@@ -2,6 +2,8 @@
 :description: API Documentation for Docker
 :keywords: API, Docker, rcli, REST, documentation
 
+:orphan:
+
 ======================
 Docker Remote API v1.4
 ======================
@@ -12,7 +14,7 @@ Docker Remote API v1.4
 =====================
 
 - The Remote API is replacing rcli
-- Default port in the docker deamon is 4243 
+- 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
@@ -44,7 +46,7 @@ List containers
 	   [
 		{
 			"Id": "8dfafdbc3a40",
-			"Image": "base:latest",
+			"Image": "ubuntu:latest",
 			"Command": "echo 1",
 			"Created": 1367854155,
 			"Status": "Exit 0",
@@ -54,7 +56,7 @@ List containers
 		},
 		{
 			"Id": "9cd87474be90",
-			"Image": "base:latest",
+			"Image": "ubuntu:latest",
 			"Command": "echo 222222",
 			"Created": 1367854155,
 			"Status": "Exit 0",
@@ -64,7 +66,7 @@ List containers
 		},
 		{
 			"Id": "3176a2479c92",
-			"Image": "base:latest",
+			"Image": "centos:latest",
 			"Command": "echo 3333333333333333",
 			"Created": 1367854154,
 			"Status": "Exit 0",
@@ -74,7 +76,7 @@ List containers
 		},
 		{
 			"Id": "4cb07b47f9fb",
-			"Image": "base:latest",
+			"Image": "fedora:latest",
 			"Command": "echo 444444444444444444444444444444444",
 			"Created": 1367854152,
 			"Status": "Exit 0",
@@ -117,6 +119,7 @@ Create a container
 		"AttachStdout":true,
 		"AttachStderr":true,
 		"PortSpecs":null,
+		"Privileged": false,
 		"Tty":false,
 		"OpenStdin":false,
 		"StdinOnce":false,
@@ -125,9 +128,11 @@ Create a container
 			"date"
 		],
 		"Dns":null,
-		"Image":"base",
+		"Image":"ubuntu",
 		"Volumes":{},
-		"VolumesFrom":""
+		"VolumesFrom":"",
+		"WorkingDir":""
+
 	   }
 	   
 	**Example response**:
@@ -191,9 +196,11 @@ Inspect a container
 					"date"
 				],
 				"Dns": null,
-				"Image": "base",
+				"Image": "ubuntu",
 				"Volumes": {},
-				"VolumesFrom": ""
+				"VolumesFrom": "",
+				"WorkingDir":""
+
 			},
 			"State": {
 				"Running": false,
@@ -217,6 +224,7 @@ Inspect a container
 
 	:statuscode 200: no error
 	:statuscode 404: no such container
+	:statuscode 409: conflict between containers and images
 	:statuscode 500: server error
 
 
@@ -350,7 +358,8 @@ Start a container
            Content-Type: application/json
 
            {
-                "Binds":["/tmp:/tmp"]
+                "Binds":["/tmp:/tmp"],
+                "LxcConf":[{"Key":"lxc.utsname","Value":"docker"}]
            }
 
         **Example response**:
@@ -361,13 +370,13 @@ Start a container
            Content-Type: text/plain
 
         :jsonparam hostConfig: the container's host configuration (optional)
-        :statuscode 200: no error
+        :statuscode 204: no error
         :statuscode 404: no such container
         :statuscode 500: server error
 
 
-Stop a contaier
-***************
+Stop a container
+****************
 
 .. http:post:: /containers/(id)/stop
 
@@ -526,6 +535,38 @@ Remove a container
         :statuscode 500: server error
 
 
+Copy files or folders from a container
+**************************************
+
+.. http:post:: /containers/(id)/copy
+
+	Copy files or folders of container ``id``
+
+	**Example request**:
+
+	.. sourcecode:: http
+
+	   POST /containers/4fa6e0f0c678/copy HTTP/1.1
+	   Content-Type: application/json
+
+	   {
+		"Resource":"test.txt"
+	   }
+
+	**Example response**:
+
+	.. sourcecode:: http
+
+	   HTTP/1.1 200 OK
+	   Content-Type: application/octet-stream
+	   
+	   {{ STREAM }}
+
+	:statuscode 200: no error
+	:statuscode 404: no such container
+	:statuscode 500: server error
+
+
 2.2 Images
 ----------
 
@@ -551,16 +592,16 @@ List Images
 	   
 	   [
 		{
-			"Repository":"base",
-			"Tag":"ubuntu-12.10",
+			"Repository":"ubuntu",
+			"Tag":"precise",
 			"Id":"b750fe79269d",
 			"Created":1364102658,
 			"Size":24653,
 			"VirtualSize":180116135
 		},
 		{
-			"Repository":"base",
-			"Tag":"ubuntu-quantal",
+			"Repository":"ubuntu",
+			"Tag":"12.04",
 			"Id":"b750fe79269d",
 			"Created":1364102658,
 			"Size":24653,
@@ -594,9 +635,9 @@ List Images
 	   "d6434d954665" -> "d82cbacda43a"
 	   base -> "e9aa60c60128" [style=invis]
 	   "074be284591f" -> "f71189fff3de"
-	   "b750fe79269d" [label="b750fe79269d\nbase",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
-	   "e9aa60c60128" [label="e9aa60c60128\nbase2",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
-	   "9a33b36209ed" [label="9a33b36209ed\ntest",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "b750fe79269d" [label="b750fe79269d\nubuntu",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "e9aa60c60128" [label="e9aa60c60128\ncentos",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
+	   "9a33b36209ed" [label="9a33b36209ed\nfedora",shape=box,fillcolor="paleturquoise",style="filled,rounded"];
 	   base [style=invisible]
 	   }
  
@@ -617,7 +658,7 @@ Create an image
 
         .. sourcecode:: http
 
-           POST /images/create?fromImage=base HTTP/1.1
+           POST /images/create?fromImage=ubuntu HTTP/1.1
 
         **Example response**:
 
@@ -640,8 +681,8 @@ Create an image
         :statuscode 500: server error
 
 
-Insert a file in a image
-************************
+Insert a file in an image
+*************************
 
 .. http:post:: /images/(name)/insert
 
@@ -680,7 +721,7 @@ Inspect an image
 
 	.. sourcecode:: http
 
-	   GET /images/base/json HTTP/1.1
+	   GET /images/centos/json HTTP/1.1
 
 	**Example response**:
 
@@ -710,16 +751,18 @@ Inspect an image
 				"Env":null,
 				"Cmd": ["/bin/bash"]
 				,"Dns":null,
-				"Image":"base",
+				"Image":"centos",
 				"Volumes":null,
-				"VolumesFrom":""
+				"VolumesFrom":"",
+				"WorkingDir":""
 			},
 		"Size": 6824592
 	   }
 
 	:statuscode 200: no error
 	:statuscode 404: no such image
-        :statuscode 500: server error
+	:statuscode 409: conflict between containers and images
+	:statuscode 500: server error
 
 
 Get the history of an image
@@ -733,7 +776,7 @@ Get the history of an image
 
         .. sourcecode:: http
 
-           GET /images/base/history HTTP/1.1
+           GET /images/fedora/history HTTP/1.1
 
         **Example response**:
 
@@ -765,29 +808,29 @@ Push an image on the registry
 
 .. http:post:: /images/(name)/push
 
-	Push the image ``name`` on the registry
+   Push the image ``name`` on the registry
 
-	 **Example request**:
+   **Example request**:
 
-	 .. sourcecode:: http
+   .. sourcecode:: http
 
-	    POST /images/test/push HTTP/1.1
-	    {{ authConfig }}
+      POST /images/test/push HTTP/1.1
+      {{ authConfig }}
 
-	 **Example response**:
+   **Example response**:
 
-        .. sourcecode:: http
+   .. sourcecode:: http
 
-           HTTP/1.1 200 OK
-	   Content-Type: application/json
+    HTTP/1.1 200 OK
+    Content-Type: application/json
 
-	   {"status":"Pushing..."}
-	   {"status":"Pushing", "progress":"1/? (n/a)"}
-	   {"error":"Invalid..."}
-	   ...
+   {"status":"Pushing..."}
+   {"status":"Pushing", "progress":"1/? (n/a)"}
+   {"error":"Invalid..."}
+   ...
 
-	:query registry: the registry you wan to push, optional
-	:statuscode 200: no error
+   :query registry: the registry you wan to push, optional
+   :statuscode 200: no error
         :statuscode 404: no such image
         :statuscode 500: server error
 
@@ -900,36 +943,37 @@ 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
-	   
-	   {{ STREAM }}
+      POST /build HTTP/1.1
 
-	**Example response**:
+      {{ STREAM }}
 
-        .. sourcecode:: http
+   **Example response**:
 
-           HTTP/1.1 200 OK
-	   
-	   {{ STREAM }}
+   .. sourcecode:: http
+
+      HTTP/1.1 200 OK
+
+      {{ 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: tag to be applied to the resulting image in case of success
+	: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 500: server error
+    :statuscode 500: server error
 
 
 Check auth configuration
@@ -949,7 +993,8 @@ Check auth configuration
 	   {
 		"username":"hannibal",
 		"password:"xxxx",
-		"email":"hannibal@a-team.com"
+		"email":"hannibal@a-team.com",
+		"serveraddress":"https://index.docker.io/v1/"
 	   }
 
         **Example response**:
@@ -990,7 +1035,8 @@ Display system-wide information
 		"NFd": 11,
 		"NGoroutines":21,
 		"MemoryLimit":true,
-		"SwapLimit":false
+		"SwapLimit":false,
+		"IPv4Forwarding":true
 	   }
 
         :statuscode 200: no error
@@ -1032,31 +1078,61 @@ 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
+
+    **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
+
+
+Monitor Docker's events
+***********************
+
+.. http:get:: /events
+
+	Get events from docker, either in real time via streaming, or via polling (using `since`)
 
 	**Example request**:
 
-        .. sourcecode:: http
+	.. sourcecode:: http
 
-           POST /commit?container=44c004db4b17&m=message&repo=myrepo HTTP/1.1
+           POST /events?since=1374067924
 
         **Example response**:
 
         .. sourcecode:: http
 
-           HTTP/1.1 201 OK
-	   Content-Type: application/vnd.docker.raw-stream
+           HTTP/1.1 200 OK
+	   Content-Type: application/json
 
-           {"Id":"596069db4bf5"}
+	   {"status":"create","id":"dfdf82bd3881","from":"ubuntu:latest","time":1374067924}
+	   {"status":"start","id":"dfdf82bd3881","from":"ubuntu:latest","time":1374067924}
+	   {"status":"stop","id":"dfdf82bd3881","from":"ubuntu:latest","time":1374067966}
+	   {"status":"destroy","id":"dfdf82bd3881","from":"ubuntu:latest","time":1374067970}
 
-	: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
+	:query since: timestamp used for polling
+        :statuscode 200: no error
         :statuscode 500: server error
 
 
@@ -1088,6 +1164,8 @@ In this version of the API, /attach, uses hijacking to transport stdin, stdout a
 -----------------
 
 To enable cross origin requests to the remote api add the flag "-api-enable-cors" when running docker in daemon mode.
-    
-    docker -d -H="192.168.1.9:4243" -api-enable-cors
+
+.. code-block:: bash
+
+   docker -d -H="192.168.1.9:4243" -api-enable-cors
 

docs/sources/api/index_api.rst

@@ -6,8 +6,6 @@
 Docker Index API
 =================
 
-.. contents:: Table of Contents
-
 1. Brief introduction
 =====================
 
@@ -42,7 +40,7 @@ User Repo
         Authorization: Basic akmklmasadalkm==
         X-Docker-Token: true
 
-        [{“id”: “9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f”}]
+        [{"id": "9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f"}]
 
     :parameter namespace: the namespace for the repo
     :parameter repo_name: the name for the repo
@@ -54,7 +52,8 @@ User Repo
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
-        WWW-Authenticate: Token signature=123abc,repository=”foo/bar”,access=write
+        WWW-Authenticate: Token signature=123abc,repository="foo/bar",access=write
+        X-Docker-Token: signature=123abc,repository="foo/bar",access=write
         X-Docker-Endpoints: registry-1.docker.io [, registry-2.docker.io]
 
         ""
@@ -92,7 +91,8 @@ User Repo
         HTTP/1.1 202
         Vary: Accept
         Content-Type: application/json
-        WWW-Authenticate: Token signature=123abc,repository=”foo/bar”,access=delete
+        WWW-Authenticate: Token signature=123abc,repository="foo/bar",access=delete
+        X-Docker-Token: signature=123abc,repository="foo/bar",access=delete
         X-Docker-Endpoints: registry-1.docker.io [, registry-2.docker.io]
 
         ""
@@ -124,7 +124,7 @@ Library Repo
         Authorization: Basic akmklmasadalkm==
         X-Docker-Token: true
 
-        [{“id”: “9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f”}]
+        [{"id": "9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f"}]
 
     :parameter repo_name:  the library name for the repo
 
@@ -135,7 +135,8 @@ Library Repo
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
-        WWW-Authenticate: Token signature=123abc,repository=”library/foobar”,access=write
+        WWW-Authenticate: Token signature=123abc,repository="library/foobar",access=write
+        X-Docker-Token: signature=123abc,repository="foo/bar",access=write
         X-Docker-Endpoints: registry-1.docker.io [, registry-2.docker.io]
 
         ""
@@ -174,7 +175,8 @@ Library Repo
         HTTP/1.1 202
         Vary: Accept
         Content-Type: application/json
-        WWW-Authenticate: Token signature=123abc,repository=”library/foobar”,access=delete
+        WWW-Authenticate: Token signature=123abc,repository="library/foobar",access=delete
+        X-Docker-Token: signature=123abc,repository="foo/bar",access=delete
         X-Docker-Endpoints: registry-1.docker.io [, registry-2.docker.io]
 
         ""
@@ -205,8 +207,8 @@ User Repo Images
         Content-Type: application/json
         Authorization: Basic akmklmasadalkm==
 
-        [{“id”: “9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f”,
-        “checksum”: “b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087”}]
+        [{"id": "9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f",
+        "checksum": "b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087"}]
 
     :parameter namespace: the namespace for the repo
     :parameter repo_name: the name for the repo
@@ -250,10 +252,10 @@ User Repo Images
         Vary: Accept
         Content-Type: application/json
 
-        [{“id”: “9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f”,
-        “checksum”: “b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087”},
-        {“id”: “ertwetewtwe38722009fe6857087b486531f9a779a0c1dfddgfgsdgdsgds”,
-        “checksum”: “34t23f23fc17e3ed29dae8f12c4f9e89cc6f0bsdfgfsdgdsgdsgerwgew”}]
+        [{"id": "9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f",
+        "checksum": "b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087"},
+        {"id": "ertwetewtwe38722009fe6857087b486531f9a779a0c1dfddgfgsdgdsgds",
+        "checksum": "34t23f23fc17e3ed29dae8f12c4f9e89cc6f0bsdfgfsdgdsgdsgerwgew"}]
 
     :statuscode 200: OK
     :statuscode 404: Not found
@@ -275,8 +277,8 @@ Library Repo Images
         Content-Type: application/json
         Authorization: Basic akmklmasadalkm==
 
-        [{“id”: “9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f”,
-        “checksum”: “b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087”}]
+        [{"id": "9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f",
+        "checksum": "b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087"}]
 
     :parameter repo_name: the library name for the repo
 
@@ -318,10 +320,10 @@ Library Repo Images
         Vary: Accept
         Content-Type: application/json
 
-        [{“id”: “9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f”,
-        “checksum”: “b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087”},
-        {“id”: “ertwetewtwe38722009fe6857087b486531f9a779a0c1dfddgfgsdgdsgds”,
-        “checksum”: “34t23f23fc17e3ed29dae8f12c4f9e89cc6f0bsdfgfsdgdsgdsgerwgew”}]
+        [{"id": "9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f",
+        "checksum": "b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087"},
+        {"id": "ertwetewtwe38722009fe6857087b486531f9a779a0c1dfddgfgsdgdsgds",
+        "checksum": "34t23f23fc17e3ed29dae8f12c4f9e89cc6f0bsdfgfsdgdsgdsgerwgew"}]
 
     :statuscode 200: OK
     :statuscode 404: Not found
@@ -541,10 +543,11 @@ Search
       Content-Type: application/json
 
       {"query":"search_term",
-        "num_results": 2,
+        "num_results": 3,
         "results" : [
-           {"name": "dotcloud/base", "description": "A base ubuntu64  image..."},
-           {"name": "base2", "description": "A base ubuntu64  image..."},
+           {"name": "ubuntu", "description": "An ubuntu image..."},
+           {"name": "centos", "description": "A centos image..."},
+           {"name": "fedora", "description": "A fedora image..."}
          ]
        }
 

docs/sources/api/registry_api.rst

@@ -6,7 +6,6 @@
 Docker Registry API
 ===================
 
-.. contents:: Table of Contents
 
 1. Brief introduction
 =====================
@@ -61,7 +60,7 @@ Layer
         Host: registry-1.docker.io
         Accept: application/json
         Content-Type: application/json
-        Authorization: Token akmklmasadalkmsdfgsdgdge33
+        Authorization: Token signature=123abc,repository="foo/bar",access=read
 
     :parameter image_id: the id for the layer you want to get
 
@@ -71,39 +70,10 @@ Layer
 
         HTTP/1.1 200
         Vary: Accept
-        Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
         Cookie: (Cookie provided by the Registry)
 
-        {
-            id: "088b4505aa3adc3d35e79c031fa126b403200f02f51920fbd9b7c503e87c7a2c",
-            parent: "aeee6396d62273d180a49c96c62e45438d87c7da4a5cf5d2be6bee4e21bc226f",
-            created: "2013-04-30T17:46:10.843673+03:00",
-            container: "8305672a76cc5e3d168f97221106ced35a76ec7ddbb03209b0f0d96bf74f6ef7",
-            container_config: {
-                Hostname: "host-test",
-                User: "",
-                Memory: 0,
-                MemorySwap: 0,
-                AttachStdin: false,
-                AttachStdout: false,
-                AttachStderr: false,
-                PortSpecs: null,
-                Tty: false,
-                OpenStdin: false,
-                StdinOnce: false,
-                Env: null,
-                Cmd: [
-                "/bin/bash",
-                "-c",
-                "apt-get -q -yy -f install libevent-dev"
-                ],
-                Dns: null,
-                Image: "imagename/blah",
-                Volumes: { },
-                VolumesFrom: ""
-            },
-            docker_version: "0.1.7"
-        }
+        {layer binary data stream}
 
     :statuscode 200: OK
     :statuscode 401: Requires authorization
@@ -120,40 +90,10 @@ Layer
 
         PUT /v1/images/088b4505aa3adc3d35e79c031fa126b403200f02f51920fbd9b7c503e87c7a2c/layer HTTP/1.1
         Host: registry-1.docker.io
-        Accept: application/json
-        Content-Type: application/json
-        Authorization: Token akmklmasadalkmsdfgsdgdge33
+        Transfer-Encoding: chunked
+        Authorization: Token signature=123abc,repository="foo/bar",access=write
 
-        {
-            id: "088b4505aa3adc3d35e79c031fa126b403200f02f51920fbd9b7c503e87c7a2c",
-            parent: "aeee6396d62273d180a49c96c62e45438d87c7da4a5cf5d2be6bee4e21bc226f",
-            created: "2013-04-30T17:46:10.843673+03:00",
-            container: "8305672a76cc5e3d168f97221106ced35a76ec7ddbb03209b0f0d96bf74f6ef7",
-            container_config: {
-                Hostname: "host-test",
-                User: "",
-                Memory: 0,
-                MemorySwap: 0,
-                AttachStdin: false,
-                AttachStdout: false,
-                AttachStderr: false,
-                PortSpecs: null,
-                Tty: false,
-                OpenStdin: false,
-                StdinOnce: false,
-                Env: null,
-                Cmd: [
-                "/bin/bash",
-                "-c",
-                "apt-get -q -yy -f install libevent-dev"
-                ],
-                Dns: null,
-                Image: "imagename/blah",
-                Volumes: { },
-                VolumesFrom: ""
-            },
-            docker_version: "0.1.7"
-        }
+        {layer binary data stream}
 
     :parameter image_id: the id for the layer you want to get
 
@@ -165,6 +105,7 @@ Layer
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
 
         ""
 
@@ -191,13 +132,38 @@ Image
         Cookie: (Cookie provided by the Registry)
 
         {
-         “id”: “088b4505aa3adc3d35e79c031fa126b403200f02f51920fbd9b7c503e87c7a2c”,
-         “checksum”:  “sha256:b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087”
-         }
+            id: "088b4505aa3adc3d35e79c031fa126b403200f02f51920fbd9b7c503e87c7a2c",
+            parent: "aeee6396d62273d180a49c96c62e45438d87c7da4a5cf5d2be6bee4e21bc226f",
+            created: "2013-04-30T17:46:10.843673+03:00",
+            container: "8305672a76cc5e3d168f97221106ced35a76ec7ddbb03209b0f0d96bf74f6ef7",
+            container_config: {
+                Hostname: "host-test",
+                User: "",
+                Memory: 0,
+                MemorySwap: 0,
+                AttachStdin: false,
+                AttachStdout: false,
+                AttachStderr: false,
+                PortSpecs: null,
+                Tty: false,
+                OpenStdin: false,
+                StdinOnce: false,
+                Env: null,
+                Cmd: [
+                "/bin/bash",
+                "-c",
+                "apt-get -q -yy -f install libevent-dev"
+                ],
+                Dns: null,
+                Image: "imagename/blah",
+                Volumes: { },
+                VolumesFrom: ""
+            },
+            docker_version: "0.1.7"
+        }
 
     :parameter image_id: the id for the layer you want to get
 
-
     **Example Response**:
 
     .. sourcecode:: http
@@ -205,6 +171,7 @@ Image
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
 
         ""
 
@@ -234,11 +201,40 @@ Image
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
+        X-Docker-Size: 456789
+        X-Docker-Checksum: b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087
 
         {
-         “id”: “088b4505aa3adc3d35e79c031fa126b403200f02f51920fbd9b7c503e87c7a2c”,
-         “checksum”:  “sha256:b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087”
-         }
+            id: "088b4505aa3adc3d35e79c031fa126b403200f02f51920fbd9b7c503e87c7a2c",
+            parent: "aeee6396d62273d180a49c96c62e45438d87c7da4a5cf5d2be6bee4e21bc226f",
+            created: "2013-04-30T17:46:10.843673+03:00",
+            container: "8305672a76cc5e3d168f97221106ced35a76ec7ddbb03209b0f0d96bf74f6ef7",
+            container_config: {
+                Hostname: "host-test",
+                User: "",
+                Memory: 0,
+                MemorySwap: 0,
+                AttachStdin: false,
+                AttachStdout: false,
+                AttachStderr: false,
+                PortSpecs: null,
+                Tty: false,
+                OpenStdin: false,
+                StdinOnce: false,
+                Env: null,
+                Cmd: [
+                "/bin/bash",
+                "-c",
+                "apt-get -q -yy -f install libevent-dev"
+                ],
+                Dns: null,
+                Image: "imagename/blah",
+                Volumes: { },
+                VolumesFrom: ""
+            },
+            docker_version: "0.1.7"
+        }
 
     :statuscode 200: OK
     :statuscode 401: Requires authorization
@@ -271,6 +267,7 @@ Ancestry
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
 
         ["088b4502f51920fbd9b7c503e87c7a2c05aa3adc3d35e79c031fa126b403200f",
          "aeee63968d87c7da4a5cf5d2be6bee4e21bc226fd62273d180a49c96c62e4543",
@@ -297,6 +294,7 @@ Ancestry
         Host: registry-1.docker.io
         Accept: application/json
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
         Cookie: (Cookie provided by the Registry)
 
     :parameter namespace: namespace for the repo
@@ -309,10 +307,11 @@ Ancestry
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
 
         {
             "latest": "9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f",
-            “0.1.1”:  “b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087”
+            "0.1.1":  "b486531f9a779a0c17e3ed29dae8f12c4f9e89cc6f0bc3c38722009fe6857087"
         }
 
     :statuscode 200: OK
@@ -332,6 +331,7 @@ Ancestry
         Host: registry-1.docker.io
         Accept: application/json
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
         Cookie: (Cookie provided by the Registry)
 
     :parameter namespace: namespace for the repo
@@ -345,6 +345,7 @@ Ancestry
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
 
         "9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f"
 
@@ -377,6 +378,7 @@ Ancestry
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
 
         ""
 
@@ -399,7 +401,7 @@ Ancestry
         Content-Type: application/json
         Cookie: (Cookie provided by the Registry)
 
-        “9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f”
+        "9e89cc6f0bc3c38722009fe6857087b486531f9a779a0c17e3ed29dae8f12c4f"
 
     :parameter namespace: namespace for the repo
     :parameter repository: name for the repo
@@ -412,6 +414,7 @@ Ancestry
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
 
         ""
 
@@ -449,6 +452,7 @@ Ancestry
         HTTP/1.1 200
         Vary: Accept
         Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
 
         ""
 
@@ -456,8 +460,41 @@ Ancestry
     :statuscode 401: Requires authorization
     :statuscode 404: Repository not found
 
-3.0 Authorization
-=================
+2.4 Status
+----------
+
+.. http:get:: /v1/_ping
+
+    Check status of the registry. This endpoint is also used to determine if
+    the registry supports SSL.
+
+    **Example Request**:
+
+    .. sourcecode:: http
+
+        GET /v1/_ping HTTP/1.1
+        Host: registry-1.docker.io
+        Accept: application/json
+        Content-Type: application/json
+
+        ""
+
+    **Example Response**:
+
+    .. sourcecode:: http
+
+        HTTP/1.1 200
+        Vary: Accept
+        Content-Type: application/json
+        X-Docker-Registry-Version: 0.6.0
+
+        ""
+
+    :statuscode 200: OK
+
+
+3 Authorization
+===============
 This is where we describe the authorization process, including the tokens and cookies. 
 
 TODO: add more info.

docs/sources/api/registry_index_spec.rst

@@ -2,13 +2,12 @@
 :description: Documentation for docker Registry and Registry API
 :keywords: docker, registry, api, index
 
+.. _registryindexspec:
 
 =====================
-Registry & index Spec
+Registry & Index Spec
 =====================
 
-.. contents:: Table of Contents
-
 1. The 3 roles
 ===============
 
@@ -154,7 +153,7 @@ API (pulling repository foo/bar):
 
 .. note::
 
-    **It’s possible not to use the Index at all!** In this case, a deployed version of the Registry is deployed to store and serve images. Those images are not authentified and the security is not guaranteed.
+    **It’s possible not to use the Index at all!** In this case, a deployed version of the Registry is deployed to store and serve images. Those images are not authenticated and the security is not guaranteed.
 
 .. note::
 
@@ -563,8 +562,8 @@ Next request::
     Cookie: session="wD/J7LqL5ctqw8haL10vgfhrb2Q=?foo=UydiYXInCnAxCi4=&timestamp=RjEzNjYzMTQ5NDcuNDc0NjQzCi4="
 
 
-7.0 Document Version
----------------------
+7 Document Version
+====================
 
 - 1.0 : May 6th 2013 : initial release 
 - 1.1 : June 1st 2013 : Added Delete Repository and way to handle new source namespace.

docs/sources/api/remote_api_client_libraries.rst

@@ -0,0 +1,37 @@
+: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
+
+
+==================================
+Docker Remote API Client Libraries
+==================================
+
+These libraries have not been tested by the Docker Maintainers for
+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                                 |
++======================+================+============================================+
+| 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  |
++----------------------+----------------+--------------------------------------------+

docs/sources/commandline/cli.rst

@@ -8,50 +8,84 @@ Overview
 ======================
 
 Docker Usage
-~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~
 
 To list available commands, either run ``docker`` with no parameters or execute
 ``docker help``::
 
-  $ docker
+  $ sudo docker
     Usage: docker [OPTIONS] COMMAND [arg...]
-      -H=[tcp://127.0.0.1:4243]: tcp://host:port to bind/connect to or unix://path/to/socket to use
+      -H=[unix:///var/run/docker.sock]: tcp://host:port to bind/connect to or unix://path/to/socket to use
 
     A self-sufficient runtime for linux containers.
 
     ...
 
+
+
 Available Commands
 ~~~~~~~~~~~~~~~~~~
 
-.. toctree::
-   :maxdepth: 2
+.. include:: command/attach.rst
+
+.. include:: command/build.rst
+
+.. include:: command/commit.rst
+
+.. include:: command/cp.rst
+
+.. include:: command/diff.rst
+
+.. include:: command/events.rst
+
+.. include:: command/export.rst
+
+.. include:: command/history.rst
+
+.. include:: command/images.rst
+
+.. include:: command/import.rst
+
+.. include:: command/info.rst
+
+.. include:: command/insert.rst
+
+.. include:: command/inspect.rst
+
+.. include:: command/kill.rst
+
+.. include:: command/login.rst
+
+.. include:: command/logs.rst
+
+.. include:: command/port.rst
+
+.. include:: command/ps.rst
+
+.. include:: command/pull.rst
+
+.. include:: command/push.rst
+
+.. include:: command/restart.rst
+
+.. include:: command/rm.rst
+
+.. include:: command/rmi.rst
+
+.. include:: command/run.rst
+
+.. include:: command/search.rst
+
+.. include:: command/start.rst
+
+.. include:: command/stop.rst
+
+.. include:: command/tag.rst
+
+.. include:: command/top.rst
+
+.. include:: command/version.rst
+
+.. include:: command/wait.rst
+
 
-   command/attach
-   command/build
-   command/commit
-   command/diff
-   command/export
-   command/history
-   command/images
-   command/import
-   command/info
-   command/inspect
-   command/kill
-   command/login
-   command/logs
-   command/port
-   command/ps
-   command/pull
-   command/push
-   command/restart
-   command/rm
-   command/rmi
-   command/run
-   command/search
-   command/start
-   command/stop
-   command/tag
-   command/top
-   command/version
-   command/wait

docs/sources/commandline/command/attach.rst

@@ -10,4 +10,50 @@
 
     Usage: docker attach CONTAINER
 
-    Attach to a running 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
+

docs/sources/commandline/command/build.rst

@@ -10,8 +10,10 @@
 
     Usage: docker build [OPTIONS] PATH | URL | -
     Build a new container image from the source code at PATH
-      -t="": Tag to be applied to the resulting image in case of success.
+      -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
 
 
@@ -20,25 +22,44 @@ Examples
 
 .. code-block:: bash
 
-    docker build .
+    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 '.', 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.
-|
+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
 
-    docker build - < Dockerfile
+   sudo docker build -t vieux/apache:2.0 .
 
-| 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 due to the absence of the context, thus having no source files to copy to the container.
+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
 
-    docker build github.com/creack/docker-firefox
+    sudo docker build - < Dockerfile
 
-| 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.
+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.

docs/sources/commandline/command/commit.rst

@@ -14,19 +14,39 @@
 
       -m="": Commit message
       -author="": Author (eg. "John Hannibal Smith <hannibal@a-team.com>"
-      -run="": Config automatically applied when the image is run. "+`(ex: {"Cmd": ["cat", "/world"], "PortSpecs": ["22"]}')
+      -run="": Configuration to be applied when the image is launched with `docker run`. 
+               (ex: '{"Cmd": ["cat", "/world"], "PortSpecs": ["22"]}')
 
-Full -run example::
+Full -run example (multiline is ok within a single quote ``'``)
 
-    {"Hostname": "",
-     "User": "",
-     "CpuShares": 0,
-     "Memory": 0,
-     "MemorySwap": 0,
-     "PortSpecs": ["22", "80", "443"],
-     "Tty": true,
-     "OpenStdin": true,
-     "StdinOnce": true,
-     "Env": ["FOO=BAR", "FOO2=BAR2"],
-     "Cmd": ["cat", "-e", "/etc/resolv.conf"],
-     "Dns": ["8.8.8.8", "8.8.4.4"]}
+::
+
+  $ 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

docs/sources/commandline/command/cp.rst

@@ -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.

docs/sources/commandline/command/events.rst

@@ -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
+

docs/sources/commandline/command/images.rst

@@ -21,6 +21,6 @@ Displaying images visually
 
 ::
 
-    docker images -viz | dot -Tpng -o docker.png
+    sudo docker images -viz | dot -Tpng -o docker.png
 
-.. image:: images/docker_images.gif
+.. image:: https://docs.docker.io/en/latest/_static/docker_images.gif

docs/sources/commandline/command/import.rst

@@ -12,10 +12,11 @@
 
     Create a new filesystem image from the contents of a tarball
 
-At this time, the URL must start with ``http`` and point to a single file archive
-(.tar, .tar.gz, .tgz, .bzip, .tar.xz, .txz)
-containing a root filesystem. If you would like to import from a local directory or archive,
-you can use the ``-`` parameter to take the data from standard in.
+At this time, the URL must start with ``http`` and point to a single
+file archive (.tar, .tar.gz, .tgz, .bzip, .tar.xz, .txz) containing a
+root filesystem. If you would like to import from a local directory or
+archive, you can use the ``-`` parameter to take the data from
+standard in.
 
 Examples
 --------
@@ -23,19 +24,21 @@ Examples
 Import from a remote location
 .............................
 
-``$ docker import http://example.com/exampleimage.tgz exampleimagerepo``
+``$ sudo docker import http://example.com/exampleimage.tgz exampleimagerepo``
 
 Import from a local file
 ........................
 
 Import to docker via pipe and standard in
 
-``$ cat exampleimage.tgz | docker import - exampleimagelocal``
+``$ cat exampleimage.tgz | sudo docker import - exampleimagelocal``
 
 Import from a local directory
 .............................
 
 ``$ sudo tar -c . | docker import - exampleimagedir``
 
-Note the ``sudo`` in this example -- you must preserve the ownership of the files (especially root ownership)
-during the archiving with tar. If you are not root (or sudo) when you tar, then the ownerships might not get preserved.
+Note the ``sudo`` in this example -- you must preserve the ownership
+of the files (especially root ownership) during the archiving with
+tar. If you are not root (or sudo) when you tar, then the ownerships
+might not get preserved.

docs/sources/commandline/command/insert.rst

@@ -0,0 +1,23 @@
+:title: Insert Command
+:description: Insert a file in an image
+:keywords: insert, image, docker, documentation
+
+==========================================================================
+``insert`` -- Insert a file in an image
+==========================================================================
+
+::
+
+    Usage: docker insert IMAGE URL PATH
+
+    Insert a file from URL in the IMAGE at PATH
+
+Examples
+--------
+
+Insert file from github
+.......................
+
+.. code-block:: bash
+
+    $ sudo docker insert 8283e18b24bc https://raw.github.com/metalivedev/django/master/postinstall /tmp/postinstall.sh

docs/sources/commandline/command/login.rst

@@ -8,10 +8,17 @@
 
 ::
 
-    Usage: docker login [OPTIONS]
+    Usage: docker login [OPTIONS] [SERVER]
 
     Register or Login to the docker registry server
 
     -e="": email
     -p="": password
     -u="": username
+
+    If you want to login to a private registry you can
+    specify this by adding the server name.
+
+    example:
+    docker login localhost:8080
+

docs/sources/commandline/command/run.rst

@@ -8,7 +8,7 @@
 
 ::
 
-    Usage: docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
+    Usage: docker run [OPTIONS] IMAGE[:TAG] [COMMAND] [ARG...]
 
     Run a command in a new container
 
@@ -19,22 +19,67 @@
       -e=[]: Set environment variables
       -h="": Container host name
       -i=false: Keep stdin open even if not attached
+      -privileged=false: Give extended privileges to this container
       -m=0: Memory limit (in bytes)
       -n=true: Enable networking for this container
       -p=[]: Map a network port to the container
+      -rm=false: Automatically remove the container when it exits (incompatible with -d)
       -t=false: Allocate a pseudo-tty
       -u="": Username or UID
-      -d=[]: Set custom dns servers for the container
-      -v=[]: Create a bind mount with: [host-dir]:[container-dir]:[rw|ro]. If "host-dir" is missing, then docker creates a new volume.
+      -dns=[]: Set custom dns servers for the container
+      -v=[]: Create a bind mount with: [host-dir]:[container-dir]:[rw|ro]. If "container-dir" is missing, then docker creates a new volume.
       -volumes-from="": Mount all volumes from the given container.
       -entrypoint="": Overwrite the default entrypoint set by the image.
-
+      -w="": Working directory inside the container
+      -lxc-conf=[]: Add custom lxc options -lxc-conf="lxc.cgroup.cpuset.cpus = 0,1"
 
 Examples
 --------
 
 .. code-block:: bash
 
-    docker run -cidfile /tmp/docker_test.cid ubuntu echo "test"
+    sudo docker run -cidfile /tmp/docker_test.cid ubuntu echo "test"
+
+This will create a container and print "test" to the console. The
+``cidfile`` flag makes docker attempt to create a new file and write the
+container ID to it. If the file exists already, docker will return an
+error. Docker will close this file when docker run exits.
+
+.. code-block:: bash
+
+   docker run mount -t tmpfs none /var/spool/squid
+
+This will *not* work, because by default, most potentially dangerous
+kernel capabilities are dropped; including ``cap_sys_admin`` (which is
+required to mount filesystems). However, the ``-privileged`` flag will
+allow it to run:
+
+.. code-block:: bash
+
+   docker run -privileged mount -t tmpfs none /var/spool/squid
+
+The ``-privileged`` flag gives *all* capabilities to the container,
+and it also lifts all the limitations enforced by the ``device``
+cgroup controller. In other words, the container can then do almost
+everything that the host can do. This flag exists to allow special
+use-cases, like running Docker within Docker.
+
+.. code-block:: bash
+
+   docker  run -w /path/to/dir/ -i -t  ubuntu pwd
+
+The ``-w`` lets the command being executed inside directory given, 
+here /path/to/dir/. If the path does not exists it is created inside the 
+container.
+
+.. code-block:: bash
+
+   docker  run  -v `pwd`:`pwd` -w `pwd` -i -t  ubuntu pwd
+
+The ``-v`` flag mounts the current working directory into the container. 
+The ``-w`` lets the command being executed inside the current 
+working directory, by changing into the directory to the value
+returned by ``pwd``. So this combination executes the command
+using the container, but inside the current working directory.
+
 
-| This will create a container and print "test" to the console. The cidfile flag makes docker attempt to create a new file and write the container ID to it. If the file exists already, docker will return an error. Docker will close this file when docker run exits.

docs/sources/commandline/command/search.rst

@@ -10,5 +10,5 @@
 
     Usage: docker search TERM
 
-    Searches for the TERM parameter on the Docker index and prints out a list of repositories
-    that match.
+    Searches for the TERM parameter on the Docker index and prints out
+    a list of repositories that match.

docs/sources/commandline/index.rst

@@ -15,12 +15,15 @@ Contents:
   attach  <command/attach>
   build   <command/build>
   commit  <command/commit>
+  cp      <command/cp>
   diff    <command/diff>
+  events  <command/events>
   export  <command/export>
   history <command/history>
   images  <command/images>
   import  <command/import>
   info    <command/info>
+  insert  <command/insert>
   inspect <command/inspect>
   kill    <command/kill>
   login   <command/login>

docs/sources/concepts/index.rst

@@ -1,16 +0,0 @@
-:title: Overview
-:description: Docker documentation summary
-:keywords: concepts, documentation, docker, containers
-
-
-
-Overview
-========
-
-Contents:
-
-.. toctree::
-   :maxdepth: 1
-
-   ../index
-   manifesto

docs/sources/concepts/manifesto.rst

@@ -1,129 +0,0 @@
-:title: Manifesto
-:description: An overview of Docker and standard containers
-:keywords: containers, lxc, concepts, explanation
-
-.. _dockermanifesto:
-
-Docker Manifesto
-----------------
-
-Docker complements LXC with a high-level API which operates at the
-process level. It runs unix processes with strong guarantees of
-isolation and repeatability across servers.
-
-Docker is a great building block for automating distributed systems:
-large-scale web deployments, database clusters, continuous deployment
-systems, private PaaS, service-oriented architectures, etc.
-
-- **Heterogeneous payloads** Any combination of binaries, libraries,
-  configuration files, scripts, virtualenvs, jars, gems, tarballs, you
-  name it. No more juggling between domain-specific tools. Docker can
-  deploy and run them all.
-- **Any server** Docker can run on any x64 machine with a modern linux
-  kernel - whether it's a laptop, a bare metal server or a VM. This
-  makes it perfect for multi-cloud deployments.
-- **Isolation** docker isolates processes from each other and from the
-  underlying host, using lightweight containers.
-- **Repeatability** Because containers are isolated in their own
-  filesystem, they behave the same regardless of where, when, and
-  alongside what they run.
-
-.. image:: images/lego_docker.jpg
-   :target: http://bricks.argz.com/ins/7823-1/12
-
-What is a Standard Container?
-.............................
-
-Docker defines a unit of software delivery called a Standard
-Container. The goal of a Standard Container is to encapsulate a
-software component and all its dependencies in a format that is
-self-describing and portable, so that any compliant runtime can run it
-without extra dependency, regardless of the underlying machine and the
-contents of the container.
-
-The spec for Standard Containers is currently work in progress, but it
-is very straightforward. It mostly defines 1) an image format, 2) a
-set of standard operations, and 3) an execution environment.
-
-A great analogy for this is the shipping container. Just like Standard
-Containers are a fundamental unit of software delivery, shipping
-containers are a fundamental unit of physical delivery.
-
-Standard operations
-~~~~~~~~~~~~~~~~~~~
-
-Just like shipping containers, Standard Containers define a set of
-STANDARD OPERATIONS. Shipping containers can be lifted, stacked,
-locked, loaded, unloaded and labelled. Similarly, standard containers
-can be started, stopped, copied, snapshotted, downloaded, uploaded and
-tagged.
-
-
-Content-agnostic
-~~~~~~~~~~~~~~~~~~~
-
-Just like shipping containers, Standard Containers are
-CONTENT-AGNOSTIC: all standard operations have the same effect
-regardless of the contents. A shipping container will be stacked in
-exactly the same way whether it contains Vietnamese powder coffee or
-spare Maserati parts. Similarly, Standard Containers are started or
-uploaded in the same way whether they contain a postgres database, a
-php application with its dependencies and application server, or Java
-build artifacts.
-
-Infrastructure-agnostic
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Both types of containers are INFRASTRUCTURE-AGNOSTIC: they can be
-transported to thousands of facilities around the world, and
-manipulated by a wide variety of equipment. A shipping container can
-be packed in a factory in Ukraine, transported by truck to the nearest
-routing center, stacked onto a train, loaded into a German boat by an
-Australian-built crane, stored in a warehouse at a US facility,
-etc. Similarly, a standard container can be bundled on my laptop,
-uploaded to S3, downloaded, run and snapshotted by a build server at
-Equinix in Virginia, uploaded to 10 staging servers in a home-made
-Openstack cluster, then sent to 30 production instances across 3 EC2
-regions.
-
-
-Designed for automation
-~~~~~~~~~~~~~~~~~~~~~~~
-
-Because they offer the same standard operations regardless of content
-and infrastructure, Standard Containers, just like their physical
-counterpart, are extremely well-suited for automation. In fact, you
-could say automation is their secret weapon.
-
-Many things that once required time-consuming and error-prone human
-effort can now be programmed. Before shipping containers, a bag of
-powder coffee was hauled, dragged, dropped, rolled and stacked by 10
-different people in 10 different locations by the time it reached its
-destination. 1 out of 50 disappeared. 1 out of 20 was damaged. The
-process was slow, inefficient and cost a fortune - and was entirely
-different depending on the facility and the type of goods.
-
-Similarly, before Standard Containers, by the time a software
-component ran in production, it had been individually built,
-configured, bundled, documented, patched, vendored, templated, tweaked
-and instrumented by 10 different people on 10 different
-computers. Builds failed, libraries conflicted, mirrors crashed,
-post-it notes were lost, logs were misplaced, cluster updates were
-half-broken. The process was slow, inefficient and cost a fortune -
-and was entirely different depending on the language and
-infrastructure provider.
-
-Industrial-grade delivery
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-There are 17 million shipping containers in existence, packed with
-every physical good imaginable. Every single one of them can be loaded
-on the same boats, by the same cranes, in the same facilities, and
-sent anywhere in the World with incredible efficiency. It is
-embarrassing to think that a 30 ton shipment of coffee can safely
-travel half-way across the World in *less time* than it takes a
-software team to deliver its code from one datacenter to another
-sitting 10 miles away.
-
-With Standard Containers we can put an end to that embarrassment, by
-making INDUSTRIAL-GRADE DELIVERY of software a reality.

docs/sources/conf.py

@@ -51,9 +51,7 @@ source_suffix = '.rst'
 # The encoding of source files.
 #source_encoding = 'utf-8-sig'
 
-#disable the parmalinks on headers, I find them really annoying
-html_add_permalinks = None
-
+html_add_permalinks = u'¶'
 
 # The master toctree document.
 master_doc = 'toctree'
@@ -203,7 +201,7 @@ latex_elements = {
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
 latex_documents = [
-  ('index', 'Docker.tex', u'Docker Documentation',
+  ('toctree', 'Docker.tex', u'Docker Documentation',
    u'Team Docker', 'manual'),
 ]
 
@@ -233,7 +231,7 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'docker', u'Docker Documentation',
+    ('toctree', 'docker', u'Docker Documentation',
      [u'Team Docker'], 1)
 ]
 
@@ -247,7 +245,7 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-  ('index', 'Docker', u'Docker Documentation',
+  ('toctree', 'Docker', u'Docker Documentation',
    u'Team Docker', 'Docker', 'One line description of project.',
    'Miscellaneous'),
 ]

docs/sources/contributing/contributing.rst

@@ -1,5 +1,5 @@
 :title: Contribution Guidelines
-:description: Contribution guidelines: create issues, convetions, pull requests
+:description: Contribution guidelines: create issues, conventions, pull requests
 :keywords: contributing, docker, documentation, help, guideline
 
 Contributing to Docker

docs/sources/contributing/devenvironment.rst

@@ -3,56 +3,130 @@
 :keywords: Docker, documentation, developers, contributing, dev environment
 
 Setting Up a Dev Environment
-============================
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-To make it easier to contribute to Docker, we provide a standard development environment. It is important that
-the same environment be used for all tests, builds and releases. The standard development environment defines
-all build dependencies: system libraries and binaries, go environment, go dependencies, etc.
+To make it easier to contribute to Docker, we provide a standard
+development environment. It is important that the same environment be
+used for all tests, builds and releases. The standard development
+environment defines all build dependencies: system libraries and
+binaries, go environment, go dependencies, etc.
 
 
-Step 1: install docker
+Step 1: Install Docker
 ----------------------
 
-Docker's build environment itself is a docker container, so the first step is to install docker on your system.
+Docker's build environment itself is a Docker container, so the first
+step is to install Docker on your system.
 
-You can follow the `install instructions most relevant to your system <https://docs.docker.io/en/latest/installation/>`.
-Make sure you have a working, up-to-date docker installation, then continue to the next step.
+You can follow the `install instructions most relevant to your system
+<https://docs.docker.io/en/latest/installation/>`_.  Make sure you have
+a working, up-to-date docker installation, then continue to the next
+step.
 
 
-Step 2: check out the source
+Step 2: Check out the Source
 ----------------------------
 
-::
+.. code-block:: bash
 
     git clone http://git@github.com/dotcloud/docker
     cd docker
 
-
-Step 3: build
--------------
-
-When you are ready to build docker, run this command:
-
-::
-
-    docker build -t docker .
-
-This will build the revision currently checked out in the repository. Feel free to check out the version
-of your choice.
-
-If the build is successful, congratulations! You have produced a clean build of docker, neatly encapsulated
-in a standard build environment.
-
-You can run an interactive session in the newly built container:
-
-::
-
-    docker run -i -t docker bash
+To checkout a different revision just use ``git checkout`` with the name of branch or revision number.
 
 
-To extract the binaries from the container:
+Step 3: Build the Environment
+-----------------------------
 
-::
+This following command will build a development environment using the Dockerfile in the current directory. Essentially, it will install all the build and runtime dependencies necessary to build and test Docker. This command will take some time to complete when you first execute it.
 
-    docker run docker sh -c 'cat $(which docker)' > docker-build && chmod +x docker-build
+.. code-block:: bash
 
+    sudo docker build -t docker .
+
+
+
+If the build is successful, congratulations! You have produced a clean build of docker, neatly encapsulated in a standard build environment. 
+
+
+Step 4: Build the Docker Binary
+-------------------------------
+
+To create the Docker binary, run this command:
+
+.. code-block:: bash
+
+	sudo docker run -lxc-conf=lxc.aa_profile=unconfined -privileged -v `pwd`:/go/src/github.com/dotcloud/docker docker hack/make.sh binary
+
+This will create the Docker binary in ``./bundles/<version>-dev/binary/``
+
+
+Step 5: Run the Tests
+---------------------
+
+To run the Docker test cases you first need to disable `AppArmor <https://wiki.ubuntu.com/AppArmor>`_ using the following commands
+
+.. code-block:: bash
+
+	sudo /etc/init.d/apparmor stop
+	sudo /etc/init.d/apparmor teardown
+
+To execute the test cases, run this command:
+
+.. code-block:: bash
+
+	sudo docker run -lxc-conf=lxc.aa_profile=unconfined -privileged -v `pwd`:/go/src/github.com/dotcloud/docker docker hack/make.sh test
+
+
+If the test are successful then the tail of the output should look something like this
+
+.. code-block:: bash
+
+	--- PASS: TestWriteBroadcaster (0.00 seconds)
+	=== RUN TestRaceWriteBroadcaster
+	--- PASS: TestRaceWriteBroadcaster (0.00 seconds)
+	=== RUN TestTruncIndex
+	--- PASS: TestTruncIndex (0.00 seconds)
+	=== RUN TestCompareKernelVersion
+	--- PASS: TestCompareKernelVersion (0.00 seconds)
+	=== RUN TestHumanSize
+	--- PASS: TestHumanSize (0.00 seconds)
+	=== RUN TestParseHost
+	--- PASS: TestParseHost (0.00 seconds)
+	=== RUN TestParseRepositoryTag
+	--- PASS: TestParseRepositoryTag (0.00 seconds)
+	=== RUN TestGetResolvConf
+	--- PASS: TestGetResolvConf (0.00 seconds)
+	=== RUN TestCheckLocalDns
+	--- PASS: TestCheckLocalDns (0.00 seconds)
+	=== RUN TestParseRelease
+	--- PASS: TestParseRelease (0.00 seconds)
+	=== RUN TestDependencyGraphCircular
+	--- PASS: TestDependencyGraphCircular (0.00 seconds)
+	=== RUN TestDependencyGraph
+	--- PASS: TestDependencyGraph (0.00 seconds)
+	PASS
+	ok  	github.com/dotcloud/docker/utils	0.017s
+
+
+
+
+Step 6: Use Docker
+-------------------
+
+You can run an interactive session in the newly built container: 
+
+.. code-block:: bash
+
+	sudo docker run -privileged -i -t docker bash
+
+	# type 'exit' to exit
+
+
+
+.. note:: The binary is available outside the container in the directory  ``./bundles/<version>-dev/binary/``. You can swap your host docker executable with this binary for live testing - for example, on ubuntu: ``sudo service docker stop ; sudo cp $(which docker) $(which docker)_ ; sudo cp ./bundles/<version>-dev/binary/docker-<version>-dev $(which docker);sudo service docker start``.
+
+
+**Need More Help?**
+
+If you need more help then hop on to the `#docker-dev IRC channel <irc://chat.freenode.net#docker-dev>`_ or post a message on the `Docker developer mailinglist <https://groups.google.com/d/forum/docker-dev>`_.

docs/sources/examples/couchdb_data_volumes.rst

@@ -9,27 +9,29 @@ CouchDB Service
 
 .. include:: example_header.inc
 
-Here's an example of using data volumes to share the same data between 2 couchdb containers.
-This could be used for hot upgrades, testing different versions of couchdb on the same data, etc.
+Here's an example of using data volumes to share the same data between
+2 CouchDB containers.  This could be used for hot upgrades, testing
+different versions of CouchDB on the same data, etc.
 
 Create first database
 ---------------------
 
-Note that we're marking /var/lib/couchdb as a data volume.
+Note that we're marking ``/var/lib/couchdb`` as a data volume.
 
 .. code-block:: bash
 
-    COUCH1=$(docker run -d -v /var/lib/couchdb shykes/couchdb:2013-05-03)
+    COUCH1=$(sudo docker run -d -v /var/lib/couchdb shykes/couchdb:2013-05-03)
 
 Add data to the first database
 ------------------------------
 
-We're assuming your docker host is reachable at `localhost`. If not, replace `localhost` with the public IP of your docker host.
+We're assuming your docker host is reachable at `localhost`. If not,
+replace `localhost` with the public IP of your docker host.
 
 .. code-block:: bash
 
     HOST=localhost
-    URL="http://$HOST:$(docker port $COUCH1 5984)/_utils/"
+    URL="http://$HOST:$(sudo docker port $COUCH1 5984)/_utils/"
     echo "Navigate to $URL in your browser, and use the couch interface to add data"
 
 Create second database
@@ -39,7 +41,7 @@ This time, we're requesting shared access to $COUCH1's volumes.
 
 .. code-block:: bash
 
-    COUCH2=$(docker run -d -volumes-from $COUCH1 shykes/couchdb:2013-05-03)
+    COUCH2=$(sudo docker run -d -volumes-from $COUCH1 shykes/couchdb:2013-05-03)
 
 Browse data on the second database
 ----------------------------------
@@ -47,7 +49,8 @@ Browse data on the second database
 .. code-block:: bash
 
     HOST=localhost
-    URL="http://$HOST:$(docker port $COUCH2 5984)/_utils/"
+    URL="http://$HOST:$(sudo docker port $COUCH2 5984)/_utils/"
     echo "Navigate to $URL in your browser. You should see the same data as in the first database"'!'
 
-Congratulations, you are running 2 Couchdb containers, completely isolated from each other *except* for their data.
+Congratulations, you are running 2 Couchdb containers, completely
+isolated from each other *except* for their data.

docs/sources/examples/hello_world.rst

@@ -2,6 +2,33 @@
 :description: A simple hello world example with Docker
 :keywords: docker, example, hello world
 
+.. _examples:
+
+Hello World
+-----------
+
+.. _running_examples:
+
+Running the Examples
+====================
+
+All the examples assume your machine is running the docker daemon. To
+run the docker daemon in the background, simply type:
+
+.. code-block:: bash
+
+   sudo docker -d &
+
+Now you can run docker in client mode: by default all commands will be
+forwarded to the ``docker`` daemon via a protected Unix socket, so you
+must run as root.
+
+.. code-block:: bash
+
+   sudo docker help
+
+----
+
 .. _hello_world:
 
 Hello World
@@ -11,26 +38,28 @@ Hello World
 
 This is the most basic example available for using Docker.
 
-Download the base container
+Download the base image (named "ubuntu"):
 
 .. code-block:: bash
 
-    # Download a base image
-    docker pull base
+    # Download an ubuntu image
+    sudo docker pull ubuntu
 
-The *base* image is a minimal *ubuntu* based container, alternatively you can select *busybox*, a bare
-minimal linux system. The images are retrieved from the docker repository.
+Alternatively to the *ubuntu* image, you can select *busybox*, a bare
+minimal Linux system. The images are retrieved from the Docker
+repository.
 
 
 .. code-block:: bash
 
     #run a simple echo command, that will echo hello world back to the console over standard out.
-    docker run base /bin/echo hello world
+    sudo docker run ubuntu /bin/echo hello world
 
 **Explanation:**
 
+- **"sudo"** execute the following commands as user *root* 
 - **"docker run"** run a command in a new container 
-- **"base"** is the image we want to run the command inside of.
+- **"ubuntu"** is the image we want to run the command inside of.
 - **"/bin/echo"** is the command we want to run in the container
 - **"hello world"** is the input for the echo command
 
@@ -47,4 +76,106 @@ See the example in action
     </div>
 
 
-Continue to the :ref:`hello_world_daemon` example.
+----
+
+.. _hello_world_daemon:
+
+Hello World Daemon
+==================
+
+.. include:: example_header.inc
+
+And now for the most boring daemon ever written!
+
+This example assumes you have Docker installed and the Ubuntu
+image already imported with ``docker pull ubuntu``.  We will use the Ubuntu
+image to run a simple hello world daemon that will just print hello
+world to standard out every second. It will continue to do this until
+we stop it.
+
+**Steps:**
+
+.. code-block:: bash
+
+    CONTAINER_ID=$(sudo docker run -d ubuntu /bin/sh -c "while true; do echo hello world; sleep 1; done")
+
+We are going to run a simple hello world daemon in a new container
+made from the *ubuntu* image.
+
+- **"docker run -d "** run a command in a new container. We pass "-d"
+  so it runs as a daemon.
+- **"ubuntu"** is the image we want to run the command inside of.
+- **"/bin/sh -c"** is the command we want to run in the container
+- **"while true; do echo hello world; sleep 1; done"** is the mini
+  script we want to run, that will just print hello world once a
+  second until we stop it.
+- **$CONTAINER_ID** the output of the run command will return a
+  container id, we can use in future commands to see what is going on
+  with this process.
+
+.. code-block:: bash
+
+    sudo docker logs $CONTAINER_ID
+
+Check the logs make sure it is working correctly.
+
+- **"docker logs**" This will return the logs for a container
+- **$CONTAINER_ID** The Id of the container we want the logs for.
+
+.. code-block:: bash
+
+    sudo docker attach $CONTAINER_ID
+
+Attach to the container to see the results in realtime.
+
+- **"docker attach**" This will allow us to attach to a background
+  process to see what is going on.
+- **$CONTAINER_ID** The Id of the container we want to attach too.
+
+Exit from the container attachment by pressing Control-C.
+
+.. code-block:: bash
+
+    sudo docker ps
+
+Check the process list to make sure it is running.
+
+- **"docker ps"** this shows all running process managed by docker
+
+.. code-block:: bash
+
+    sudo docker stop $CONTAINER_ID
+
+Stop the container, since we don't need it anymore.
+
+- **"docker stop"** This stops a container
+- **$CONTAINER_ID** The Id of the container we want to stop.
+
+.. code-block:: bash
+
+    sudo docker ps
+
+Make sure it is really stopped.
+
+
+**Video:**
+
+See the example in action
+
+.. raw:: html
+
+    <div style="margin-top:10px;">
+      <iframe width="560" height="350" src="http://ascii.io/a/2562/raw" frameborder="0"></iframe>
+    </div>
+
+The next example in the series is a :ref:`python_web_app` example, or
+you could skip to any of the other examples:
+
+
+* :ref:`python_web_app`
+* :ref:`nodejs_web_app`
+* :ref:`running_redis_service`
+* :ref:`running_ssh_service`
+* :ref:`running_couchdb_service`
+* :ref:`postgresql_service`
+* :ref:`mongodb`

docs/sources/examples/hello_world_daemon.rst

@@ -1,84 +0,0 @@
-:title: Hello world daemon example
-:description: A simple hello world daemon example with Docker
-:keywords: docker, example, hello world, daemon
-
-.. _hello_world_daemon:
-
-Hello World Daemon
-==================
-
-.. include:: example_header.inc
-
-The most boring daemon ever written.
-
-This example assumes you have Docker installed and with the base image already imported ``docker pull base``.
-We will use the base image to run a simple hello world daemon that will just print hello world to standard
-out every second. It will continue to do this until we stop it.
-
-**Steps:**
-
-.. code-block:: bash
-
-    CONTAINER_ID=$(docker run -d base /bin/sh -c "while true; do echo hello world; sleep 1; done")
-
-We are going to run a simple hello world daemon in a new container made from the base image.
-
-- **"docker run -d "** run a command in a new container. We pass "-d" so it runs as a daemon.
-- **"base"** is the image we want to run the command inside of.
-- **"/bin/sh -c"** is the command we want to run in the container
-- **"while true; do echo hello world; sleep 1; done"** is the mini script we want to run, that will just print hello world once a second until we stop it.
-- **$CONTAINER_ID** the output of the run command will return a container id, we can use in future commands to see what is going on with this process.
-
-.. code-block:: bash
-
-    docker logs $CONTAINER_ID
-
-Check the logs make sure it is working correctly.
-
-- **"docker logs**" This will return the logs for a container
-- **$CONTAINER_ID** The Id of the container we want the logs for.
-
-.. code-block:: bash
-
-    docker attach $CONTAINER_ID
-
-Attach to the container to see the results in realtime.
-
-- **"docker attach**" This will allow us to attach to a background process to see what is going on.
-- **$CONTAINER_ID** The Id of the container we want to attach too.
-
-.. code-block:: bash
-
-    docker ps
-
-Check the process list to make sure it is running.
-
-- **"docker ps"** this shows all running process managed by docker
-
-.. code-block:: bash
-
-    docker stop $CONTAINER_ID
-
-Stop the container, since we don't need it anymore.
-
-- **"docker stop"** This stops a container
-- **$CONTAINER_ID** The Id of the container we want to stop.
-
-.. code-block:: bash
-
-    docker ps
-
-Make sure it is really stopped.
-
-
-**Video:**
-
-See the example in action
-
-.. raw:: html
-
-    <div style="margin-top:10px;">
-      <iframe width="560" height="350" src="http://ascii.io/a/2562/raw" frameborder="0"></iframe>
-    </div>
-
-Continue to the :ref:`python_web_app` example.

docs/sources/examples/index.rst

@@ -1,22 +1,26 @@
 :title: Docker Examples
 :description: Examples on how to use Docker
-:keywords: docker, hello world, node, nodejs, python, couch, couchdb, redis, ssh, sshd, examples
+:keywords: docker, hello world, node, nodejs, python, couch, couchdb, redis, ssh, sshd, examples, postgresql
 
 
+.. _example_list:
 
 Examples
-============
+========
 
-Contents:
+Here are some examples of how to use Docker to create running
+processes, starting from a very simple *Hello World* and progressing
+to more substantial services like you might find in production.
 
 .. toctree::
    :maxdepth: 1
 
-   running_examples
    hello_world
-   hello_world_daemon
    python_web_app
    nodejs_web_app
    running_redis_service
    running_ssh_service
    couchdb_data_volumes
+   postgresql_service
+   mongodb
+   running_riak_service

docs/sources/examples/mongodb.rst

@@ -0,0 +1,100 @@
+:title: Building a Docker Image with MongoDB
+:description: How to build a Docker image with MongoDB pre-installed
+:keywords: docker, example, package installation, networking, mongodb
+
+.. _mongodb_image:
+
+Building an Image with MongoDB
+==============================
+
+.. include:: example_header.inc
+
+The goal of this example is to show how you can build your own
+docker images with MongoDB preinstalled. We will do that by
+constructing a Dockerfile that downloads a base image, adds an
+apt source and installs the database software on Ubuntu.
+
+Creating a ``Dockerfile``
++++++++++++++++++++++++++
+
+Create an empty file called ``Dockerfile``:
+
+.. code-block:: bash
+
+    touch Dockerfile
+
+Next, define the parent image you want to use to build your own image on top of.
+Here, we’ll use `Ubuntu <https://index.docker.io/_/ubuntu/>`_ (tag: ``latest``)
+available on the `docker index <http://index.docker.io>`_:
+
+.. code-block:: bash
+
+    FROM    ubuntu:latest
+
+Since we want to be running the latest version of MongoDB we'll need to add the
+10gen repo to our apt sources list.
+
+.. code-block:: bash
+
+    # Add 10gen official apt source to the sources list
+    RUN apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10
+    RUN echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | tee /etc/apt/sources.list.d/10gen.list
+
+Then, we don't want Ubuntu to complain about init not being available so we'll
+divert /sbin/initctl to /bin/true so it thinks everything is working.
+
+.. code-block:: bash
+
+    # Hack for initctl not being available in Ubuntu
+    RUN dpkg-divert --local --rename --add /sbin/initctl
+    RUN ln -s /bin/true /sbin/initctl
+
+Afterwards we'll be able to update our apt repositories and install MongoDB
+
+.. code-block:: bash
+
+    # Install MongoDB
+    RUN apt-get update
+    RUN apt-get install mongodb-10gen
+
+To run MongoDB we'll have to create the default data directory (because we want it to
+run without needing to provide a special configuration file)
+
+.. code-block:: bash
+
+    # Create the MongoDB data directory
+    RUN mkdir -p /data/db
+
+Finally, we'll expose the standard port that MongoDB runs on (27107) as well as
+define an ENTRYPOINT for the container.
+
+.. code-block:: bash
+
+    EXPOSE 27017
+    ENTRYPOINT ["usr/bin/mongod"]
+
+Now, lets build the image which will go through the ``Dockerfile`` we made and
+run all of the commands.
+
+.. code-block:: bash
+
+    docker build -t <yourname>/mongodb .
+
+Now you should be able to run ``mongod`` as a daemon and be able to connect on
+the local port!
+
+.. code-block:: bash
+
+    # Regular style
+    MONGO_ID=$(docker run -d <yourname>/mongodb)
+
+    # Lean and mean
+    MONGO_ID=$(docker run -d <yourname>/mongodb --noprealloc --smallfiles)
+
+    # Check the logs out
+    docker logs $MONGO_ID
+
+    # Connect and play around
+    mongo --port <port you get from `docker ps`>
+
+Sweet!

docs/sources/examples/nodejs_web_app.rst

@@ -9,10 +9,11 @@ Node.js Web App
 
 .. include:: example_header.inc
 
-The goal of this example is to show you how you can build your own docker images
-from a parent image using a ``Dockerfile`` . We will do that by making a simple
-Node.js hello world web application running on CentOS. You can get the full
-source code at https://github.com/gasi/docker-node-hello.
+The goal of this example is to show you how you can build your own
+docker images from a parent image using a ``Dockerfile`` . We will do
+that by making a simple Node.js hello world web application running on
+CentOS. You can get the full source code at
+https://github.com/gasi/docker-node-hello.
 
 Create Node.js app
 ++++++++++++++++++
@@ -92,7 +93,7 @@ To install the right package for CentOS, we’ll use the instructions from the
     # Enable EPEL for Node.js
     RUN     rpm -Uvh http://download.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm
     # Install Node.js and npm
-    RUN     yum install -y npm-1.2.17-5.el6
+    RUN     yum install -y npm
 
 To bundle your app’s source code inside the docker image, use the ``ADD``
 command:
@@ -109,16 +110,17 @@ Install your app dependencies using npm:
     # Install app dependencies
     RUN cd /src; npm install
 
-Your app binds to port ``8080`` so you’ll use the ``EXPOSE`` command to have it
-mapped by the docker daemon:
+Your app binds to port ``8080`` so you’ll use the ``EXPOSE`` command
+to have it mapped by the docker daemon:
 
 .. code-block:: bash
 
     EXPOSE  8080
 
-Last but not least, define the command to run your app using ``CMD`` which
-defines your runtime, i.e. ``node``, and the path to our app, i.e.
-``src/index.js`` (see the step where we added the source to the container):
+Last but not least, define the command to run your app using ``CMD``
+which defines your runtime, i.e. ``node``, and the path to our app,
+i.e.  ``src/index.js`` (see the step where we added the source to the
+container):
 
 .. code-block:: bash
 
@@ -135,7 +137,7 @@ Your ``Dockerfile`` should now look like this:
     # Enable EPEL for Node.js
     RUN     rpm -Uvh http://download.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm
     # Install Node.js and npm
-    RUN     yum install -y npm-1.2.17-5.el6
+    RUN     yum install -y npm
 
     # Bundle app source
     ADD . /src
@@ -149,19 +151,20 @@ Your ``Dockerfile`` should now look like this:
 Building your image
 +++++++++++++++++++
 
-Go to the directory that has your ``Dockerfile`` and run the following command
-to build a docker image. The ``-t`` flag let’s you tag your image so it’s easier
-to find later using the ``docker images`` command:
+Go to the directory that has your ``Dockerfile`` and run the following
+command to build a docker image. The ``-t`` flag let’s you tag your
+image so it’s easier to find later using the ``docker images``
+command:
 
 .. code-block:: bash
 
-    docker build -t <your username>/centos-node-hello .
+    sudo docker build -t <your username>/centos-node-hello .
 
 Your image will now be listed by docker:
 
 .. code-block:: bash
 
-    docker images
+    sudo docker images
 
     > # Example
     > REPOSITORY                 TAG       ID              CREATED
@@ -177,17 +180,17 @@ container running in the background. Run the image you previously built:
 
 .. code-block:: bash
 
-    docker run -d <your username>/centos-node-hello
+    sudo docker run -d <your username>/centos-node-hello
 
 Print the output of your app:
 
 .. code-block:: bash
 
     # Get container ID
-    docker ps
+    sudo docker ps
 
     # Print app output
-    docker logs <container id>
+    sudo docker logs <container id>
 
     > # Example
     > Running on http://localhost:8080
@@ -225,8 +228,8 @@ Now you can call your app using ``curl`` (install if needed via:
     >
     > Hello World
 
-We hope this tutorial helped you get up and running with Node.js and CentOS on
-docker. You can get the full source code at
+We hope this tutorial helped you get up and running with Node.js and
+CentOS on docker. You can get the full source code at
 https://github.com/gasi/docker-node-hello.
 
 Continue to :ref:`running_redis_service`.

docs/sources/examples/postgresql_service.rst

@@ -0,0 +1,170 @@
+:title: PostgreSQL service How-To
+:description: Running and installing a PostgreSQL service
+:keywords: docker, example, package installation, postgresql
+
+.. _postgresql_service:
+
+PostgreSQL Service
+==================
+
+.. note::
+
+    A shorter version of `this blog post`_.
+
+.. note::
+
+    As of version 0.5.2, docker requires root privileges to run.
+    You have to either manually adjust your system configuration (permissions on
+    /var/run/docker.sock or sudo config), or prefix `docker` with `sudo`. Check
+    `this thread`_ for details.
+
+.. _this blog post: http://zaiste.net/2013/08/docker_postgresql_how_to/
+.. _this thread: https://groups.google.com/forum/?fromgroups#!topic/docker-club/P3xDLqmLp0E
+
+Installing PostgreSQL on Docker
+-------------------------------
+
+For clarity I won't be showing commands output.
+
+
+Run an interactive shell in Docker container.
+
+.. code-block:: bash
+
+    sudo docker run -i -t ubuntu /bin/bash
+
+Update its dependencies.
+
+.. code-block:: bash
+
+    apt-get update
+
+Install ``python-software-properties``.
+
+.. code-block:: bash
+
+    apt-get -y install python-software-properties
+    apt-get -y install software-properties-common
+
+Add Pitti's PostgreSQL repository. It contains the most recent stable release
+of PostgreSQL i.e. ``9.2``.
+
+.. code-block:: bash
+
+    add-apt-repository ppa:pitti/postgresql
+    apt-get update
+
+Finally, install PostgreSQL 9.2
+
+.. code-block:: bash
+
+    apt-get -y install postgresql-9.2 postgresql-client-9.2 postgresql-contrib-9.2
+
+Now, create a PostgreSQL superuser role that can create databases and
+other roles.  Following Vagrant's convention the role will be named
+`docker` with `docker` password assigned to it.
+
+.. code-block:: bash
+
+    su postgres -c "createuser -P -d -r -s docker"
+
+Create a test database also named ``docker`` owned by previously created ``docker``
+role.
+
+.. code-block:: bash
+
+    su postgres -c "createdb -O docker docker"
+
+Adjust PostgreSQL configuration so that remote connections to the
+database are possible. Make sure that inside
+``/etc/postgresql/9.2/main/pg_hba.conf`` you have following line (you will need
+to install an editor, e.g. ``apt-get install vim``):
+
+.. code-block:: bash
+
+    host    all             all             0.0.0.0/0               md5
+
+Additionaly, inside ``/etc/postgresql/9.2/main/postgresql.conf``
+uncomment ``listen_addresses`` so it is as follows:
+
+.. code-block:: bash
+
+    listen_addresses='*'
+
+.. note::
+
+    This PostgreSQL setup is for development only purposes. Refer
+    to PostgreSQL documentation how to fine-tune these settings so that it
+    is enough secure.
+
+Exit.
+
+.. code-block:: bash
+
+    exit
+
+Create an image and assign it a name. ``<container_id>`` is in the
+Bash prompt; you can also locate it using ``docker ps -a``.
+
+.. code-block:: bash
+
+    docker commit <container_id> <your username>/postgresql
+
+Finally, run PostgreSQL server via ``docker``.
+
+.. code-block:: bash
+
+    CONTAINER=$(sudo docker run -d -p 5432 \
+      -t <your username>/postgresql \
+      /bin/su postgres -c '/usr/lib/postgresql/9.2/bin/postgres \
+        -D /var/lib/postgresql/9.2/main \
+        -c config_file=/etc/postgresql/9.2/main/postgresql.conf')
+
+Connect the PostgreSQL server using ``psql`` (You will need postgres installed
+on the machine.  For ubuntu, use something like
+``sudo apt-get install postgresql``).
+
+.. code-block:: bash
+
+    CONTAINER_IP=$(sudo docker inspect $CONTAINER | grep IPAddress | awk '{ print $2 }' | tr -d ',"')
+    psql -h $CONTAINER_IP -p 5432 -d docker -U docker -W
+
+As before, create roles or databases if needed.
+
+.. code-block:: bash
+
+    psql (9.2.4)
+    Type "help" for help.
+
+    docker=# CREATE DATABASE foo OWNER=docker;
+    CREATE DATABASE
+
+Additionally, publish your newly created image on Docker Index.
+
+.. code-block:: bash
+
+    sudo docker login
+    Username: <your username>
+    [...]
+
+.. code-block:: bash
+
+    sudo docker push <your username>/postgresql
+
+PostgreSQL service auto-launch
+------------------------------
+
+Running our image seems complicated. We have to specify the whole command with
+``docker run``. Let's simplify it so the service starts automatically when the
+container starts.
+
+.. code-block:: bash
+
+    sudo docker commit -run='{"Cmd": \
+      ["/bin/su", "postgres", "-c", "/usr/lib/postgresql/9.2/bin/postgres -D \
+      /var/lib/postgresql/9.2/main -c \
+      config_file=/etc/postgresql/9.2/main/postgresql.conf"], "PortSpecs": ["5432"]}' \
+      <container_id> <your username>/postgresql
+
+From now on, just type ``docker run <your username>/postgresql`` and
+PostgreSQL should automatically start.

docs/sources/examples/python_web_app.rst

@@ -9,13 +9,16 @@ Python Web App
 
 .. include:: example_header.inc
 
-The goal of this example is to show you how you can author your own docker images using a parent image, making changes to it, and then saving the results as a new image. We will do that by making a simple hello flask web application image.
+The goal of this example is to show you how you can author your own
+docker images using a parent image, making changes to it, and then
+saving the results as a new image. We will do that by making a simple
+hello flask web application image.
 
 **Steps:**
 
 .. code-block:: bash
 
-    docker pull shykes/pybuilder
+    sudo docker pull shykes/pybuilder
 
 We are downloading the "shykes/pybuilder" docker image
 
@@ -27,46 +30,66 @@ We set a URL variable that points to a tarball of a simple helloflask web app
 
 .. code-block:: bash
 
-    BUILD_JOB=$(docker run -d -t shykes/pybuilder:latest /usr/local/bin/buildapp $URL)
+    BUILD_JOB=$(sudo docker run -d -t shykes/pybuilder:latest /usr/local/bin/buildapp $URL)
 
-Inside of the "shykes/pybuilder" image there is a command called buildapp, we are running that command and passing the $URL variable from step 2 to it, and running the whole thing inside of a new container. BUILD_JOB will be set with the new container_id.
+Inside of the "shykes/pybuilder" image there is a command called
+buildapp, we are running that command and passing the $URL variable
+from step 2 to it, and running the whole thing inside of a new
+container. BUILD_JOB will be set with the new container_id.
 
 .. code-block:: bash
 
-    docker attach $BUILD_JOB
+    sudo docker attach $BUILD_JOB
     [...]
 
-We attach to the new container to see what is going on. Ctrl-C to disconnect
+While this container is running, we can attach to the new container to
+see what is going on. Ctrl-C to disconnect.
 
 .. code-block:: bash
 
-    BUILD_IMG=$(docker commit $BUILD_JOB _/builds/github.com/shykes/helloflask/master)
-
-Save the changed we just made in the container to a new image called "_/builds/github.com/hykes/helloflask/master" and save the image id in the BUILD_IMG variable name.
+    sudo docker ps -a
+    
+List all docker containers. If this container has already finished
+running, it will still be listed here.
 
 .. code-block:: bash
 
-    WEB_WORKER=$(docker run -d -p 5000 $BUILD_IMG /usr/local/bin/runapp)
+    BUILD_IMG=$(sudo docker commit $BUILD_JOB _/builds/github.com/shykes/helloflask/master)
 
-- **"docker run -d "** run a command in a new container. We pass "-d" so it runs as a daemon.
-- **"-p 5000"** the web app is going to listen on this port, so it must be mapped from the container to the host system.
+Save the changes we just made in the container to a new image called
+``_/builds/github.com/hykes/helloflask/master`` and save the image id in
+the BUILD_IMG variable name.
+
+.. code-block:: bash
+
+    WEB_WORKER=$(sudo docker run -d -p 5000 $BUILD_IMG /usr/local/bin/runapp)
+
+- **"docker run -d "** run a command in a new container. We pass "-d"
+  so it runs as a daemon.
+- **"-p 5000"** the web app is going to listen on this port, so it
+  must be mapped from the container to the host system.
 - **"$BUILD_IMG"** is the image we want to run the command inside of.
 - **/usr/local/bin/runapp** is the command which starts the web app.
 
-Use the new image we just created and create a new container with network port 5000, and return the container id and store in the WEB_WORKER variable.
+Use the new image we just created and create a new container with
+network port 5000, and return the container id and store in the
+WEB_WORKER variable.
 
 .. code-block:: bash
 
-    docker logs $WEB_WORKER
+    sudo docker logs $WEB_WORKER
      * Running on http://0.0.0.0:5000/
 
-view the logs for the new container using the WEB_WORKER variable, and if everything worked as planned you should see the line "Running on http://0.0.0.0:5000/" in the log output.
+View the logs for the new container using the WEB_WORKER variable, and
+if everything worked as planned you should see the line "Running on
+http://0.0.0.0:5000/" in the log output.
 
 .. code-block:: bash
 
-    WEB_PORT=$(docker port $WEB_WORKER 5000)
+    WEB_PORT=$(sudo docker port $WEB_WORKER 5000)
 
-lookup the public-facing port which is NAT-ed store the private port used by the container and store it inside of the WEB_PORT variable.
+Look up the public-facing port which is NAT-ed. Find the private port
+used by the container and store it inside of the WEB_PORT variable.
 
 .. code-block:: bash
 
@@ -74,7 +97,8 @@ lookup the public-facing port which is NAT-ed store the private port used by the
     curl http://127.0.0.1:$WEB_PORT
       Hello world!
 
-access the web app using curl. If everything worked as planned you should see the line "Hello world!" inside of your console.
+Access the web app using curl. If everything worked as planned you
+should see the line "Hello world!" inside of your console.
 
 **Video:**
 

docs/sources/examples/running_examples.rst

@@ -1,22 +0,0 @@
-:title: Running the Examples
-:description: An overview on how to run the docker examples
-:keywords: docker, examples, how to
-
-.. _running_examples:
-
-Running the Examples
---------------------
-
-All the examples assume your machine is running the docker daemon. To run the docker daemon in the background, simply type:
-
-   .. code-block:: bash
-
-      sudo docker -d &
-
-Now you can run docker in client mode: all commands will be forwarded to the docker daemon, so the client
-can run from any account.
-
-   .. code-block:: bash
-
-      # now you can run docker commands from any account.
-      docker help

docs/sources/examples/running_redis_service.rst

@@ -16,12 +16,13 @@ Open a docker container
 
 .. code-block:: bash
 
-    docker run -i -t base /bin/bash
+    sudo docker run -i -t ubuntu /bin/bash
 
 Building your image
 -------------------
 
-Update your docker container, install the redis server.  Once installed, exit out of docker.
+Update your Docker container, install the Redis server.  Once
+installed, exit out of the Docker container.
 
 .. code-block:: bash
 
@@ -45,7 +46,7 @@ container running in the background. Use your snapshot.
 
 .. code-block:: bash
 
-    docker run -d -p 6379 <your username>/redis /usr/bin/redis-server
+    sudo docker run -d -p 6379 <your username>/redis /usr/bin/redis-server
 
 Test 1
 ++++++
@@ -54,8 +55,8 @@ Connect to the container with the redis-cli.
 
 .. code-block:: bash
 
-    docker ps  # grab the new container id
-    docker inspect <container_id>    # grab the ipaddress of the container
+    sudo docker ps  # grab the new container id
+    sudo docker inspect <container_id>    # grab the ipaddress of the container
     redis-cli -h <ipaddress> -p 6379
     redis 10.0.3.32:6379> set docker awesome
     OK
@@ -70,8 +71,8 @@ Connect to the host os with the redis-cli.
 
 .. code-block:: bash
 
-    docker ps  # grab the new container id
-    docker port <container_id> 6379  # grab the external port
+    sudo docker ps  # grab the new container id
+    sudo docker port <container_id> 6379  # grab the external port
     ip addr show   # grab the host ip address
     redis-cli -h <host ipaddress> -p <external port>
     redis 192.168.0.1:49153> set docker awesome