Debianize

.gitignore

@@ -1,17 +1,6 @@
-.vagrant*
-bin
+.vagrant
 docker/docker
+dockerd/dockerd
 .*.swp
 a.out
 *.orig
-build_src
-command-line-arguments.test
-.flymake*
-docker.test
-auth/auth.test
-.idea
-.DS_Store
-docs/_build
-docs/_static
-docs/_templates
-.gopath/

.mailmap

@@ -1,19 +0,0 @@
-# Generate AUTHORS: git log --all --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>
-Guillaume J. Charmes <guillaume.charmes@dotcloud.com> creack <charmes.guillaume@gmail.com>
-<guillaume.charmes@dotcloud.com> <guillaume@dotcloud.com>
-<kencochrane@gmail.com> <KenCochrane@gmail.com>
-<sridharr@activestate.com> <github@srid.name>
-Thatcher Peskens <thatcher@dotcloud.com> dhrp <thatcher@dotcloud.com>
-Thatcher Peskens <thatcher@dotcloud.com> dhrp <thatcher@gmx.net>
-Jérôme Petazzoni <jerome.petazzoni@dotcloud.com> jpetazzo <jerome.petazzoni@dotcloud.com>
-Jérôme Petazzoni <jerome.petazzoni@dotcloud.com> <jp@enix.org>
-Joffrey F <joffrey@dotcloud.com>
-<joffrey@dotcloud.com> <f.joffrey@gmail.com>
-Tim Terhorst <mynamewastaken+git@gmail.com>
-Andy Smith <github@anarkystic.com>
-<kalessin@kalessin.fr> <louis@dotcloud.com>
-<victor.vieux@dotcloud.com> <victor@dotcloud.com>
-<dominik@honnef.co> <dominikh@fork-bomb.org>

AUTHORS

@@ -1,45 +0,0 @@
-Andrea Luzzardi <aluzzardi@gmail.com>
-Andy Rothfusz <github@metaliveblog.com>
-Andy Smith <github@anarkystic.com>
-Antony Messerli <amesserl@rackspace.com>
-Brian McCallister <brianm@skife.org>
-Caleb Spare <cespare@gmail.com>
-Charles Hooper <charles.hooper@dotcloud.com>
-Daniel Mizyrycki <daniel.mizyrycki@dotcloud.com>
-Daniel Robinson <gottagetmac@gmail.com>
-Dominik Honnef <dominik@honnef.co>
-Don Spaulding <donspauldingii@gmail.com>
-ezbercih <cem.ezberci@gmail.com>
-Flavio Castelli <fcastelli@suse.com>
-Francisco Souza <f@souza.cc>
-Frederick F. Kautz IV <fkautz@alumni.cmu.edu>
-Guillaume J. Charmes <guillaume.charmes@dotcloud.com>
-Hunter Blanks <hunter@twilio.com>
-Jeff Lindsay <progrium@gmail.com>
-Jeremy Grosser <jeremy@synack.me>
-Joffrey F <joffrey@dotcloud.com>
-John Costa <john.costa@gmail.com>
-Jonathan Rudenberg <jonathan@titanous.com>
-Julien Barbier <write0@gmail.com>
-Jérôme Petazzoni <jerome.petazzoni@dotcloud.com>
-Ken Cochrane <kencochrane@gmail.com>
-Kevin J. Lynagh <kevin@keminglabs.com>
-Louis Opter <kalessin@kalessin.fr>
-Maxim Treskin <zerthurd@gmail.com>
-Mikhail Sobolev <mss@mawhrin.net>
-Nelson Chen <crazysim@gmail.com>
-Niall O'Higgins <niallo@unworkable.org>
-Paul Hammond <paul@paulhammond.org>
-Piotr Bogdan <ppbogdan@gmail.com>
-Robert Obryk <robryk@gmail.com>
-Sam Alba <sam.alba@gmail.com>
-Shawn Siefkas <shawn.siefkas@meredith.com>
-Silas Sewell <silas@sewell.org>
-Solomon Hykes <solomon@dotcloud.com>
-Sridhar Ratnakumar <sridharr@activestate.com>
-Thatcher Peskens <thatcher@dotcloud.com>
-Tim Terhorst <mynamewastaken+git@gmail.com>
-Troy Howard <thoward37@gmail.com>
-unclejack <unclejacksons@gmail.com>
-Victor Vieux <victor.vieux@dotcloud.com>
-Vivek Agarwal <me@vivek.im>

CHANGELOG.md

@@ -1,86 +0,0 @@
-# Changelog
-
-## 0.2.0 (2012-04-23)
- - Runtime: ghost containers can be killed and waited for
- * Documentation: update install intructions
- - Packaging: fix Vagrantfile
- - Development: automate releasing binaries and ubuntu packages
- + Add a changelog
- - Various bugfixes
-
-
-## 0.1.8 (2013-04-22)
- - Dynamically detect cgroup capabilities
- - Issue stability warning on kernels <3.8
- - 'docker push' buffers on disk instead of memory
- - Fix 'docker diff' for removed files
- - Fix 'docker stop' for ghost containers 
- - Fix handling of pidfile
- - Various bugfixes and stability improvements
-
-## 0.1.7 (2013-04-18)
- - Container ports are available on localhost
- - 'docker ps' shows allocated TCP ports
- - Contributors can run 'make hack' to start a continuous integration VM
- - Streamline ubuntu packaging & uploading
- - Various bugfixes and stability improvements
-
-## 0.1.6 (2013-04-17)
- - Record the author an image with 'docker commit -author'
-
-## 0.1.5 (2013-04-17)
- - Disable standalone mode
- - Use a custom DNS resolver with 'docker -d -dns'
- - Detect ghost containers
- - Improve diagnosis of missing system capabilities
- - Allow disabling memory limits at compile time
- - Add debian packaging
- - Documentation: installing on Arch Linux 
- - Documentation: running Redis on docker
- - Fixed lxc 0.9 compatibility
- - Automatically load aufs module
- - Various bugfixes and stability improvements
-
-## 0.1.4 (2013-04-09)
- - Full support for TTY emulation
- - Detach from a TTY session with the escape sequence `C-p C-q`
- - Various bugfixes and stability improvements
- - Minor UI improvements
- - Automatically create our own bridge interface 'docker0'
-
-## 0.1.3 (2013-04-04)
- - Choose TCP frontend port with '-p :PORT'
- - Layer format is versioned
- - Major reliability improvements to the process manager
- - Various bugfixes and stability improvements
-
-## 0.1.2 (2013-04-03)
- - Set container hostname with 'docker run -h'
- - Selective attach at run with 'docker run -a [stdin[,stdout[,stderr]]]'
- - Various bugfixes and stability improvements
- - UI polish
- - Progress bar on push/pull
- - Use XZ compression by default
- - Make IP allocator lazy
-
-## 0.1.1 (2013-03-31)
- - Display shorthand IDs for convenience
- - Stabilize process management
- - Layers can include a commit message
- - Simplified 'docker attach'
- - Fixed support for re-attaching
- - Various bugfixes and stability improvements
- - Auto-download at run
- - Auto-login on push
- - Beefed up documentation
-
-## 0.1.0 (2013-03-23)
- - First release
- - Implement registry in order to push/pull images
- - TCP port allocation
- - Fix termcaps on Linux
- - Add documentation
- - Add Vagrant support with Vagrantfile
- - Add unit tests
- - Add repository/tags to ease image management
- - Improve the layer implementation

CONTRIBUTING.md

@@ -1,93 +0,0 @@
-# Contributing to Docker
-
-Want to hack on Docker? Awesome! There are instructions to get you
-started on the website: http://docker.io/gettingstarted.html
-
-They are probably not perfect, please let us know if anything feels
-wrong or incomplete.
-
-## Contribution guidelines
-
-### Pull requests are always welcome
-
-We are always thrilled to receive pull requests, and do our best to
-process them as fast as possible. Not sure if that typo is worth a pull
-request? Do it! We will appreciate it.
-
-If your pull request is not accepted on the first try, don't be
-discouraged! If there's a problem with the implementation, hopefully you
-received feedback on what to improve.
-
-We're trying very hard to keep Docker lean and focused. We don't want it
-to do everything for everybody. This means that we might decide against
-incorporating a new feature. However, there might be a way to implement
-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)
-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
-else is working on the same thing.
-
-### Create issues...
-
-Any significant improvement should be documented as [a github
-issue](https://github.com/dotcloud/docker/issues) before anybody
-starts working on it.
-
-### ...but check for existing issues first!
-
-Please take a moment to check that an issue doesn't already exist
-documenting your bug report or improvement proposal. If it does, it
-never hurts to add a quick "+1" or "I have this problem too". This will
-help prioritize the most common problems and requests.
-
-### Conventions
-
-Fork the repo and make changes on your fork in a feature branch:
-
-- If it's a bugfix branch, name it XXX-something where XXX is the number of the
-  issue
-- If it's a feature branch, create an enhancement issue to announce your
-  intentions, and name it XXX-something where XXX is the number of the issue.
-
-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.
-
-Write clean code. Universally formatted code promotes ease of writing, reading,
-and maintenance. Always run `go fmt` before committing your changes. Most
-editors have plugins that do this automatically, and there's also a git
-pre-commit hook:
-
-```
-curl -o .git/hooks/pre-commit https://raw.github.com/edsrzf/gofmt-git-hook/master/fmt-check && chmod +x .git/hooks/pre-commit
-```
-
-Pull requests descriptions should be as clear as possible and include a
-reference to all the issues that they address.
-
-Code review comments may be added to your pull request. Discuss, then make the
-suggested modifications and push additional commits to your feature branch. Be
-sure to post a comment after pushing. The new commits will show up in the pull
-request automatically, but the reviewers will not be notified unless you
-comment.
-
-Before the pull request is merged, make sure that you squash your commits into
-logical units of work using `git rebase -i` and `git push -f`. After every
-commit the test suite should be passing. Include documentation changes in the
-same commit so that a revert would remove all traces of the feature or fix.
-
-Commits that fix or close an issue should include a reference like `Closes #XXX`
-or `Fixes #XXX`, which will automatically close the issue when merged.
-
-Add your name to the AUTHORS file, but make sure the list is sorted and your
-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.

Makefile

@@ -1,78 +1,23 @@
-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
+GOPATH := $(PWD)/env
+BUILDPATH := $(PWD)/build
 
-GIT_ROOT := $(shell git rev-parse --show-toplevel)
-BUILD_DIR := $(CURDIR)/.gopath
+all: docker.o dockerd.o
 
-GOPATH ?= $(BUILD_DIR)
-export GOPATH
+env:
+	mkdir -p ${BUILDPATH} ${GOPATH}/src/github.com/dotcloud/
+	ln -s $(PWD) ${GOPATH}/src/github.com/dotcloud/docker
 
-GO_OPTIONS ?=
-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 = -ldflags "-X main.GIT_COMMIT $(GIT_COMMIT)$(GIT_STATUS)"
-
-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); go build $(GO_OPTIONS) $(BUILD_OPTIONS) -o $@)
-	@echo $(DOCKER_BIN_RELATIVE) is created.
-
-$(DOCKER_DIR):
-	@mkdir -p $(dir $@)
-	@rm -f $@
-	@ln -sf $(CURDIR)/ $@
-	@(cd $(DOCKER_MAIN); go get $(GO_OPTIONS))
-
-whichrelease:
-	echo $(RELEASE_VERSION)
-
-release: $(BINRELEASE)
-srcrelease: $(SRCRELEASE)
-deps: $(DOCKER_DIR)
-
-# A clean checkout of $RELEASE_VERSION, with vendored dependencies
-$(SRCRELEASE):
-	rm -fr $(SRCRELEASE)
-	git clone $(GIT_ROOT) $(SRCRELEASE)
-	cd $(SRCRELEASE); git checkout -q $(RELEASE_VERSION)
-
-# A binary release ready to be uploaded to a mirror
-$(BINRELEASE): $(SRCRELEASE)
-	rm -f $(BINRELEASE)
-	cd $(SRCRELEASE); make; cp -R bin docker-$(RELEASE_VERSION); tar -f ../$(BINRELEASE) -zv -c docker-$(RELEASE_VERSION)
+deps:
+	GOPATH=${GOPATH} go get github.com/kr/pty
+	GOPATH=${GOPATH} go get github.com/mattn/go-sqlite3
+	GOPATH=${GOPATH} go get github.com/shykes/gorp
 
 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
+	go clean
+	rm -rf env build
 
-test: all
-	@(cd $(DOCKER_DIR); sudo -E go test $(GO_OPTIONS))
+docker.o: env deps
+	GOPATH=${GOPATH} go build -o ${BUILDPATH}/docker docker/docker.go
 
-fmt:
-	@gofmt -s -l -w .
-
-hack:
-	cd $(CURDIR)/buildbot && vagrant up
+dockerd.o: env deps
+	GOPATH=${GOPATH} go build -o ${BUILDPATH}/dockerd dockerd/dockerd.go

README.md

@@ -1,17 +1,17 @@
-Docker: the Linux container runtime
-===================================
+Docker is a process manager with superpowers
+============================================
 
-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.
+It encapsulates heterogeneous payloads in Standard Containers, and runs them on any server with strong guarantees of isolation and repeatability.
 
-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.
+Is is a great building block for automating distributed systems: large-scale web deployments, database clusters, continuous deployment systems, private PaaS, service-oriented architectures, etc.
 
-![Docker L](docs/sources/static_files/lego_docker.jpg "Docker")
+<img src="http://bricks.argz.com/bricksfiles/lego/07000/7823/012.jpg"/>
 
 * *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.
+* *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.
 
@@ -25,146 +25,15 @@ Notable features
 
 * Network isolation: each process container runs in its own network namespace, with a virtual interface and IP address of its own.
 
-* Copy-on-write: root filesystems are created using copy-on-write, which makes deployment extremely fast, memory-cheap and disk-cheap.
+* Copy-on-write: root filesystems are created using copy-on-write, which makes deployment extremeley fast, memory-cheap and disk-cheap.
 
-* Logging: the standard streams (stdout/stderr/stdin) of each process container are collected and logged for real-time or batch retrieval.
+* Logging: the standard streams (stdout/stderr/stdin) of each process container is collected and logged for real-time or batch retrieval.
 
 * Change management: changes to a container's filesystem can be committed into a new image and re-used to create more containers. No templating or manual configuration required.
 
-* Interactive shell: docker can allocate a pseudo-tty and attach to the standard input of any container, for example to run a throwaway interactive shell.
-
-Install instructions
-==================
-
-Quick install on Ubuntu 12.04 and 12.10
----------------------------------------
-
-```bash
-curl get.docker.io | sh -x
-```
-
-Binary installs
-----------------
-
-Docker supports the following binary installation methods.
-Note that some methods are community contributions and not yet officially supported.
-
-* [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/)
-* [MacOS X (with Vagrant)](http://docs.docker.io/en/latest/installation/macos/)
-* [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 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
----------------------------
-
-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
-```
+* Interactive shell: docker can allocate a pseudo-tty and attach to the standard input of any container, for example to run a throaway interactive shell.
 
 
-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 $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.
-IP=$(ifconfig eth0 | perl -n -e 'if (m/inet addr:([\d\.]+)/g) { print $1 }')
-echo hello world | nc $IP $PORT
-
-# Verify that the network connection worked
-echo "Daemon received: $(docker logs $JOB)"
-```
 
 Under the hood
 --------------
@@ -181,60 +50,47 @@ Under the hood, Docker is built on the following components:
 * [lxc](http://lxc.sourceforge.net/), a set of convenience scripts to simplify the creation of linux containers.
 
 
+Setup instructions
+==================
 
-Contributing to Docker
-======================
+Requirements
+------------
 
-Want to hack on Docker? Awesome! There are instructions to get you started on the website: http://docs.docker.io/en/latest/contributing/contributing/
+Right now, the officially supported distributions are:
 
-They are probably not perfect, please let us know if anything feels wrong or incomplete.
+* Ubuntu 12.04 (precise LTS)
+* Ubuntu 12.10 (quantal)
+
+Docker probably works on other distributions featuring a recent kernel, the AUFS patch, and up-to-date lxc. However this has not been tested.
 
 
-Note
-----
+Installation
+---------------
 
-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/master/docs/README.md
+1. Set up your host of choice on a physical / virtual machine
+2. Assume root identity on your newly installed environment (`sudo -s`)
+3. Type the following commands:
 
-Please feel free to fix / update the documentation and send us pull requests. More tutorials are also welcome.
+        apt-get update
+        apt-get install lxc wget bsdtar curl
 
+4. Download the latest docker binaries: `wget http://docker.io.s3.amazonaws.com/builds/$(uname -s)/$(uname -m)/docker-master.tgz` ([Or get the Linux/x86_64 binaries here](http://docker.io.s3.amazonaws.com/builds/Linux/x86_64/docker-master.tgz) )
+5. Extract the contents of the tar file `tar -xf docker-master.tar.gz`
+6. Launch the docker daemon in the background `./dockerd &`
+7. Download a base image `./docker pull base`
+8. Run your first container! `./docker run -i -a -t base /bin/bash`
+9. Start exploring `./docker --help`
 
-Setting up a dev environment
-----------------------------
-
-Instructions that have been verified to work on Ubuntu 12.10,
-
-```bash
-sudo apt-get -y install lxc wget bsdtar curl 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 git@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.
+Consider adding docker and dockerd to your `PATH` for simplicity.
 
 
 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.
+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 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.
+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 (http://bricks.argz.com/ins/7823-1/12) are a fundamental unit of physical delivery.
 
@@ -245,7 +101,7 @@ Just like shipping containers, Standard Containers define a set of STANDARD OPER
 
 ### 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.
+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 coffe 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

SPECS/data-volumes.md

@@ -1,71 +0,0 @@
-
-## Spec for data volumes
-
-Spec owner: Solomon Hykes <solomon@dotcloud.com>
-
-Data volumes (issue #111) are a much-requested feature which trigger much discussion and debate. Below is the current authoritative spec for implementing data volumes.
-This spec will be deprecated once the feature is fully implemented.
-
-Discussion, requests, trolls, demands, offerings, threats and other forms of supplications concerning this spec should be addressed to Solomon here: https://github.com/dotcloud/docker/issues/111
-
-
-### 1. Creating data volumes
-
-At container creation, parts of a container's filesystem can be mounted as separate data volumes. Volumes are defined with the -v flag.
-
-For example:
-
-```bash
-$ docker run -v /var/lib/postgres -v /var/log postgres /usr/bin/postgres
-```
-
-In this example, a new container is created from the 'postgres' image. At the same time, docker creates 2 new data volumes: one will be mapped to the container at /var/lib/postgres, the other at /var/log.
-
-2 important notes:
-
-1) Volumes don't have top-level names. At no point does the user provide a name, or is a name given to him. Volumes are identified by the path at which they are mounted inside their container.
-
-2) The user doesn't choose the source of the volume. Docker only mounts volumes it created itself, in the same way that it only runs containers that it created itself. That is by design.
-
-
-### 2. Sharing data volumes
-
-Instead of creating its own volumes, a container can share another container's volumes. For example:
-
-```bash
-$ docker run --volumes-from $OTHER_CONTAINER_ID postgres /usr/local/bin/postgres-backup
-```
-
-In this example, a new container is created from the 'postgres' example. At the same time, docker will *re-use* the 2 data volumes created in the previous example. One volume will be mounted on the /var/lib/postgres of *both* containers, and the other will be mounted on the /var/log of both containers.
-
-### 3. Under the hood
-
-Docker stores volumes in /var/lib/docker/volumes. Each volume receives a globally unique ID at creation, and is stored at /var/lib/docker/volumes/ID.
-
-At creation, volumes are attached to a single container - the source of truth for this mapping will be the container's configuration.
-
-Mounting a volume consists of calling "mount --bind" from the volume's directory to the appropriate sub-directory of the container mountpoint. This may be done by Docker itself, or farmed out to lxc (which supports mount-binding) if possible.
-
-
-### 4. Backups, transfers and other volume operations
-
-Volumes sometimes need to be backed up, transfered between hosts, synchronized, etc. These operations typically are application-specific or site-specific, eg. rsync vs. S3 upload vs. replication vs...
-
-Rather than attempting to implement all these scenarios directly, Docker will allow for custom implementations using an extension mechanism.
-
-### 5. Custom volume handlers
-
-Docker allows for arbitrary code to be executed against a container's volumes, to implement any custom action: backup, transfer, synchronization across hosts, etc.
-
-Here's an example:
-
-```bash
-$ DB=$(docker run -d -v /var/lib/postgres -v /var/log postgres /usr/bin/postgres)
-
-$ BACKUP_JOB=$(docker run -d --volumes-from $DB shykes/backuper /usr/local/bin/backup-postgres --s3creds=$S3CREDS)
-
-$ docker wait $BACKUP_JOB
-```
-
-Congratulations, you just implemented a custom volume handler, using Docker's built-in ability to 1) execute arbitrary code and 2) share volumes between containers.
-

Vagrantfile

@@ -1,82 +1,100 @@
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-def v10(config)
-  config.vm.box = 'precise64'
-  config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
-
-  # Install ubuntu packaging dependencies and create ubuntu packages
-  config.vm.provision :shell, :inline => "echo 'deb http://ppa.launchpad.net/dotcloud/lxc-docker/ubuntu precise main' >>/etc/apt/sources.list"
-  config.vm.provision :shell, :inline => 'export DEBIAN_FRONTEND=noninteractive; apt-get -qq update; apt-get install -qq -y --force-yes lxc-docker'
-end
-
-Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|
-  v10(config)
-end
-
-Vagrant::VERSION >= "1.1.0" and Vagrant.configure("1") do |config|
-  v10(config)
-end
-
-Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
-  config.vm.provider :aws do |aws|
-    config.vm.box = "dummy"
-    config.vm.box_url = "https://github.com/mitchellh/vagrant-aws/raw/master/dummy.box"
-    aws.access_key_id = ENV["AWS_ACCESS_KEY_ID"]
-    aws.secret_access_key =     ENV["AWS_SECRET_ACCESS_KEY"]
-    aws.keypair_name = ENV["AWS_KEYPAIR_NAME"]
-    aws.ssh_private_key_path = ENV["AWS_SSH_PRIVKEY"]
-    aws.region = "us-east-1"
-    aws.ami = "ami-d0f89fb9"
-    aws.ssh_username = "ubuntu"
-    aws.instance_type = "t1.micro"
-  end
-
-  config.vm.provider :rackspace do |rs|
-    config.vm.box = "dummy"
-    config.vm.box_url = "https://github.com/mitchellh/vagrant-rackspace/raw/master/dummy.box"
-    config.ssh.private_key_path = ENV["RS_PRIVATE_KEY"]
-    rs.username = ENV["RS_USERNAME"]
-    rs.api_key  = ENV["RS_API_KEY"]
-    rs.public_key_path = ENV["RS_PUBLIC_KEY"]
-    rs.flavor   = /512MB/
-    rs.image    = /Ubuntu/
-  end
-
-  config.vm.provider :virtualbox do |vb|
-    config.vm.box = 'precise64'
-    config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
-  end
-end
-
-Vagrant::VERSION >= "1.2.0" and Vagrant.configure("2") do |config|
-  config.vm.provider :aws do |aws, override|
-    config.vm.box = "dummy"
-    config.vm.box_url = "https://github.com/mitchellh/vagrant-aws/raw/master/dummy.box"
-    aws.access_key_id = ENV["AWS_ACCESS_KEY_ID"]
-    aws.secret_access_key = ENV["AWS_SECRET_ACCESS_KEY"]
-    aws.keypair_name = ENV["AWS_KEYPAIR_NAME"]
-    override.ssh.private_key_path = ENV["AWS_SSH_PRIVKEY"]
-    override.ssh.username = "ubuntu"
-    aws.region = "us-east-1"
-    aws.ami = "ami-d0f89fb9"
-    aws.instance_type = "t1.micro"
-  end
-
-  config.vm.provider :rackspace do |rs|
-    config.vm.box = "dummy"
-    config.vm.box_url = "https://github.com/mitchellh/vagrant-rackspace/raw/master/dummy.box"
-    config.ssh.private_key_path = ENV["RS_PRIVATE_KEY"]
-    rs.username = ENV["RS_USERNAME"]
-    rs.api_key  = ENV["RS_API_KEY"]
-    rs.public_key_path = ENV["RS_PUBLIC_KEY"]
-    rs.flavor   = /512MB/
-    rs.image    = /Ubuntu/
-  end
-
-  config.vm.provider :virtualbox do |vb|
-    config.vm.box = 'precise64'
-    config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
-  end
+Vagrant::Config.run do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
 
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "quantal64_3.5.0-25"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  config.vm.box_url = "http://get.docker.io/vbox/ubuntu/12.10/quantal64_3.5.0-25.box"
+
+  # Boot with a GUI so you can see the screen. (Default is headless)
+  # config.vm.boot_mode = :gui
+
+  # Assign this VM to a host-only network IP, allowing you to access it
+  # via the IP. Host-only networks can talk to the host machine as well as
+  # any other machines on the same network, but cannot be accessed (through this
+  # network interface) by any external networks.
+  # config.vm.network :hostonly, "192.168.33.10"
+
+  # Assign this VM to a bridged network, allowing you to connect directly to a
+  # network using the host's network device. This makes the VM appear as another
+  # physical device on your network.
+  # config.vm.network :bridged
+
+  # Forward a port from the guest to the host, which allows for outside
+  # computers to access the VM, whereas host only networking does not.
+  # config.vm.forward_port 80, 8080
+
+  # Share an additional folder to the guest VM. The first argument is
+  # an identifier, the second is the path on the guest to mount the
+  # folder, and the third is the path on the host to the actual folder.
+  # config.vm.share_folder "v-data", "/vagrant_data", "../data"
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file quantal64.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  config.vm.provision :puppet do |puppet|
+    puppet.manifests_path = "puppet/manifests"
+    puppet.manifest_file  = "quantal64.pp"
+    puppet.module_path = "puppet/modules"
+  end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding 
+  # some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :mysql_password => "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision :chef_client do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # IF you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
 end

auth/auth.go

@@ -1,168 +0,0 @@
-package auth
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path"
-	"strings"
-)
-
-// Where we store the config file
-const CONFIGFILE = ".dockercfg"
-
-// the registry server we want to login against
-const REGISTRY_SERVER = "https://registry.docker.io"
-
-type AuthConfig struct {
-	Username string `json:"username"`
-	Password string `json:"password"`
-	Email    string `json:"email"`
-	rootPath string `json:-`
-}
-
-func NewAuthConfig(username, password, email, rootPath string) *AuthConfig {
-	return &AuthConfig{
-		Username: username,
-		Password: password,
-		Email:    email,
-		rootPath: rootPath,
-	}
-}
-
-// create a base64 encoded auth string to store in config
-func EncodeAuth(authConfig *AuthConfig) string {
-	authStr := authConfig.Username + ":" + authConfig.Password
-	msg := []byte(authStr)
-	encoded := make([]byte, base64.StdEncoding.EncodedLen(len(msg)))
-	base64.StdEncoding.Encode(encoded, msg)
-	return string(encoded)
-}
-
-// decode the auth string
-func DecodeAuth(authStr string) (*AuthConfig, error) {
-	decLen := base64.StdEncoding.DecodedLen(len(authStr))
-	decoded := make([]byte, decLen)
-	authByte := []byte(authStr)
-	n, err := base64.StdEncoding.Decode(decoded, authByte)
-	if err != nil {
-		return nil, err
-	}
-	if n > decLen {
-		return nil, fmt.Errorf("Something went wrong decoding auth config")
-	}
-	arr := strings.Split(string(decoded), ":")
-	if len(arr) != 2 {
-		return nil, fmt.Errorf("Invalid auth configuration file")
-	}
-	password := strings.Trim(arr[1], "\x00")
-	return &AuthConfig{Username: arr[0], Password: password}, nil
-
-}
-
-// load up the auth config information and return values
-// FIXME: use the internal golang config parser
-func LoadConfig(rootPath string) (*AuthConfig, error) {
-	confFile := path.Join(rootPath, CONFIGFILE)
-	if _, err := os.Stat(confFile); err != nil {
-		return &AuthConfig{}, fmt.Errorf("The Auth config file is missing")
-	}
-	b, err := ioutil.ReadFile(confFile)
-	if err != nil {
-		return nil, err
-	}
-	arr := strings.Split(string(b), "\n")
-	origAuth := strings.Split(arr[0], " = ")
-	origEmail := strings.Split(arr[1], " = ")
-	authConfig, err := DecodeAuth(origAuth[1])
-	if err != nil {
-		return nil, err
-	}
-	authConfig.Email = origEmail[1]
-	authConfig.rootPath = rootPath
-	return authConfig, nil
-}
-
-// save the auth config
-func saveConfig(rootPath, authStr string, email string) error {
-	lines := "auth = " + authStr + "\n" + "email = " + email + "\n"
-	b := []byte(lines)
-	err := ioutil.WriteFile(path.Join(rootPath, CONFIGFILE), b, 0600)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// try to register/login to the registry server
-func Login(authConfig *AuthConfig) (string, error) {
-	storeConfig := false
-	reqStatusCode := 0
-	var status string
-	var errMsg string
-	var reqBody []byte
-	jsonBody, err := json.Marshal(authConfig)
-	if err != nil {
-		errMsg = fmt.Sprintf("Config Error: %s", err)
-		return "", errors.New(errMsg)
-	}
-
-	// using `bytes.NewReader(jsonBody)` here causes the server to respond with a 411 status.
-	b := strings.NewReader(string(jsonBody))
-	req1, err := http.Post(REGISTRY_SERVER+"/v1/users", "application/json; charset=utf-8", b)
-	if err != nil {
-		errMsg = fmt.Sprintf("Server Error: %s", err)
-		return "", errors.New(errMsg)
-	}
-
-	reqStatusCode = req1.StatusCode
-	defer req1.Body.Close()
-	reqBody, err = ioutil.ReadAll(req1.Body)
-	if err != nil {
-		errMsg = fmt.Sprintf("Server Error: [%#v] %s", reqStatusCode, err)
-		return "", errors.New(errMsg)
-	}
-
-	if reqStatusCode == 201 {
-		status = "Account Created\n"
-		storeConfig = true
-	} else if reqStatusCode == 400 {
-		// FIXME: This should be 'exists', not 'exist'. Need to change on the server first.
-		if string(reqBody) == "Username or email already exist" {
-			client := &http.Client{}
-			req, err := http.NewRequest("GET", REGISTRY_SERVER+"/v1/users", nil)
-			req.SetBasicAuth(authConfig.Username, authConfig.Password)
-			resp, err := client.Do(req)
-			if err != nil {
-				return "", err
-			}
-			defer resp.Body.Close()
-			body, err := ioutil.ReadAll(resp.Body)
-			if err != nil {
-				return "", err
-			}
-			if resp.StatusCode == 200 {
-				status = "Login Succeeded\n"
-				storeConfig = true
-			} else {
-				status = fmt.Sprintf("Login: %s", body)
-				return "", errors.New(status)
-			}
-		} else {
-			status = fmt.Sprintf("Registration: %s", reqBody)
-			return "", errors.New(status)
-		}
-	} else {
-		status = fmt.Sprintf("[%s] : %s", reqStatusCode, reqBody)
-		return "", errors.New(status)
-	}
-	if storeConfig {
-		authStr := EncodeAuth(authConfig)
-		saveConfig(authConfig.rootPath, authStr, authConfig.Email)
-	}
-	return status, nil
-}

auth/auth_test.go

@@ -1,23 +0,0 @@
-package auth
-
-import (
-	"testing"
-)
-
-func TestEncodeAuth(t *testing.T) {
-	newAuthConfig := &AuthConfig{Username: "ken", Password: "test", Email: "test@example.com"}
-	authStr := EncodeAuth(newAuthConfig)
-	decAuthConfig, err := DecodeAuth(authStr)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if newAuthConfig.Username != decAuthConfig.Username {
-		t.Fatal("Encode Username doesn't match decoded Username")
-	}
-	if newAuthConfig.Password != decAuthConfig.Password {
-		t.Fatal("Encode Password doesn't match decoded Password")
-	}
-	if authStr != "a2VuOnRlc3Q=" {
-		t.Fatal("AuthString encoding isn't correct.")
-	}
-}

buildbot/README.rst

@@ -1,20 +0,0 @@
-Buildbot
-========
-
-Buildbot is a continuous integration system designed to automate the
-build/test cycle. By automatically rebuilding and testing the tree each time
-something has changed, build problems are pinpointed quickly, before other
-developers are inconvenienced by the failure.
-
-When running 'make hack' at the docker root directory, it spawns a virtual
-machine in the background running a buildbot instance and adds a git
-post-commit hook that automatically run docker tests for you.
-
-You can check your buildbot instance at http://192.168.33.21:8010/waterfall
-
-
-Buildbot dependencies
----------------------
-
-vagrant, virtualbox packages and python package requests
-

buildbot/Vagrantfile

@@ -1,28 +0,0 @@
-# -*- mode: ruby -*-
-# vi: set ft=ruby :
-
-$BUILDBOT_IP = '192.168.33.21'
-
-def v10(config)
-  config.vm.box = "quantal64_3.5.0-25"
-  config.vm.box_url = "http://get.docker.io/vbox/ubuntu/12.10/quantal64_3.5.0-25.box"
-  config.vm.share_folder 'v-data', '/data/docker', File.dirname(__FILE__) + '/..'
-  config.vm.network :hostonly, $BUILDBOT_IP
-
-  # Ensure puppet is installed on the instance
-  config.vm.provision :shell, :inline => 'apt-get -qq update; apt-get install -y puppet'
-
-  config.vm.provision :puppet do |puppet|
-    puppet.manifests_path = '.'
-    puppet.manifest_file  = 'buildbot.pp'
-    puppet.options = ['--templatedir','.']
-  end
-end
-
-Vagrant::VERSION < '1.1.0' and Vagrant::Config.run do |config|
-  v10(config)
-end
-
-Vagrant::VERSION >= '1.1.0' and Vagrant.configure('1') do |config|
-  v10(config)
-end

buildbot/buildbot-cfg/buildbot-cfg.sh

@@ -1,43 +0,0 @@
-#!/bin/bash
-
-# Auto setup of buildbot configuration. Package installation is being done
-# on buildbot.pp
-# Dependencies: buildbot, buildbot-slave, supervisor
-
-SLAVE_NAME='buildworker'
-SLAVE_SOCKET='localhost:9989'
-BUILDBOT_PWD='pass-docker'
-USER='vagrant'
-ROOT_PATH='/data/buildbot'
-DOCKER_PATH='/data/docker'
-BUILDBOT_CFG="$DOCKER_PATH/buildbot/buildbot-cfg"
-IP=$(grep BUILDBOT_IP /data/docker/buildbot/Vagrantfile | awk -F "'" '{ print $2; }')
-
-function run { su $USER -c "$1"; }
-
-export PATH=/bin:sbin:/usr/bin:/usr/sbin:/usr/local/bin
-
-# Exit if buildbot has already been installed
-[ -d "$ROOT_PATH" ] && exit 0
-
-# Setup buildbot
-run "mkdir -p ${ROOT_PATH}"
-cd ${ROOT_PATH}
-run "buildbot create-master master"
-run "cp $BUILDBOT_CFG/master.cfg master"
-run "sed -i 's/localhost/$IP/' master/master.cfg"
-run "buildslave create-slave slave $SLAVE_SOCKET $SLAVE_NAME $BUILDBOT_PWD"
-
-# Allow buildbot subprocesses (docker tests) to properly run in containers,
-# in particular with docker -u
-run "sed -i 's/^umask = None/umask = 000/' ${ROOT_PATH}/slave/buildbot.tac"
-
-# Setup supervisor
-cp $BUILDBOT_CFG/buildbot.conf /etc/supervisor/conf.d/buildbot.conf
-sed -i "s/^chmod=0700.*0700./chmod=0770\nchown=root:$USER/" /etc/supervisor/supervisord.conf
-kill -HUP `pgrep -f "/usr/bin/python /usr/bin/supervisord"`
-
-# Add git hook
-cp $BUILDBOT_CFG/post-commit $DOCKER_PATH/.git/hooks
-sed -i "s/localhost/$IP/" $DOCKER_PATH/.git/hooks/post-commit
-

buildbot/buildbot-cfg/buildbot.conf

@@ -1,18 +0,0 @@
-[program:buildmaster]
-command=su vagrant -c "buildbot start master"
-directory=/data/buildbot
-chown= root:root
-redirect_stderr=true
-stdout_logfile=/var/log/supervisor/buildbot-master.log
-stderr_logfile=/var/log/supervisor/buildbot-master.log
-
-[program:buildworker]
-command=buildslave start slave
-directory=/data/buildbot
-chown= root:root
-redirect_stderr=true
-stdout_logfile=/var/log/supervisor/buildbot-slave.log
-stderr_logfile=/var/log/supervisor/buildbot-slave.log
-
-[group:buildbot]
-programs=buildmaster,buildworker

buildbot/buildbot-cfg/master.cfg

@@ -1,46 +0,0 @@
-import os
-from buildbot.buildslave import BuildSlave
-from buildbot.schedulers.forcesched import ForceScheduler
-from buildbot.config import BuilderConfig
-from buildbot.process.factory import BuildFactory
-from buildbot.steps.shell import ShellCommand
-from buildbot.status import html
-from buildbot.status.web import authz, auth
-
-PORT_WEB = 8010         # Buildbot webserver port
-PORT_MASTER = 9989      # Port where buildbot master listen buildworkers
-TEST_USER = 'buildbot'  # Credential to authenticate build triggers
-TEST_PWD = 'docker'     # Credential to authenticate build triggers
-BUILDER_NAME = 'docker'
-BUILDPASSWORD = 'pass-docker'  # Credential to authenticate buildworkers
-DOCKER_PATH = '/data/docker'
-
-
-c = BuildmasterConfig = {}
-
-c['title'] = "Docker"
-c['titleURL'] = "waterfall"
-c['buildbotURL'] = "http://localhost:{0}/".format(PORT_WEB)
-c['db'] = {'db_url':"sqlite:///state.sqlite"}
-c['slaves'] = [BuildSlave('buildworker', BUILDPASSWORD)]
-c['slavePortnum'] = PORT_MASTER
-
-c['schedulers'] = [ForceScheduler(name='trigger',builderNames=[BUILDER_NAME])]
-
-# Docker test command
-test_cmd = """(
-    cd {0}/..; rm -rf docker-tmp; git clone docker docker-tmp;
-    cd docker-tmp; make test; exit_status=$?;
-    cd ..; rm -rf docker-tmp; exit $exit_status)""".format(DOCKER_PATH)
-
-# Builder
-factory = BuildFactory()
-factory.addStep(ShellCommand(description='Docker',logEnviron=False,
-    usePTY=True,command=test_cmd))
-c['builders'] = [BuilderConfig(name=BUILDER_NAME,slavenames=['buildworker'],
-    factory=factory)]
-
-# Status
-authz_cfg=authz.Authz(auth=auth.BasicAuth([(TEST_USER,TEST_PWD)]),
-    forceBuild='auth')
-c['status'] = [html.WebStatus(http_port=PORT_WEB, authz=authz_cfg)]

buildbot/buildbot-cfg/post-commit

@@ -1,21 +0,0 @@
-#!/usr/bin/env python
-
-'''Trigger buildbot docker test build
-
-   post-commit git hook designed to automatically trigger buildbot on
-   the provided vagrant docker VM.'''
-
-import requests
-
-USERNAME = 'buildbot'
-PASSWORD = 'docker'
-BASE_URL = 'http://localhost:8010'
-path = lambda s: BASE_URL + '/' + s
-
-try:
-    session = requests.session()
-    session.post(path('login'),data={'username':USERNAME,'passwd':PASSWORD})
-    session.post(path('builders/docker/force'),
-        data={'forcescheduler':'trigger','reason':'Test commit'})
-except:
-    pass

buildbot/buildbot.pp

@@ -1,32 +0,0 @@
-node default {
-    $USER = 'vagrant'
-    $ROOT_PATH = '/data/buildbot'
-    $DOCKER_PATH = '/data/docker'
-
-    exec {'apt_update': command => '/usr/bin/apt-get update' }
-    Package { require => Exec['apt_update'] }
-    group {'puppet': ensure => 'present'}
-
-    # Install dependencies
-    Package { ensure => 'installed' }
-    package { ['python-dev','python-pip','supervisor','lxc','bsdtar','git','golang']: }
-
-    file{[ '/data' ]:
-        owner => $USER, group => $USER, ensure => 'directory' }
-
-    file {'/var/tmp/requirements.txt':
-        content => template('requirements.txt') }
-
-    exec {'requirements':
-        require => [ Package['python-dev'], Package['python-pip'],
-            File['/var/tmp/requirements.txt'] ],
-        cwd     => '/var/tmp',
-        command => "/bin/sh -c '(/usr/bin/pip install -r requirements.txt;
-            rm /var/tmp/requirements.txt)'" }
-
-    exec {'buildbot-cfg-sh':
-        require => [ Package['supervisor'], Exec['requirements']],
-        path    => '/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin',
-        cwd     => '/data',
-        command => "$DOCKER_PATH/buildbot/buildbot-cfg/buildbot-cfg.sh" }
-}

buildbot/requirements.txt

@@ -1,6 +0,0 @@
-sqlalchemy<=0.7.9
-sqlalchemy-migrate>=0.7.2
-buildbot==0.8.7p1
-buildbot_slave==0.8.7p1
-nose==1.2.1
-requests==1.1.0

builder.go

@@ -1,169 +0,0 @@
-package docker
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"strings"
-)
-
-type Builder struct {
-	runtime *Runtime
-}
-
-func NewBuilder(runtime *Runtime) *Builder {
-	return &Builder{
-		runtime: runtime,
-	}
-}
-
-func (builder *Builder) Run(image *Image, cmd ...string) (*Container, error) {
-	// FIXME: pass a NopWriter instead of nil
-	config, err := ParseRun(append([]string{"-d", image.Id}, cmd...), nil, builder.runtime.capabilities)
-	if config.Image == "" {
-		return nil, fmt.Errorf("Image not specified")
-	}
-	if len(config.Cmd) == 0 {
-		return nil, fmt.Errorf("Command not specified")
-	}
-	if config.Tty {
-		return nil, fmt.Errorf("The tty mode is not supported within the builder")
-	}
-
-	// Create new container
-	container, err := builder.runtime.Create(config)
-	if err != nil {
-		return nil, err
-	}
-	if err := container.Start(); err != nil {
-		return nil, err
-	}
-	return container, nil
-}
-
-func (builder *Builder) Commit(container *Container, repository, tag, comment, author string) (*Image, error) {
-	return builder.runtime.Commit(container.Id, repository, tag, comment, author)
-}
-
-func (builder *Builder) clearTmp(containers, images map[string]struct{}) {
-	for c := range containers {
-		tmp := builder.runtime.Get(c)
-		builder.runtime.Destroy(tmp)
-		Debugf("Removing container %s", c)
-	}
-	for i := range images {
-		builder.runtime.graph.Delete(i)
-		Debugf("Removing image %s", i)
-	}
-}
-
-func (builder *Builder) Build(dockerfile io.Reader, stdout io.Writer) error {
-	var (
-		image, base   *Image
-		tmpContainers map[string]struct{} = make(map[string]struct{})
-		tmpImages     map[string]struct{} = make(map[string]struct{})
-	)
-	defer builder.clearTmp(tmpContainers, tmpImages)
-
-	file := bufio.NewReader(dockerfile)
-	for {
-		line, err := file.ReadString('\n')
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return err
-		}
-		line = strings.TrimSpace(line)
-		// Skip comments and empty line
-		if len(line) == 0 || line[0] == '#' {
-			continue
-		}
-		tmp := strings.SplitN(line, "	", 2)
-		if len(tmp) != 2 {
-			return fmt.Errorf("Invalid Dockerfile format")
-		}
-		switch tmp[0] {
-		case "from":
-			fmt.Fprintf(stdout, "FROM %s\n", tmp[1])
-			image, err = builder.runtime.repositories.LookupImage(tmp[1])
-			if err != nil {
-				return err
-			}
-			break
-		case "run":
-			fmt.Fprintf(stdout, "RUN %s\n", tmp[1])
-			if image == nil {
-				return fmt.Errorf("Please provide a source image with `from` prior to run")
-			}
-
-			// Create the container and start it
-			c, err := builder.Run(image, "/bin/sh", "-c", tmp[1])
-			if err != nil {
-				return err
-			}
-			tmpContainers[c.Id] = struct{}{}
-
-			// Wait for it to finish
-			if result := c.Wait(); result != 0 {
-				return fmt.Errorf("!!! '%s' return non-zero exit code '%d'. Aborting.", tmp[1], result)
-			}
-
-			// Commit the container
-			base, err = builder.Commit(c, "", "", "", "")
-			if err != nil {
-				return err
-			}
-			tmpImages[base.Id] = struct{}{}
-
-			fmt.Fprintf(stdout, "===> %s\n", base.ShortId())
-			break
-		case "copy":
-			if image == nil {
-				return fmt.Errorf("Please provide a source image with `from` prior to copy")
-			}
-			tmp2 := strings.SplitN(tmp[1], " ", 2)
-			if len(tmp) != 2 {
-				return fmt.Errorf("Invalid COPY format")
-			}
-			fmt.Fprintf(stdout, "COPY %s to %s in %s\n", tmp2[0], tmp2[1], base.ShortId())
-
-			file, err := Download(tmp2[0], stdout)
-			if err != nil {
-				return err
-			}
-			defer file.Body.Close()
-
-			c, err := builder.Run(base, "echo", "insert", tmp2[0], tmp2[1])
-			if err != nil {
-				return err
-			}
-
-			if err := c.Inject(file.Body, tmp2[1]); err != nil {
-				return err
-			}
-
-			base, err = builder.Commit(c, "", "", "", "")
-			if err != nil {
-				return err
-			}
-			fmt.Fprintf(stdout, "===> %s\n", base.ShortId())
-			break
-		default:
-			fmt.Fprintf(stdout, "Skipping unknown op %s\n", tmp[0])
-		}
-	}
-	if base != nil {
-		// The build is successful, keep the temporary containers and images
-		for i := range tmpImages {
-			delete(tmpImages, i)
-		}
-		for i := range tmpContainers {
-			delete(tmpContainers, i)
-		}
-		fmt.Fprintf(stdout, "Build finished. image id: %s\n", base.ShortId())
-	} else {
-		fmt.Fprintf(stdout, "An error occured during the build\n")
-	}
-	return nil
-}

client/client.go

@@ -0,0 +1,126 @@
+package client
+
+import (
+	"../future"
+	"../rcli"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+)
+
+// Run docker in "simple mode": run a single command and return.
+func SimpleMode(args []string) error {
+	var oldState *State
+	var err error
+	if IsTerminal(0) && os.Getenv("NORAW") == "" {
+		oldState, err = MakeRaw(0)
+		if err != nil {
+			return err
+		}
+		defer Restore(0, oldState)
+	}
+	// FIXME: we want to use unix sockets here, but net.UnixConn doesn't expose
+	// CloseWrite(), which we need to cleanly signal that stdin is closed without
+	// closing the connection.
+	// See http://code.google.com/p/go/issues/detail?id=3345
+	conn, err := rcli.Call("tcp", "127.0.0.1:4242", args...)
+	if err != nil {
+		return err
+	}
+	receive_stdout := future.Go(func() error {
+		_, err := io.Copy(os.Stdout, conn)
+		return err
+	})
+	send_stdin := future.Go(func() error {
+		_, err := io.Copy(conn, os.Stdin)
+		if err := conn.CloseWrite(); err != nil {
+			log.Printf("Couldn't send EOF: " + err.Error())
+		}
+		return err
+	})
+	if err := <-receive_stdout; err != nil {
+		return err
+	}
+	if oldState != nil {
+		Restore(0, oldState)
+	}
+	if !IsTerminal(0) {
+		if err := <-send_stdin; err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Run docker in "interactive mode": run a bash-compatible shell capable of running docker commands.
+func InteractiveMode(scripts ...string) error {
+	// Determine path of current docker binary
+	dockerPath, err := exec.LookPath(os.Args[0])
+	if err != nil {
+		return err
+	}
+	dockerPath, err = filepath.Abs(dockerPath)
+	if err != nil {
+		return err
+	}
+
+	// Create a temp directory
+	tmp, err := ioutil.TempDir("", "docker-shell")
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(tmp)
+
+	// For each command, create an alias in temp directory
+	// FIXME: generate this list dynamically with introspection of some sort
+	// It might make sense to merge docker and dockerd to keep that introspection
+	// within a single binary.
+	for _, cmd := range []string{
+		"help",
+		"run",
+		"ps",
+		"pull",
+		"put",
+		"rm",
+		"kill",
+		"wait",
+		"stop",
+		"start",
+		"restart",
+		"logs",
+		"diff",
+		"commit",
+		"attach",
+		"info",
+		"tar",
+		"web",
+		"images",
+		"docker",
+	} {
+		if err := os.Symlink(dockerPath, path.Join(tmp, cmd)); err != nil {
+			return err
+		}
+	}
+
+	// Run $SHELL with PATH set to temp directory
+	rcfile, err := ioutil.TempFile("", "docker-shell-rc")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(rcfile.Name())
+	io.WriteString(rcfile, "enable -n help\n")
+	os.Setenv("PATH", tmp+":"+os.Getenv("PATH"))
+	os.Setenv("PS1", "\\h docker> ")
+	shell := exec.Command("/bin/bash", append([]string{"--rcfile", rcfile.Name()}, scripts...)...)
+	shell.Stdin = os.Stdin
+	shell.Stdout = os.Stdout
+	shell.Stderr = os.Stderr
+	if err := shell.Run(); err != nil {
+		return err
+	}
+	return nil
+}

client/term.go

@@ -1,4 +1,4 @@
-package term
+package client
 
 import (
 	"syscall"
@@ -114,6 +114,27 @@ func IsTerminal(fd int) bool {
 	return err == 0
 }
 
+// MakeRaw put the terminal connected to the given file descriptor into raw
+// mode and returns the previous state of the terminal so that it can be
+// restored.
+func MakeRaw(fd int) (*State, error) {
+	var oldState State
+	if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(getTermios), uintptr(unsafe.Pointer(&oldState.termios)), 0, 0, 0); err != 0 {
+		return nil, err
+	}
+
+	newState := oldState.termios
+	newState.Iflag &^= ISTRIP | INLCR | IGNCR | IXON | IXOFF
+	newState.Iflag |= ICRNL
+	newState.Oflag |= ONLCR
+	newState.Lflag &^= ECHO | ICANON | ISIG
+	if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(setTermios), uintptr(unsafe.Pointer(&newState)), 0, 0, 0); err != 0 {
+		return nil, err
+	}
+
+	return &oldState, nil
+}
+
 // Restore restores the terminal connected to the given file descriptor to a
 // previous state.
 func Restore(fd int, state *State) error {

client/termios_darwin.go

@@ -0,0 +1,8 @@
+package client
+
+import "syscall"
+
+const (
+	getTermios = syscall.TIOCGETA
+	setTermios = syscall.TIOCSETA
+)

client/termios_linux.go

@@ -0,0 +1,8 @@
+package client
+
+import "syscall"
+
+const (
+	getTermios = syscall.TCGETS
+	setTermios = syscall.TCSETS
+)

commands_test.go

@@ -1,397 +0,0 @@
-package docker
-
-import (
-	"bufio"
-	"fmt"
-	"github.com/dotcloud/docker/rcli"
-	"io"
-	"io/ioutil"
-	"strings"
-	"testing"
-	"time"
-)
-
-func closeWrap(args ...io.Closer) error {
-	e := false
-	ret := fmt.Errorf("Error closing elements")
-	for _, c := range args {
-		if err := c.Close(); err != nil {
-			e = true
-			ret = fmt.Errorf("%s\n%s", ret, err)
-		}
-	}
-	if e {
-		return ret
-	}
-	return nil
-}
-
-func setTimeout(t *testing.T, msg string, d time.Duration, f func()) {
-	c := make(chan bool)
-
-	// Make sure we are not too long
-	go func() {
-		time.Sleep(d)
-		c <- true
-	}()
-	go func() {
-		f()
-		c <- false
-	}()
-	if <-c {
-		t.Fatal(msg)
-	}
-}
-
-func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error {
-	for i := 0; i < count; i++ {
-		if _, err := w.Write([]byte(input)); err != nil {
-			return err
-		}
-		o, err := bufio.NewReader(r).ReadString('\n')
-		if err != nil {
-			return err
-		}
-		if strings.Trim(o, " \r\n") != output {
-			return fmt.Errorf("Unexpected output. Expected [%s], received [%s]", output, o)
-		}
-	}
-	return nil
-}
-
-func cmdWait(srv *Server, container *Container) error {
-	stdout, stdoutPipe := io.Pipe()
-
-	go func() {
-		srv.CmdWait(nil, stdoutPipe, container.Id)
-	}()
-
-	if _, err := bufio.NewReader(stdout).ReadString('\n'); err != nil {
-		return err
-	}
-	// Cleanup pipes
-	return closeWrap(stdout, stdoutPipe)
-}
-
-// TestRunHostname checks that 'docker run -h' correctly sets a custom hostname
-func TestRunHostname(t *testing.T) {
-	runtime, err := newTestRuntime()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer nuke(runtime)
-
-	srv := &Server{runtime: runtime}
-
-	stdin, _ := io.Pipe()
-	stdout, stdoutPipe := io.Pipe()
-
-	c := make(chan struct{})
-	go func() {
-		if err := srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-h", "foobar", GetTestImage(runtime).Id, "hostname"); err != nil {
-			t.Fatal(err)
-		}
-		close(c)
-	}()
-	cmdOutput, err := bufio.NewReader(stdout).ReadString('\n')
-	if err != nil {
-		t.Fatal(err)
-	}
-	if cmdOutput != "foobar\n" {
-		t.Fatalf("'hostname' should display '%s', not '%s'", "foobar\n", cmdOutput)
-	}
-
-	setTimeout(t, "CmdRun timed out", 2*time.Second, func() {
-		<-c
-		cmdWait(srv, srv.runtime.List()[0])
-	})
-
-}
-
-func TestRunExit(t *testing.T) {
-	runtime, err := newTestRuntime()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer nuke(runtime)
-
-	srv := &Server{runtime: runtime}
-
-	stdin, stdinPipe := io.Pipe()
-	stdout, stdoutPipe := io.Pipe()
-	c1 := make(chan struct{})
-	go func() {
-		srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", GetTestImage(runtime).Id, "/bin/cat")
-		close(c1)
-	}()
-
-	setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
-		if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
-			t.Fatal(err)
-		}
-	})
-
-	container := runtime.List()[0]
-
-	// Closing /bin/cat stdin, expect it to exit
-	p, err := container.StdinPipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := p.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	// as the process exited, CmdRun must finish and unblock. Wait for it
-	setTimeout(t, "Waiting for CmdRun timed out", 2*time.Second, func() {
-		<-c1
-		cmdWait(srv, container)
-	})
-
-	// Make sure that the client has been disconnected
-	setTimeout(t, "The client should have been disconnected once the remote process exited.", 2*time.Second, func() {
-		// Expecting pipe i/o error, just check that read does not block
-		stdin.Read([]byte{})
-	})
-
-	// Cleanup pipes
-	if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Expected behaviour: the process dies when the client disconnects
-func TestRunDisconnect(t *testing.T) {
-	runtime, err := newTestRuntime()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer nuke(runtime)
-
-	srv := &Server{runtime: runtime}
-
-	stdin, stdinPipe := io.Pipe()
-	stdout, stdoutPipe := io.Pipe()
-	c1 := make(chan struct{})
-	go func() {
-		// We're simulating a disconnect so the return value doesn't matter. What matters is the
-		// fact that CmdRun returns.
-		srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", GetTestImage(runtime).Id, "/bin/cat")
-		close(c1)
-	}()
-
-	setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
-		if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
-			t.Fatal(err)
-		}
-	})
-
-	// Close pipes (simulate disconnect)
-	if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
-		t.Fatal(err)
-	}
-
-	// as the pipes are close, we expect the process to die,
-	// therefore CmdRun to unblock. Wait for CmdRun
-	setTimeout(t, "Waiting for CmdRun timed out", 2*time.Second, func() {
-		<-c1
-	})
-
-	// Client disconnect after run -i should cause stdin to be closed, which should
-	// cause /bin/cat to exit.
-	setTimeout(t, "Waiting for /bin/cat to exit timed out", 2*time.Second, func() {
-		container := runtime.List()[0]
-		container.Wait()
-		if container.State.Running {
-			t.Fatalf("/bin/cat is still running after closing stdin")
-		}
-	})
-}
-
-// Expected behaviour: the process dies when the client disconnects
-func TestRunDisconnectTty(t *testing.T) {
-	runtime, err := newTestRuntime()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer nuke(runtime)
-
-	srv := &Server{runtime: runtime}
-
-	stdin, stdinPipe := io.Pipe()
-	stdout, stdoutPipe := io.Pipe()
-	c1 := make(chan struct{})
-	go func() {
-		// We're simulating a disconnect so the return value doesn't matter. What matters is the
-		// fact that CmdRun returns.
-		srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", "-t", GetTestImage(runtime).Id, "/bin/cat")
-		close(c1)
-	}()
-
-	setTimeout(t, "Waiting for the container to be started timed out", 2*time.Second, func() {
-		for {
-			// Client disconnect after run -i should keep stdin out in TTY mode
-			l := runtime.List()
-			if len(l) == 1 && l[0].State.Running {
-				break
-			}
-
-			time.Sleep(10 * time.Millisecond)
-		}
-	})
-
-	// Client disconnect after run -i should keep stdin out in TTY mode
-	container := runtime.List()[0]
-
-	setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
-		if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
-			t.Fatal(err)
-		}
-	})
-
-	// Close pipes (simulate disconnect)
-	if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
-		t.Fatal(err)
-	}
-
-	// In tty mode, we expect the process to stay alive even after client's stdin closes.
-	// Do not wait for run to finish
-
-	// Give some time to monitor to do his thing
-	container.WaitTimeout(500 * time.Millisecond)
-	if !container.State.Running {
-		t.Fatalf("/bin/cat should  still be running after closing stdin (tty mode)")
-	}
-}
-
-// TestAttachStdin checks attaching to stdin without stdout and stderr.
-// 'docker run -i -a stdin' should sends the client's stdin to the command,
-// then detach from it and print the container id.
-func TestRunAttachStdin(t *testing.T) {
-	runtime, err := newTestRuntime()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer nuke(runtime)
-	srv := &Server{runtime: runtime}
-
-	stdin, stdinPipe := io.Pipe()
-	stdout, stdoutPipe := io.Pipe()
-
-	ch := make(chan struct{})
-	go func() {
-		srv.CmdRun(stdin, rcli.NewDockerLocalConn(stdoutPipe), "-i", "-a", "stdin", GetTestImage(runtime).Id, "sh", "-c", "echo hello; cat")
-		close(ch)
-	}()
-
-	// Send input to the command, close stdin
-	setTimeout(t, "Write timed out", 2*time.Second, func() {
-		if _, err := stdinPipe.Write([]byte("hi there\n")); err != nil {
-			t.Fatal(err)
-		}
-		if err := stdinPipe.Close(); err != nil {
-			t.Fatal(err)
-		}
-	})
-
-	container := runtime.List()[0]
-
-	// Check output
-	cmdOutput, err := bufio.NewReader(stdout).ReadString('\n')
-	if err != nil {
-		t.Fatal(err)
-	}
-	if cmdOutput != container.ShortId()+"\n" {
-		t.Fatalf("Wrong output: should be '%s', not '%s'\n", container.ShortId()+"\n", cmdOutput)
-	}
-
-	// wait for CmdRun to return
-	setTimeout(t, "Waiting for CmdRun timed out", 2*time.Second, func() {
-		<-ch
-	})
-
-	setTimeout(t, "Waiting for command to exit timed out", 2*time.Second, func() {
-		container.Wait()
-	})
-
-	// Check logs
-	if cmdLogs, err := container.ReadLog("stdout"); err != nil {
-		t.Fatal(err)
-	} else {
-		if output, err := ioutil.ReadAll(cmdLogs); err != nil {
-			t.Fatal(err)
-		} else {
-			expectedLog := "hello\nhi there\n"
-			if string(output) != expectedLog {
-				t.Fatalf("Unexpected logs: should be '%s', not '%s'\n", expectedLog, output)
-			}
-		}
-	}
-}
-
-// Expected behaviour, the process stays alive when the client disconnects
-func TestAttachDisconnect(t *testing.T) {
-	runtime, err := newTestRuntime()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer nuke(runtime)
-
-	srv := &Server{runtime: runtime}
-
-	container, err := runtime.Create(
-		&Config{
-			Image:     GetTestImage(runtime).Id,
-			Memory:    33554432,
-			Cmd:       []string{"/bin/cat"},
-			OpenStdin: true,
-		},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer runtime.Destroy(container)
-
-	// Start the process
-	if err := container.Start(); err != nil {
-		t.Fatal(err)
-	}
-
-	stdin, stdinPipe := io.Pipe()
-	stdout, stdoutPipe := io.Pipe()
-
-	// Attach to it
-	c1 := make(chan struct{})
-	go func() {
-		// We're simulating a disconnect so the return value doesn't matter. What matters is the
-		// fact that CmdAttach returns.
-		srv.CmdAttach(stdin, rcli.NewDockerLocalConn(stdoutPipe), container.Id)
-		close(c1)
-	}()
-
-	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)
-		}
-	})
-	// 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", 2*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 timeoout in destroy. Best effort, don't check error
-	cStdin, _ := container.StdinPipe()
-	cStdin.Close()
-}

container.go

@@ -1,9 +1,9 @@
 package docker
 
 import (
+	"./fs"
 	"encoding/json"
-	"fmt"
-	"github.com/dotcloud/docker/rcli"
+	"errors"
 	"github.com/kr/pty"
 	"io"
 	"io/ioutil"
@@ -11,178 +11,162 @@ import (
 	"os"
 	"os/exec"
 	"path"
-	"sort"
 	"strconv"
-	"strings"
 	"syscall"
 	"time"
 )
 
-type Container struct {
-	root string
+var sysInitPath string
 
-	Id string
+func init() {
+	sysInitPath = SelfPath()
+}
+
+type Container struct {
+	Id   string
+	Root string
 
 	Created time.Time
 
 	Path string
 	Args []string
 
-	Config *Config
-	State  State
-	Image  string
+	Config     *Config
+	Mountpoint *fs.Mountpoint
+	State      *State
+	Image      string
 
 	network         *NetworkInterface
+	networkManager  *NetworkManager
 	NetworkSettings *NetworkSettings
 
-	SysInitPath    string
-	ResolvConfPath string
+	SysInitPath   string
+	lxcConfigPath string
+	cmd           *exec.Cmd
+	stdout        *writeBroadcaster
+	stderr        *writeBroadcaster
+	stdin         io.ReadCloser
+	stdinPipe     io.WriteCloser
 
-	cmd       *exec.Cmd
-	stdout    *writeBroadcaster
-	stderr    *writeBroadcaster
-	stdin     io.ReadCloser
-	stdinPipe io.WriteCloser
-	ptyMaster io.Closer
-
-	runtime *Runtime
-
-	waitLock chan struct{}
+	stdoutLog *os.File
+	stderrLog *os.File
 }
 
 type Config struct {
-	Hostname     string
-	User         string
-	Memory       int64 // Memory limit (in bytes)
-	MemorySwap   int64 // Total memory usage (memory + swap); set `-1' to disable swap
-	AttachStdin  bool
-	AttachStdout bool
-	AttachStderr bool
-	PortSpecs    []string
-	Tty          bool // Attach standard streams to a tty, including stdin if it is not closed.
-	OpenStdin    bool // Open stdin
-	StdinOnce    bool // If true, close stdin after the 1 attached client disconnects.
-	Env          []string
-	Cmd          []string
-	Dns          []string
-	Image        string // Name of the image as it was passed by the operator (eg. could be symbolic)
-}
-
-func ParseRun(args []string, stdout io.Writer, capabilities *Capabilities) (*Config, error) {
-	cmd := rcli.Subcmd(stdout, "run", "[OPTIONS] IMAGE COMMAND [ARG...]", "Run a command in a new container")
-	if len(args) > 0 && args[0] != "--help" {
-		cmd.SetOutput(ioutil.Discard)
-	}
-
-	flHostname := cmd.String("h", "", "Container host name")
-	flUser := cmd.String("u", "", "Username or UID")
-	flDetach := cmd.Bool("d", false, "Detached mode: leave the container running in the background")
-	flAttach := NewAttachOpts()
-	cmd.Var(flAttach, "a", "Attach to stdin, stdout or stderr.")
-	flStdin := cmd.Bool("i", false, "Keep stdin open even if not attached")
-	flTty := cmd.Bool("t", false, "Allocate a pseudo-tty")
-	flMemory := cmd.Int64("m", 0, "Memory limit (in bytes)")
-
-	if *flMemory > 0 && !capabilities.MemoryLimit {
-		fmt.Fprintf(stdout, "WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.\n")
-		*flMemory = 0
-	}
-
-	var flPorts ListOpts
-	cmd.Var(&flPorts, "p", "Expose a container's port to the host (use 'docker port' to see the actual mapping)")
-
-	var flEnv ListOpts
-	cmd.Var(&flEnv, "e", "Set environment variables")
-
-	var flDns ListOpts
-	cmd.Var(&flDns, "dns", "Set custom dns servers")
-
-	if err := cmd.Parse(args); err != nil {
-		return nil, err
-	}
-	if *flDetach && len(flAttach) > 0 {
-		return nil, fmt.Errorf("Conflicting options: -a and -d")
-	}
-	// If neither -d or -a are set, attach to everything by default
-	if len(flAttach) == 0 && !*flDetach {
-		if !*flDetach {
-			flAttach.Set("stdout")
-			flAttach.Set("stderr")
-			if *flStdin {
-				flAttach.Set("stdin")
-			}
-		}
-	}
-	parsedArgs := cmd.Args()
-	runCmd := []string{}
-	image := ""
-	if len(parsedArgs) >= 1 {
-		image = cmd.Arg(0)
-	}
-	if len(parsedArgs) > 1 {
-		runCmd = parsedArgs[1:]
-	}
-	config := &Config{
-		Hostname:     *flHostname,
-		PortSpecs:    flPorts,
-		User:         *flUser,
-		Tty:          *flTty,
-		OpenStdin:    *flStdin,
-		Memory:       *flMemory,
-		AttachStdin:  flAttach.Get("stdin"),
-		AttachStdout: flAttach.Get("stdout"),
-		AttachStderr: flAttach.Get("stderr"),
-		Env:          flEnv,
-		Cmd:          runCmd,
-		Dns:          flDns,
-		Image:        image,
-	}
-
-	if *flMemory > 0 && !capabilities.SwapLimit {
-		fmt.Fprintf(stdout, "WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.\n")
-		config.MemorySwap = -1
-	}
-
-	// When allocating stdin in attached mode, close stdin at client disconnect
-	if config.OpenStdin && config.AttachStdin {
-		config.StdinOnce = true
-	}
-	return config, nil
+	Hostname   string
+	User       string
+	Memory     int64 // Memory limit (in bytes)
+	MemorySwap int64 // Total memory usage (memory + swap); set `-1' to disable swap
+	Ports      []int
+	Tty        bool // Attach standard streams to a tty, including stdin if it is not closed.
+	OpenStdin  bool // Open stdin
 }
 
 type NetworkSettings struct {
 	IpAddress   string
 	IpPrefixLen int
 	Gateway     string
-	Bridge      string
 	PortMapping map[string]string
 }
 
-// String returns a human-readable description of the port mapping defined in the settings
-func (settings *NetworkSettings) PortMappingHuman() string {
-	var mapping []string
-	for private, public := range settings.PortMapping {
-		mapping = append(mapping, fmt.Sprintf("%s->%s", public, private))
+func createContainer(id string, root string, command string, args []string, image *fs.Image, config *Config, netManager *NetworkManager) (*Container, error) {
+	mountpoint, err := image.Mountpoint(path.Join(root, "rootfs"), path.Join(root, "rw"))
+	if err != nil {
+		return nil, err
 	}
-	sort.Strings(mapping)
-	return strings.Join(mapping, ", ")
+	container := &Container{
+		Id:              id,
+		Root:            root,
+		Created:         time.Now(),
+		Path:            command,
+		Args:            args,
+		Config:          config,
+		Image:           image.Id,
+		Mountpoint:      mountpoint,
+		State:           newState(),
+		networkManager:  netManager,
+		NetworkSettings: &NetworkSettings{},
+		SysInitPath:     sysInitPath,
+		lxcConfigPath:   path.Join(root, "config.lxc"),
+		stdout:          newWriteBroadcaster(),
+		stderr:          newWriteBroadcaster(),
+	}
+	if err := os.Mkdir(root, 0700); err != nil {
+		return nil, err
+	}
+	// Setup logging of stdout and stderr to disk
+	if stdoutLog, err := os.OpenFile(path.Join(container.Root, id+"-stdout.log"), os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600); err != nil {
+		return nil, err
+	} else {
+		container.stdoutLog = stdoutLog
+	}
+	if stderrLog, err := os.OpenFile(path.Join(container.Root, id+"-stderr.log"), os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600); err != nil {
+		return nil, err
+	} else {
+		container.stderrLog = stderrLog
+	}
+	if container.Config.OpenStdin {
+		container.stdin, container.stdinPipe = io.Pipe()
+	} else {
+		container.stdinPipe = NopWriteCloser(ioutil.Discard) // Silently drop stdin
+	}
+	container.stdout.AddWriter(NopWriteCloser(container.stdoutLog))
+	container.stderr.AddWriter(NopWriteCloser(container.stderrLog))
+
+	if err := container.save(); err != nil {
+		return nil, err
+	}
+	return container, nil
 }
 
-// Inject the io.Reader at the given path. Note: do not close the reader
-func (container *Container) Inject(file io.Reader, pth string) error {
-	// Make sure the directory exists
-	if err := os.MkdirAll(path.Join(container.rwPath(), path.Dir(pth)), 0755); err != nil {
-		return err
-	}
-	// FIXME: Handle permissions/already existing dest
-	dest, err := os.Create(path.Join(container.rwPath(), pth))
+func loadContainer(store *fs.Store, containerPath string, netManager *NetworkManager) (*Container, error) {
+	data, err := ioutil.ReadFile(path.Join(containerPath, "config.json"))
 	if err != nil {
-		return err
+		return nil, err
 	}
-	if _, err := io.Copy(dest, file); err != nil {
-		return err
+	mountpoint, err := store.FetchMountpoint(
+		path.Join(containerPath, "rootfs"),
+		path.Join(containerPath, "rw"),
+	)
+	if err != nil {
+		return nil, err
+	} else if mountpoint == nil {
+		return nil, errors.New("Couldn't load container: unregistered mountpoint.")
 	}
-	return nil
+	container := &Container{
+		stdout:          newWriteBroadcaster(),
+		stderr:          newWriteBroadcaster(),
+		lxcConfigPath:   path.Join(containerPath, "config.lxc"),
+		networkManager:  netManager,
+		NetworkSettings: &NetworkSettings{},
+		Mountpoint:      mountpoint,
+	}
+	// Load container settings
+	if err := json.Unmarshal(data, container); err != nil {
+		return nil, err
+	}
+
+	// Setup logging of stdout and stderr to disk
+	if stdoutLog, err := os.OpenFile(path.Join(container.Root, container.Id+"-stdout.log"), os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600); err != nil {
+		return nil, err
+	} else {
+		container.stdoutLog = stdoutLog
+	}
+	if stderrLog, err := os.OpenFile(path.Join(container.Root, container.Id+"-stderr.log"), os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600); err != nil {
+		return nil, err
+	} else {
+		container.stderrLog = stderrLog
+	}
+	container.stdout.AddWriter(NopWriteCloser(container.stdoutLog))
+	container.stderr.AddWriter(NopWriteCloser(container.stderrLog))
+
+	if container.Config.OpenStdin {
+		container.stdin, container.stdinPipe = io.Pipe()
+	} else {
+		container.stdinPipe = NopWriteCloser(ioutil.Discard) // Silently drop stdin
+	}
+	container.State = newState()
+	return container, nil
 }
 
 func (container *Container) Cmd() *exec.Cmd {
@@ -193,32 +177,64 @@ func (container *Container) When() time.Time {
 	return container.Created
 }
 
-func (container *Container) FromDisk() error {
-	data, err := ioutil.ReadFile(container.jsonPath())
+func (container *Container) loadUserData() (map[string]string, error) {
+	jsonData, err := ioutil.ReadFile(path.Join(container.Root, "userdata.json"))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return make(map[string]string), nil
+		}
+		return nil, err
+	}
+	data := make(map[string]string)
+	if err := json.Unmarshal(jsonData, &data); err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+func (container *Container) saveUserData(data map[string]string) error {
+	jsonData, err := json.Marshal(data)
 	if err != nil {
 		return err
 	}
-	// Load container settings
-	if err := json.Unmarshal(data, container); err != nil {
-		return err
-	}
-	return nil
+	return ioutil.WriteFile(path.Join(container.Root, "userdata.json"), jsonData, 0700)
 }
 
-func (container *Container) ToDisk() (err error) {
+func (container *Container) SetUserData(key, value string) error {
+	data, err := container.loadUserData()
+	if err != nil {
+		return err
+	}
+	data[key] = value
+	return container.saveUserData(data)
+}
+
+func (container *Container) GetUserData(key string) string {
+	data, err := container.loadUserData()
+	if err != nil {
+		return ""
+	}
+	if value, exists := data[key]; exists {
+		return value
+	}
+	return ""
+}
+
+func (container *Container) save() (err error) {
 	data, err := json.Marshal(container)
 	if err != nil {
 		return
 	}
-	return ioutil.WriteFile(container.jsonPath(), data, 0666)
+	return ioutil.WriteFile(path.Join(container.Root, "config.json"), data, 0666)
 }
 
 func (container *Container) generateLXCConfig() error {
-	fo, err := os.Create(container.lxcConfigPath())
+	fo, err := os.Create(container.lxcConfigPath)
 	if err != nil {
 		return err
 	}
 	defer fo.Close()
+
 	if err := LxcTemplateCompiled.Execute(fo, container); err != nil {
 		return err
 	}
@@ -226,37 +242,53 @@ func (container *Container) generateLXCConfig() error {
 }
 
 func (container *Container) startPty() error {
-	ptyMaster, ptySlave, err := pty.Open()
+	stdout_master, stdout_slave, err := pty.Open()
 	if err != nil {
 		return err
 	}
-	container.ptyMaster = ptyMaster
-	container.cmd.Stdout = ptySlave
-	container.cmd.Stderr = ptySlave
+	container.cmd.Stdout = stdout_slave
+
+	stderr_master, stderr_slave, err := pty.Open()
+	if err != nil {
+		return err
+	}
+	container.cmd.Stderr = stderr_slave
 
 	// Copy the PTYs to our broadcasters
 	go func() {
-		defer container.stdout.CloseWriters()
-		Debugf("[startPty] Begin of stdout pipe")
-		io.Copy(container.stdout, ptyMaster)
-		Debugf("[startPty] End of stdout pipe")
+		defer container.stdout.Close()
+		io.Copy(container.stdout, stdout_master)
+	}()
+
+	go func() {
+		defer container.stderr.Close()
+		io.Copy(container.stderr, stderr_master)
 	}()
 
 	// stdin
+	var stdin_slave io.ReadCloser
 	if container.Config.OpenStdin {
-		container.cmd.Stdin = ptySlave
-		container.cmd.SysProcAttr = &syscall.SysProcAttr{Setctty: true, Setsid: true}
+		stdin_master, stdin_slave, err := pty.Open()
+		if err != nil {
+			return err
+		}
+		container.cmd.Stdin = stdin_slave
+		// FIXME: The following appears to be broken.
+		// "cannot set terminal process group (-1): Inappropriate ioctl for device"
+		// container.cmd.SysProcAttr = &syscall.SysProcAttr{Setctty: true, Setsid: true}
 		go func() {
 			defer container.stdin.Close()
-			Debugf("[startPty] Begin of stdin pipe")
-			io.Copy(ptyMaster, container.stdin)
-			Debugf("[startPty] End of stdin pipe")
+			io.Copy(stdin_master, container.stdin)
 		}()
 	}
 	if err := container.cmd.Start(); err != nil {
 		return err
 	}
-	ptySlave.Close()
+	stdout_slave.Close()
+	stderr_slave.Close()
+	if stdin_slave != nil {
+		stdin_slave.Close()
+	}
 	return nil
 }
 
@@ -270,154 +302,25 @@ func (container *Container) start() error {
 		}
 		go func() {
 			defer stdin.Close()
-			Debugf("Begin of stdin pipe [start]")
 			io.Copy(stdin, container.stdin)
-			Debugf("End of stdin pipe [start]")
 		}()
 	}
 	return container.cmd.Start()
 }
 
-func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, stdout io.Writer, stderr io.Writer) chan error {
-	var cStdout, cStderr io.ReadCloser
-
-	var nJobs int
-	errors := make(chan error, 3)
-	if stdin != nil && container.Config.OpenStdin {
-		nJobs += 1
-		if cStdin, err := container.StdinPipe(); err != nil {
-			errors <- err
-		} else {
-			go func() {
-				Debugf("[start] attach stdin\n")
-				defer Debugf("[end] attach stdin\n")
-				// No matter what, when stdin is closed (io.Copy unblock), close stdout and stderr
-				if cStdout != nil {
-					defer cStdout.Close()
-				}
-				if cStderr != nil {
-					defer cStderr.Close()
-				}
-				if container.Config.StdinOnce && !container.Config.Tty {
-					defer cStdin.Close()
-				}
-				if container.Config.Tty {
-					_, err = CopyEscapable(cStdin, stdin)
-				} else {
-					_, err = io.Copy(cStdin, stdin)
-				}
-				if err != nil {
-					Debugf("[error] attach stdin: %s\n", err)
-				}
-				// Discard error, expecting pipe error
-				errors <- nil
-			}()
-		}
-	}
-	if stdout != nil {
-		nJobs += 1
-		if p, err := container.StdoutPipe(); err != nil {
-			errors <- err
-		} else {
-			cStdout = p
-			go func() {
-				Debugf("[start] attach stdout\n")
-				defer Debugf("[end]  attach stdout\n")
-				// 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()
-					}
-				}
-				_, err := io.Copy(stdout, cStdout)
-				if err != nil {
-					Debugf("[error] attach stdout: %s\n", err)
-				}
-				errors <- err
-			}()
-		}
-	}
-	if stderr != nil {
-		nJobs += 1
-		if p, err := container.StderrPipe(); err != nil {
-			errors <- err
-		} else {
-			cStderr = p
-			go func() {
-				Debugf("[start] attach stderr\n")
-				defer Debugf("[end]  attach stderr\n")
-				// 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()
-					}
-				}
-				_, err := io.Copy(stderr, cStderr)
-				if err != nil {
-					Debugf("[error] attach stderr: %s\n", err)
-				}
-				errors <- err
-			}()
-		}
-	}
-	return Go(func() error {
-		if cStdout != nil {
-			defer cStdout.Close()
-		}
-		if cStderr != nil {
-			defer cStderr.Close()
-		}
-		// FIXME: how do 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 {
-			Debugf("Waiting for job %d/%d\n", i+1, nJobs)
-			if err := <-errors; err != nil {
-				Debugf("Job %d returned error %s. Aborting all jobs\n", i+1, err)
-				return err
-			}
-			Debugf("Job %d completed successfully\n", i+1)
-		}
-		Debugf("All jobs completed successfully\n")
-		return nil
-	})
-}
-
 func (container *Container) Start() error {
-	container.State.lock()
-	defer container.State.unlock()
-
-	if container.State.Running {
-		return fmt.Errorf("The container %s is already running.", container.Id)
-	}
-	if err := container.EnsureMounted(); err != nil {
+	if err := container.Mountpoint.EnsureMounted(); err != nil {
 		return err
 	}
 	if err := container.allocateNetwork(); err != nil {
 		return err
 	}
-
-	// Make sure the config is compatible with the current kernel
-	if container.Config.Memory > 0 && !container.runtime.capabilities.MemoryLimit {
-		log.Printf("WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.\n")
-		container.Config.Memory = 0
-	}
-	if container.Config.Memory > 0 && !container.runtime.capabilities.SwapLimit {
-		log.Printf("WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.\n")
-		container.Config.MemorySwap = -1
-	}
-
 	if err := container.generateLXCConfig(); err != nil {
 		return err
 	}
 	params := []string{
 		"-n", container.Id,
-		"-f", container.lxcConfigPath(),
+		"-f", container.lxcConfigPath,
 		"--",
 		"/sbin/init",
 	}
@@ -430,33 +333,11 @@ func (container *Container) Start() error {
 		params = append(params, "-u", container.Config.User)
 	}
 
-	if container.Config.Tty {
-		params = append(params, "-e", "TERM=xterm")
-	}
-
-	// Setup environment
-	params = append(params,
-		"-e", "HOME=/",
-		"-e", "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
-	)
-
-	for _, elem := range container.Config.Env {
-		params = append(params, "-e", elem)
-	}
-
 	// Program
 	params = append(params, "--", container.Path)
 	params = append(params, container.Args...)
 
-	container.cmd = exec.Command("lxc-start", params...)
-
-	// Setup logging of stdout and stderr to disk
-	if err := container.runtime.LogToDisk(container.stdout, container.logPath("stdout")); err != nil {
-		return err
-	}
-	if err := container.runtime.LogToDisk(container.stderr, container.logPath("stderr")); err != nil {
-		return err
-	}
+	container.cmd = exec.Command("/usr/bin/lxc-start", params...)
 
 	var err error
 	if container.Config.Tty {
@@ -467,13 +348,8 @@ func (container *Container) Start() error {
 	if err != nil {
 		return err
 	}
-	// FIXME: save state on disk *first*, then converge
-	// this way disk state is used as a journal, eg. we can restore after crash etc.
 	container.State.setRunning(container.cmd.Process.Pid)
-
-	// Init the lock
-	container.waitLock = make(chan struct{})
-	container.ToDisk()
+	container.save()
 	go container.monitor()
 	return nil
 }
@@ -513,98 +389,68 @@ func (container *Container) StdoutPipe() (io.ReadCloser, error) {
 	return newBufReader(reader), nil
 }
 
+func (container *Container) StdoutLog() io.Reader {
+	r, err := os.Open(container.stdoutLog.Name())
+	if err != nil {
+		return nil
+	}
+	return r
+}
+
 func (container *Container) StderrPipe() (io.ReadCloser, error) {
 	reader, writer := io.Pipe()
 	container.stderr.AddWriter(writer)
 	return newBufReader(reader), nil
 }
 
+func (container *Container) StderrLog() io.Reader {
+	r, err := os.Open(container.stderrLog.Name())
+	if err != nil {
+		return nil
+	}
+	return r
+}
+
 func (container *Container) allocateNetwork() error {
-	iface, err := container.runtime.networkManager.Allocate()
+	iface, err := container.networkManager.Allocate()
 	if err != nil {
 		return err
 	}
 	container.NetworkSettings.PortMapping = make(map[string]string)
-	for _, spec := range container.Config.PortSpecs {
-		if nat, err := iface.AllocatePort(spec); err != nil {
+	for _, port := range container.Config.Ports {
+		if extPort, err := iface.AllocatePort(port); err != nil {
 			iface.Release()
 			return err
 		} else {
-			container.NetworkSettings.PortMapping[strconv.Itoa(nat.Backend)] = strconv.Itoa(nat.Frontend)
+			container.NetworkSettings.PortMapping[strconv.Itoa(port)] = strconv.Itoa(extPort)
 		}
 	}
 	container.network = iface
-	container.NetworkSettings.Bridge = container.runtime.networkManager.bridgeIface
 	container.NetworkSettings.IpAddress = iface.IPNet.IP.String()
 	container.NetworkSettings.IpPrefixLen, _ = iface.IPNet.Mask.Size()
 	container.NetworkSettings.Gateway = iface.Gateway.String()
 	return nil
 }
 
-func (container *Container) releaseNetwork() {
-	container.network.Release()
+func (container *Container) releaseNetwork() error {
+	err := container.network.Release()
 	container.network = nil
 	container.NetworkSettings = &NetworkSettings{}
-}
-
-// FIXME: replace this with a control socket within docker-init
-func (container *Container) waitLxc() error {
-	for {
-		if output, err := exec.Command("lxc-info", "-n", container.Id).CombinedOutput(); err != nil {
-			return err
-		} else {
-			if !strings.Contains(string(output), "RUNNING") {
-				return nil
-			}
-		}
-		time.Sleep(500 * time.Millisecond)
-	}
-	return nil
+	return err
 }
 
 func (container *Container) monitor() {
 	// Wait for the program to exit
-	Debugf("Waiting for process")
-
-	// If the command does not exists, try to wait via lxc
-	if container.cmd == nil {
-		if err := container.waitLxc(); err != nil {
-			Debugf("%s: Process: %s", container.Id, err)
-		}
-	} else {
-		if err := container.cmd.Wait(); err != nil {
-			// Discard the error as any signals or non 0 returns will generate an error
-			Debugf("%s: Process: %s", container.Id, err)
-		}
-	}
-	Debugf("Process finished")
-
-	var exitCode int = -1
-	if container.cmd != nil {
-		exitCode = container.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
-	}
+	container.cmd.Wait()
+	exitCode := container.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
 
 	// Cleanup
-	container.releaseNetwork()
-	if container.Config.OpenStdin {
-		if err := container.stdin.Close(); err != nil {
-			Debugf("%s: Error close stdin: %s", container.Id, err)
-		}
+	if err := container.releaseNetwork(); err != nil {
+		log.Printf("%v: Failed to release network: %v", container.Id, err)
 	}
-	if err := container.stdout.CloseWriters(); err != nil {
-		Debugf("%s: Error close stdout: %s", container.Id, err)
-	}
-	if err := container.stderr.CloseWriters(); err != nil {
-		Debugf("%s: Error close stderr: %s", container.Id, err)
-	}
-
-	if container.ptyMaster != nil {
-		if err := container.ptyMaster.Close(); err != nil {
-			Debugf("%s: Error closing Pty master: %s", container.Id, err)
-		}
-	}
-
-	if err := container.Unmount(); err != nil {
+	container.stdout.Close()
+	container.stderr.Close()
+	if err := container.Mountpoint.Umount(); err != nil {
 		log.Printf("%v: Failed to umount filesystem: %v", container.Id, err)
 	}
 
@@ -615,85 +461,51 @@ func (container *Container) monitor() {
 
 	// Report status back
 	container.State.setStopped(exitCode)
-
-	// Release the lock
-	close(container.waitLock)
-
-	if err := container.ToDisk(); err != nil {
-		// FIXME: there is a race condition here which causes this to fail during the unit tests.
-		// If another goroutine was waiting for Wait() to return before removing the container's root
-		// from the filesystem... At this point it may already have done so.
-		// This is because State.setStopped() has already been called, and has caused Wait()
-		// to return.
-		// FIXME: why are we serializing running state to disk in the first place?
-		//log.Printf("%s: Failed to dump configuration to the disk: %s", container.Id, err)
-	}
+	container.save()
 }
 
 func (container *Container) kill() error {
-	if !container.State.Running {
-		return nil
+	if err := container.cmd.Process.Kill(); err != nil {
+		return err
 	}
-
-	// Sending SIGKILL to the process via lxc
-	output, err := exec.Command("lxc-kill", "-n", container.Id, "9").CombinedOutput()
-	if err != nil {
-		log.Printf("error killing container %s (%s, %s)", container.Id, output, err)
-	}
-
-	// 2. Wait for the process to die, in last resort, try to kill the process directly
-	if err := container.WaitTimeout(10 * time.Second); err != nil {
-		if container.cmd == nil {
-			return fmt.Errorf("lxc-kill failed, impossible to kill the container %s", container.Id)
-		}
-		log.Printf("Container %s failed to exit within 10 seconds of lxc SIGKILL - trying direct SIGKILL", container.Id)
-		if err := container.cmd.Process.Kill(); err != nil {
-			return err
-		}
-	}
-
 	// Wait for the container to be actually stopped
 	container.Wait()
 	return nil
 }
 
 func (container *Container) Kill() error {
-	container.State.lock()
-	defer container.State.unlock()
 	if !container.State.Running {
 		return nil
 	}
 	return container.kill()
 }
 
-func (container *Container) Stop(seconds int) error {
-	container.State.lock()
-	defer container.State.unlock()
+func (container *Container) Stop() error {
 	if !container.State.Running {
 		return nil
 	}
 
 	// 1. Send a SIGTERM
-	if output, err := exec.Command("lxc-kill", "-n", container.Id, "15").CombinedOutput(); err != nil {
-		log.Print(string(output))
-		log.Print("Failed to send SIGTERM to the process, force killing")
-		if err := container.kill(); err != nil {
+	if output, err := exec.Command("/usr/bin/lxc-kill", "-n", container.Id, "15").CombinedOutput(); err != nil {
+		log.Printf(string(output))
+		log.Printf("Failed to send SIGTERM to the process, force killing")
+		if err := container.Kill(); err != nil {
 			return err
 		}
 	}
 
 	// 2. Wait for the process to exit on its own
-	if err := container.WaitTimeout(time.Duration(seconds) * time.Second); err != nil {
-		log.Printf("Container %v failed to exit within %d seconds of SIGTERM - using the force", container.Id, seconds)
-		if err := container.kill(); err != nil {
+	if err := container.WaitTimeout(10 * time.Second); err != nil {
+		log.Printf("Container %v failed to exit within 10 seconds of SIGTERM - using the force", container.Id)
+		if err := container.Kill(); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (container *Container) Restart(seconds int) error {
-	if err := container.Stop(seconds); err != nil {
+func (container *Container) Restart() error {
+	if err := container.Stop(); err != nil {
 		return err
 	}
 	if err := container.Start(); err != nil {
@@ -704,19 +516,11 @@ func (container *Container) Restart(seconds int) error {
 
 // Wait blocks until the container stops running, then returns its exit code.
 func (container *Container) Wait() int {
-	<-container.waitLock
-	return container.State.ExitCode
-}
 
-func (container *Container) ExportRw() (Archive, error) {
-	return Tar(container.rwPath(), Uncompressed)
-}
-
-func (container *Container) Export() (Archive, error) {
-	if err := container.EnsureMounted(); err != nil {
-		return nil, err
+	for container.State.Running {
+		container.State.wait()
 	}
-	return Tar(container.RootfsPath(), Uncompressed)
+	return container.State.ExitCode
 }
 
 func (container *Container) WaitTimeout(timeout time.Duration) error {
@@ -728,89 +532,9 @@ func (container *Container) WaitTimeout(timeout time.Duration) error {
 
 	select {
 	case <-time.After(timeout):
-		return fmt.Errorf("Timed Out")
+		return errors.New("Timed Out")
 	case <-done:
 		return nil
 	}
-	panic("unreachable")
-}
-
-func (container *Container) EnsureMounted() error {
-	if mounted, err := container.Mounted(); err != nil {
-		return err
-	} else if mounted {
-		return nil
-	}
-	return container.Mount()
-}
-
-func (container *Container) Mount() error {
-	image, err := container.GetImage()
-	if err != nil {
-		return err
-	}
-	return image.Mount(container.RootfsPath(), container.rwPath())
-}
-
-func (container *Container) Changes() ([]Change, error) {
-	image, err := container.GetImage()
-	if err != nil {
-		return nil, err
-	}
-	return image.Changes(container.rwPath())
-}
-
-func (container *Container) GetImage() (*Image, error) {
-	if container.runtime == nil {
-		return nil, fmt.Errorf("Can't get image of unregistered container")
-	}
-	return container.runtime.graph.Get(container.Image)
-}
-
-func (container *Container) Mounted() (bool, error) {
-	return Mounted(container.RootfsPath())
-}
-
-func (container *Container) Unmount() error {
-	return Unmount(container.RootfsPath())
-}
-
-// ShortId returns a shorthand version of the container's id for convenience.
-// A collision with other container shorthands is very unlikely, but possible.
-// In case of a collision a lookup with Runtime.Get() will fail, and the caller
-// will need to use a langer prefix, or the full-length container Id.
-func (container *Container) ShortId() string {
-	return TruncateId(container.Id)
-}
-
-func (container *Container) logPath(name string) string {
-	return path.Join(container.root, fmt.Sprintf("%s-%s.log", container.Id, name))
-}
-
-func (container *Container) ReadLog(name string) (io.Reader, error) {
-	return os.Open(container.logPath(name))
-}
-
-func (container *Container) jsonPath() string {
-	return path.Join(container.root, "config.json")
-}
-
-func (container *Container) lxcConfigPath() string {
-	return path.Join(container.root, "config.lxc")
-}
-
-// This method must be exported to be used from the lxc template
-func (container *Container) RootfsPath() string {
-	return path.Join(container.root, "rootfs")
-}
-
-func (container *Container) rwPath() string {
-	return path.Join(container.root, "rw")
-}
-
-func validateId(id string) error {
-	if id == "" {
-		return fmt.Errorf("Invalid empty id")
-	}
 	return nil
 }

contrib/README

@@ -1,4 +0,0 @@
-The `contrib` directory contains scripts, images, and other helpful things
-which are not part of the core docker distribution. Please note that they
-could be out of date, since they do not receive the same attention as the
-rest of the repository.

contrib/crashTest.go

@@ -1,96 +0,0 @@
-package main
-
-import (
-	"io"
-	"log"
-	"os"
-	"os/exec"
-	"time"
-)
-
-const DOCKER_PATH = "/home/creack/dotcloud/docker/docker/docker"
-
-func runDaemon() (*exec.Cmd, error) {
-	os.Remove("/var/run/docker.pid")
-	cmd := exec.Command(DOCKER_PATH, "-d")
-	outPipe, err := cmd.StdoutPipe()
-	if err != nil {
-		return nil, err
-	}
-	errPipe, err := cmd.StderrPipe()
-	if err != nil {
-		return nil, err
-	}
-	if err := cmd.Start(); err != nil {
-		return nil, err
-	}
-	go func() {
-		io.Copy(os.Stdout, outPipe)
-	}()
-	go func() {
-		io.Copy(os.Stderr, errPipe)
-	}()
-	return cmd, nil
-}
-
-func crashTest() error {
-	if err := exec.Command("/bin/bash", "-c", "while true; do true; done").Start(); err != nil {
-		return err
-	}
-
-	for {
-		daemon, err := runDaemon()
-		if err != nil {
-			return err
-		}
-		//		time.Sleep(5000 * time.Millisecond)
-		var stop bool
-		go func() error {
-			stop = false
-			for i := 0; i < 100 && !stop; i++ {
-				func() error {
-					cmd := exec.Command(DOCKER_PATH, "run", "base", "echo", "hello", "world")
-					log.Printf("%d", i)
-					outPipe, err := cmd.StdoutPipe()
-					if err != nil {
-						return err
-					}
-					inPipe, err := cmd.StdinPipe()
-					if err != nil {
-						return err
-					}
-					if err := cmd.Start(); err != nil {
-						return err
-					}
-					go func() {
-						io.Copy(os.Stdout, outPipe)
-					}()
-					// Expecting error, do not check
-					inPipe.Write([]byte("hello world!!!!!\n"))
-					go inPipe.Write([]byte("hello world!!!!!\n"))
-					go inPipe.Write([]byte("hello world!!!!!\n"))
-					inPipe.Close()
-
-					if err := cmd.Wait(); err != nil {
-						return err
-					}
-					outPipe.Close()
-					return nil
-				}()
-			}
-			return nil
-		}()
-		time.Sleep(20 * time.Second)
-		stop = true
-		if err := daemon.Process.Kill(); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func main() {
-	if err := crashTest(); err != nil {
-		log.Println(err)
-	}
-}

contrib/docker-build/README

@@ -1,68 +0,0 @@
-# docker-build: build your software with docker
-
-## Description
-
-docker-build is a script to build docker images from source. It will be deprecated once the 'build' feature is incorporated into docker itself (See https://github.com/dotcloud/docker/issues/278)
-
-Author: Solomon Hykes <solomon@dotcloud.com>
-
-
-## Install
-
-docker-builder requires:
-
-1) A reasonably recent Python setup (tested on 2.7.2).
-
-2) A running docker daemon at version 0.1.4 or more recent (http://www.docker.io/gettingstarted)
-
-
-## Usage
-
-First create a valid Changefile, which defines a sequence of changes to apply to a base image.
-
-    $ cat Changefile
-    # Start build from a know base image
-    from	base:ubuntu-12.10
-    # Update ubuntu sources
-    run	echo 'deb http://archive.ubuntu.com/ubuntu quantal main universe multiverse' > /etc/apt/sources.list
-    run	apt-get update
-    # Install system packages
-    run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q git
-    run DEBIAN_FRONTEND=noninteractive apt-get install -y -q curl
-    run DEBIAN_FRONTEND=noninteractive apt-get install -y -q golang
-    # Insert files from the host (./myscript must be present in the current directory)
-    copy	myscript /usr/local/bin/myscript
-
-
-Run docker-build, and pass the contents of your Changefile as standard input.
-
-    $ IMG=$(./docker-build < Changefile)
-
-This will take a while: for each line of the changefile, docker-build will:
-
-1. Create a new container to execute the given command or insert the given file
-2. Wait for the container to complete execution
-3. Commit the resulting changes as a new image
-4. Use the resulting image as the input of the next step
-
-
-If all the steps succeed, the result will be an image containing the combined results of each build step.
-You can trace back those build steps by inspecting the image's history:
-
-    $ docker history $IMG
-    ID                  CREATED             CREATED BY
-    1e9e2045de86        A few seconds ago   /bin/sh -c cat > /usr/local/bin/myscript; chmod +x /usr/local/bin/git
-    77db140aa62a        A few seconds ago   /bin/sh -c DEBIAN_FRONTEND=noninteractive apt-get install -y -q golang
-    77db140aa62a        A few seconds ago   /bin/sh -c DEBIAN_FRONTEND=noninteractive apt-get install -y -q curl
-    77db140aa62a        A few seconds ago   /bin/sh -c DEBIAN_FRONTEND=noninteractive apt-get install -y -q git 
-    83e85d155451        A few seconds ago   /bin/sh -c apt-get update
-    bfd53b36d9d3        A few seconds ago   /bin/sh -c echo 'deb http://archive.ubuntu.com/ubuntu quantal main universe multiverse' > /etc/apt/sources.list
-    base		2 weeks ago         /bin/bash
-    27cf78414709        2 weeks ago
-
-
-Note that your build started from 'base', as instructed by your Changefile. But that base image itself seems to have been built in 2 steps - hence the extra step in the history.
-
-
-You can use this build technique to create any image you want: a database, a web application, or anything else that can be build by a sequence of unix commands - in other words, anything else.
-

contrib/docker-build/docker-build

@@ -1,104 +0,0 @@
-#!/usr/bin/env python
-
-# docker-build is a script to build docker images from source.
-# It will be deprecated once the 'build' feature is incorporated into docker itself.
-# (See https://github.com/dotcloud/docker/issues/278)
-#
-# Author: Solomon Hykes <solomon@dotcloud.com>
-
-
-
-# First create a valid Changefile, which defines a sequence of changes to apply to a base image.
-# 
-#     $ cat Changefile
-#     # Start build from a know base image
-#     from	base:ubuntu-12.10
-#     # Update ubuntu sources
-#     run	echo 'deb http://archive.ubuntu.com/ubuntu quantal main universe multiverse' > /etc/apt/sources.list
-#     run	apt-get update
-#     # Install system packages
-#     run	DEBIAN_FRONTEND=noninteractive apt-get install -y -q git
-#     run DEBIAN_FRONTEND=noninteractive apt-get install -y -q curl
-#     run DEBIAN_FRONTEND=noninteractive apt-get install -y -q golang
-#     # Insert files from the host (./myscript must be present in the current directory)
-#     copy	myscript /usr/local/bin/myscript
-# 
-# 
-# Run docker-build, and pass the contents of your Changefile as standard input.
-# 
-#     $ IMG=$(./docker-build < Changefile)
-# 
-# This will take a while: for each line of the changefile, docker-build will:
-# 
-# 1. Create a new container to execute the given command or insert the given file
-# 2. Wait for the container to complete execution
-# 3. Commit the resulting changes as a new image
-# 4. Use the resulting image as the input of the next step
-
-
-import sys
-import subprocess
-import json
-import hashlib
-
-def docker(args, stdin=None):
-	print "# docker " + " ".join(args)
-	p = subprocess.Popen(["docker"] + list(args), stdin=stdin, stdout=subprocess.PIPE)
-	return p.stdout
-
-def image_exists(img):
-	return docker(["inspect", img]).read().strip() != ""
-
-def run_and_commit(img_in, cmd, stdin=None):
-	run_id = docker(["run"] + (["-i", "-a", "stdin"] if stdin else ["-d"]) + [img_in, "/bin/sh", "-c", cmd], stdin=stdin).read().rstrip()
-	print "---> Waiting for " + run_id
-	result=int(docker(["wait", run_id]).read().rstrip())
-	if result != 0:
-		print "!!! '{}' return non-zero exit code '{}'. Aborting.".format(cmd, result)
-		sys.exit(1)
-	return docker(["commit", run_id]).read().rstrip()
-
-def insert(base, src, dst):
-	print "COPY {} to {} in {}".format(src, dst, base)
-	if dst == "":
-		raise Exception("Missing destination path")
-	stdin = file(src)
-	stdin.seek(0)
-	return run_and_commit(base, "cat > {0}; chmod +x {0}".format(dst), stdin=stdin)
-	
-
-def main():
-	base=""
-	steps = []
-	try:
-		for line in sys.stdin.readlines():
-			line = line.strip()
-			# Skip comments and empty lines
-			if line == "" or line[0] == "#":
-				continue
-			op, param = line.split("	", 1)
-			if op == "from":
-				print "FROM " + param
-				base = param
-				steps.append(base)
-			elif op == "run":
-				print "RUN " + param
-				result = run_and_commit(base, param)
-				steps.append(result)
-				base = result
-				print "===> " + base
-			elif op == "copy":
-				src, dst = param.split("	", 1)
-				result = insert(base, src, dst)
-				steps.append(result)
-				base = result
-				print "===> " + base
-			else:
-				print "Skipping uknown op " + op
-	except:
-		docker(["rmi"] + steps[1:])
-		raise
-	print base
-
-if __name__ == "__main__":
-	main()

contrib/docker-build/example.changefile

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

contrib/mkimage-busybox.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-# Generate a very minimal filesystem based on busybox-static,
-# and load it into the local docker under the name "busybox".
-
-BUSYBOX=$(which busybox)
-[ "$BUSYBOX" ] || {
-    echo "Sorry, I could not locate busybox."
-    echo "Try 'apt-get install busybox-static'?"
-    exit 1
-}
-
-set -e
-ROOTFS=/tmp/rootfs-busybox-$$-$RANDOM
-mkdir $ROOTFS
-cd $ROOTFS
-
-mkdir bin etc dev dev/pts lib proc sys tmp
-touch etc/resolv.conf
-cp /etc/nsswitch.conf etc/nsswitch.conf
-echo root:x:0:0:root:/:/bin/sh > etc/passwd
-echo root:x:0: > etc/group
-ln -s lib lib64
-ln -s bin sbin
-cp $BUSYBOX bin
-for X in $(busybox --list)
-do
-    ln -s busybox bin/$X
-done
-rm bin/init
-ln bin/busybox bin/init
-cp /lib/x86_64-linux-gnu/lib{pthread,c,dl,nsl,nss_*}.so.* lib
-cp /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 lib
-for X in console null ptmx random stdin stdout stderr tty urandom zero
-do
-    cp -a /dev/$X dev
-done
-
-tar -cf- . | docker import - busybox
-docker run -i -u root busybox /bin/echo Success.

contrib/vagrant-docker/README.md

@@ -1,3 +0,0 @@
-# Vagrant-docker
-
-This is a placeholder for the official vagrant-docker, a plugin for Vagrant (http://vagrantup.com) which exposes Docker as a provider.

debian/changelog

@@ -0,0 +1,17 @@
+dockerd (0.1.1-1) unstable; urgency=low
+
+  * fs branch was merged upstream 
+
+ -- Jeremy Grosser <jeremy@synack.me>  Wed, 13 Mar 2013 00:23:46 +0000
+
+dockerd (0.1-2) unstable; urgency=low
+
+  * Fix upstart script 
+
+ -- Jeremy Grosser <jeremy@synack.me>  Tue, 12 Mar 2013 23:50:16 +0000
+
+dockerd (0.1-1) unstable; urgency=low
+
+  * Initial release
+
+ -- Jeremy Grosser <jeremy@synack.me>  Tue, 12 Mar 2013 03:24:45 +0000

debian/control

@@ -0,0 +1,14 @@
+Source: dockerd
+Section: misc
+Priority: extra
+Maintainer: Jeremy Grosser <jeremy@synack.me>
+Build-Depends: debhelper (>= 8.0.0), golang, git, libsqlite3-dev, pkg-config
+Standards-Version: 3.9.3
+Homepage: https://github.com/dotcloud/docker/
+
+Package: dockerd
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}, bsdtar, lxc, curl
+Description: Process manager with superpowers
+ Encapsulates heterogeneous payloads in Standard Containers, and runs them on
+ any server with strong guarantees of isolation and repeatability.

debian/copyright

@@ -0,0 +1,16 @@
+Format: http://dep.debian.net/deps/dep5
+Upstream-Name: docker
+Source: https://github.com/dotcloud/docker
+
+Files: *
+Copyright: 2012-2013 dotCloud, inc.
+License: Apache 2.0
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.

debian/dockerd.install

@@ -0,0 +1,2 @@
+build/docker usr/bin
+build/dockerd usr/sbin

debian/dockerd.upstart

@@ -0,0 +1,10 @@
+description     "Run dockerd"
+
+start on runlevel [2345]
+stop on starting rc RUNLEVEL=[016]
+respawn
+
+script
+    test -f /etc/default/locale && . /etc/default/locale || true
+    LANG=$LANG LC_ALL=$LANG /usr/sbin/dockerd
+end script

debian/rules

@@ -10,4 +10,4 @@
 #export DH_VERBOSE=1
 
 %:
-	dh $@
+	dh $@ 

docker.go

@@ -0,0 +1,160 @@
+package docker
+
+import (
+	"./fs"
+	"container/list"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"sort"
+)
+
+type Docker struct {
+	root           string
+	repository     string
+	containers     *list.List
+	networkManager *NetworkManager
+	Store          *fs.Store
+}
+
+func (docker *Docker) List() []*Container {
+	containers := new(History)
+	for e := docker.containers.Front(); e != nil; e = e.Next() {
+		containers.Add(e.Value.(*Container))
+	}
+	return *containers
+}
+
+func (docker *Docker) getContainerElement(id string) *list.Element {
+	for e := docker.containers.Front(); e != nil; e = e.Next() {
+		container := e.Value.(*Container)
+		if container.Id == id {
+			return e
+		}
+	}
+	return nil
+}
+
+func (docker *Docker) Get(id string) *Container {
+	e := docker.getContainerElement(id)
+	if e == nil {
+		return nil
+	}
+	return e.Value.(*Container)
+}
+
+func (docker *Docker) Exists(id string) bool {
+	return docker.Get(id) != nil
+}
+
+func (docker *Docker) Create(id string, command string, args []string, image *fs.Image, config *Config) (*Container, error) {
+	if docker.Exists(id) {
+		return nil, fmt.Errorf("Container %v already exists", id)
+	}
+	root := path.Join(docker.repository, id)
+
+	container, err := createContainer(id, root, command, args, image, config, docker.networkManager)
+	if err != nil {
+		return nil, err
+	}
+	docker.containers.PushBack(container)
+	return container, nil
+}
+
+func (docker *Docker) Destroy(container *Container) error {
+	element := docker.getContainerElement(container.Id)
+	if element == nil {
+		return fmt.Errorf("Container %v not found - maybe it was already destroyed?", container.Id)
+	}
+
+	if err := container.Stop(); err != nil {
+		return err
+	}
+	if container.Mountpoint.Mounted() {
+		if err := container.Mountpoint.Umount(); err != nil {
+			log.Printf("Unable to umount container %v: %v", container.Id, err)
+		}
+
+		if err := container.Mountpoint.Deregister(); err != nil {
+			log.Printf("Unable to deregiser mountpoint %v: %v", container.Mountpoint.Root, err)
+		}
+	}
+	if err := os.RemoveAll(container.Root); err != nil {
+		log.Printf("Unable to remove filesystem for %v: %v", container.Id, err)
+	}
+	docker.containers.Remove(element)
+	return nil
+}
+
+func (docker *Docker) restore() error {
+	dir, err := ioutil.ReadDir(docker.repository)
+	if err != nil {
+		return err
+	}
+	for _, v := range dir {
+		container, err := loadContainer(docker.Store, path.Join(docker.repository, v.Name()), docker.networkManager)
+		if err != nil {
+			log.Printf("Failed to load container %v: %v", v.Name(), err)
+			continue
+		}
+		docker.containers.PushBack(container)
+	}
+	return nil
+}
+
+func New() (*Docker, error) {
+	return NewFromDirectory("/var/lib/docker")
+}
+
+func NewFromDirectory(root string) (*Docker, error) {
+	store, err := fs.New(path.Join(root, "images"))
+	if err != nil {
+		return nil, err
+	}
+	netManager, err := newNetworkManager(networkBridgeIface)
+	if err != nil {
+		return nil, err
+	}
+
+	docker := &Docker{
+		root:           root,
+		repository:     path.Join(root, "containers"),
+		containers:     list.New(),
+		Store:          store,
+		networkManager: netManager,
+	}
+
+	if err := os.MkdirAll(docker.repository, 0700); err != nil && !os.IsExist(err) {
+		return nil, err
+	}
+
+	if err := docker.restore(); err != nil {
+		return nil, err
+	}
+	return docker, nil
+}
+
+type History []*Container
+
+func (history *History) Len() int {
+	return len(*history)
+}
+
+func (history *History) Less(i, j int) bool {
+	containers := *history
+	return containers[j].When().Before(containers[i].When())
+}
+
+func (history *History) Swap(i, j int) {
+	containers := *history
+	tmp := containers[i]
+	containers[i] = containers[j]
+	containers[j] = tmp
+}
+
+func (history *History) Add(container *Container) {
+	*history = append(*history, container)
+	sort.Sort(history)
+}

docker/docker.go

@@ -1,146 +1,29 @@
 package main
 
 import (
+	"../client"
 	"flag"
-	"fmt"
-	"github.com/dotcloud/docker"
-	"github.com/dotcloud/docker/rcli"
-	"github.com/dotcloud/docker/term"
-	"io"
-	"io/ioutil"
 	"log"
 	"os"
-	"os/signal"
-	"strconv"
-	"syscall"
-)
-
-var (
-	GIT_COMMIT string
+	"path"
 )
 
 func main() {
-	if docker.SelfPath() == "/sbin/init" {
-		// Running in init mode
-		docker.SysInit()
-		return
-	}
-	// FIXME: Switch d and D ? (to be more sshd like)
-	flDaemon := flag.Bool("d", false, "Daemon mode")
-	flDebug := flag.Bool("D", false, "Debug mode")
-	bridgeName := flag.String("b", "", "Attach containers to a pre-existing network bridge")
-	pidfile := flag.String("p", "/var/run/docker.pid", "File containing process PID")
-	flag.Parse()
-	if *bridgeName != "" {
-		docker.NetworkBridgeIface = *bridgeName
-	} else {
-		docker.NetworkBridgeIface = docker.DefaultNetworkBridge
-	}
-	if *flDebug {
-		os.Setenv("DEBUG", "1")
-	}
-	docker.GIT_COMMIT = GIT_COMMIT
-	if *flDaemon {
-		if flag.NArg() != 0 {
-			flag.Usage()
-			return
-		}
-		if err := daemon(*pidfile); err != nil {
-			log.Fatal(err)
+	if cmd := path.Base(os.Args[0]); cmd == "docker" {
+		fl_shell := flag.Bool("i", false, "Interactive mode")
+		flag.Parse()
+		if *fl_shell {
+			if err := client.InteractiveMode(flag.Args()...); err != nil {
+				log.Fatal(err)
+			}
+		} else {
+			if err := client.SimpleMode(os.Args[1:]); err != nil {
+				log.Fatal(err)
+			}
 		}
 	} else {
-		if err := runCommand(flag.Args()); err != nil {
+		if err := client.SimpleMode(append([]string{cmd}, os.Args[1:]...)); err != nil {
 			log.Fatal(err)
 		}
 	}
 }
-
-func createPidFile(pidfile string) error {
-	if pidString, err := ioutil.ReadFile(pidfile); err == nil {
-		pid, err := strconv.Atoi(string(pidString))
-		if err == nil {
-			if _, err := os.Stat(fmt.Sprintf("/proc/%d/", pid)); err == nil {
-				return fmt.Errorf("pid file found, ensure docker is not running or delete %s", pidfile)
-			}
-		}
-	}
-
-	file, err := os.Create(pidfile)
-	if err != nil {
-		return err
-	}
-
-	defer file.Close()
-
-	_, err = fmt.Fprintf(file, "%d", os.Getpid())
-	return err
-}
-
-func removePidFile(pidfile string) {
-	if err := os.Remove(pidfile); err != nil {
-		log.Printf("Error removing %s: %s", pidfile, err)
-	}
-}
-
-func daemon(pidfile string) error {
-	if err := createPidFile(pidfile); err != nil {
-		log.Fatal(err)
-	}
-	defer removePidFile(pidfile)
-
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt, os.Kill, os.Signal(syscall.SIGTERM))
-	go func() {
-		sig := <-c
-		log.Printf("Received signal '%v', exiting\n", sig)
-		removePidFile(pidfile)
-		os.Exit(0)
-	}()
-
-	service, err := docker.NewServer()
-	if err != nil {
-		return err
-	}
-	return rcli.ListenAndServe("tcp", "127.0.0.1:4242", service)
-}
-
-func runCommand(args []string) error {
-	// FIXME: we want to use unix sockets here, but net.UnixConn doesn't expose
-	// CloseWrite(), which we need to cleanly signal that stdin is closed without
-	// closing the connection.
-	// See http://code.google.com/p/go/issues/detail?id=3345
-	if conn, err := rcli.Call("tcp", "127.0.0.1:4242", args...); err == nil {
-		options := conn.GetOptions()
-		if options.RawTerminal &&
-			term.IsTerminal(int(os.Stdin.Fd())) &&
-			os.Getenv("NORAW") == "" {
-			if oldState, err := rcli.SetRawTerminal(); err != nil {
-				return err
-			} else {
-				defer rcli.RestoreTerminal(oldState)
-			}
-		}
-		receiveStdout := docker.Go(func() error {
-			_, err := io.Copy(os.Stdout, conn)
-			return err
-		})
-		sendStdin := docker.Go(func() error {
-			_, err := io.Copy(conn, os.Stdin)
-			if err := conn.CloseWrite(); err != nil {
-				log.Printf("Couldn't send EOF: " + err.Error())
-			}
-			return err
-		})
-		if err := <-receiveStdout; err != nil {
-			return err
-		}
-		if !term.IsTerminal(int(os.Stdin.Fd())) {
-			if err := <-sendStdin; err != nil {
-				return err
-			}
-		}
-	} else {
-		return fmt.Errorf("Can't connect to docker daemon. Is 'docker -d' running on this host?")
-	}
-	return nil
-}

docker_test.go

@@ -0,0 +1,290 @@
+package docker
+
+import (
+	"./fs"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"testing"
+)
+
+const testLayerPath string = "/var/lib/docker/docker-ut.tar"
+
+func nuke(docker *Docker) error {
+	return os.RemoveAll(docker.root)
+}
+
+func layerArchive(tarfile string) (io.Reader, error) {
+	// FIXME: need to close f somewhere
+	f, err := os.Open(tarfile)
+	if err != nil {
+		return nil, err
+	}
+	return f, nil
+}
+
+func init() {
+	// Hack to run sys init during unit testing
+	if SelfPath() == "/sbin/init" {
+		SysInit()
+	}
+
+	// Make sure the unit test image is there
+	if _, err := os.Stat(testLayerPath); err != nil {
+		if !os.IsNotExist(err) {
+			panic(err)
+		}
+		log.Fatalf("Unit test base image not found. Please fix the problem by running \"debootstrap --arch=amd64 quantal %v\"", testLayerPath)
+		return
+	}
+}
+
+func newTestDocker() (*Docker, error) {
+	root, err := ioutil.TempDir("", "docker-test")
+	if err != nil {
+		return nil, err
+	}
+	docker, err := NewFromDirectory(root)
+	if err != nil {
+		return nil, err
+	}
+
+	if layer, err := layerArchive(testLayerPath); err != nil {
+		panic(err)
+	} else {
+		_, err = docker.Store.Create(layer, nil, "docker-ut", "unit tests")
+		if err != nil {
+			panic(err)
+		}
+	}
+	return docker, nil
+}
+
+func GetTestImage(docker *Docker) *fs.Image {
+	imgs, err := docker.Store.Images()
+	if err != nil {
+		panic(err)
+	} else if len(imgs) < 1 {
+		panic("GASP")
+	}
+	return imgs[0]
+}
+
+func TestCreate(t *testing.T) {
+	docker, err := newTestDocker()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(docker)
+
+	// Make sure we start we 0 containers
+	if len(docker.List()) != 0 {
+		t.Errorf("Expected 0 containers, %v found", len(docker.List()))
+	}
+	container, err := docker.Create(
+		"test_create",
+		"ls",
+		[]string{"-al"},
+		GetTestImage(docker),
+		&Config{},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	defer func() {
+		if err := docker.Destroy(container); err != nil {
+			t.Error(err)
+		}
+	}()
+
+	// Make sure we can find the newly created container with List()
+	if len(docker.List()) != 1 {
+		t.Errorf("Expected 1 container, %v found", len(docker.List()))
+	}
+
+	// Make sure the container List() returns is the right one
+	if docker.List()[0].Id != "test_create" {
+		t.Errorf("Unexpected container %v returned by List", docker.List()[0])
+	}
+
+	// Make sure we can get the container with Get()
+	if docker.Get("test_create") == nil {
+		t.Errorf("Unable to get newly created container")
+	}
+
+	// Make sure it is the right container
+	if docker.Get("test_create") != container {
+		t.Errorf("Get() returned the wrong container")
+	}
+
+	// Make sure Exists returns it as existing
+	if !docker.Exists("test_create") {
+		t.Errorf("Exists() returned false for a newly created container")
+	}
+}
+
+func TestDestroy(t *testing.T) {
+	docker, err := newTestDocker()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(docker)
+	container, err := docker.Create(
+		"test_destroy",
+		"ls",
+		[]string{"-al"},
+		GetTestImage(docker),
+		&Config{},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Destroy
+	if err := docker.Destroy(container); err != nil {
+		t.Error(err)
+	}
+
+	// Make sure docker.Exists() behaves correctly
+	if docker.Exists("test_destroy") {
+		t.Errorf("Exists() returned true")
+	}
+
+	// Make sure docker.List() doesn't list the destroyed container
+	if len(docker.List()) != 0 {
+		t.Errorf("Expected 0 container, %v found", len(docker.List()))
+	}
+
+	// Make sure docker.Get() refuses to return the unexisting container
+	if docker.Get("test_destroy") != nil {
+		t.Errorf("Unable to get newly created container")
+	}
+
+	// Make sure the container root directory does not exist anymore
+	_, err = os.Stat(container.Root)
+	if err == nil || !os.IsNotExist(err) {
+		t.Errorf("Container root directory still exists after destroy")
+	}
+
+	// Test double destroy
+	if err := docker.Destroy(container); err == nil {
+		// It should have failed
+		t.Errorf("Double destroy did not fail")
+	}
+}
+
+func TestGet(t *testing.T) {
+	docker, err := newTestDocker()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(docker)
+	container1, err := docker.Create(
+		"test1",
+		"ls",
+		[]string{"-al"},
+		GetTestImage(docker),
+		&Config{},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer docker.Destroy(container1)
+
+	container2, err := docker.Create(
+		"test2",
+		"ls",
+		[]string{"-al"},
+		GetTestImage(docker),
+		&Config{},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer docker.Destroy(container2)
+
+	container3, err := docker.Create(
+		"test3",
+		"ls",
+		[]string{"-al"},
+		GetTestImage(docker),
+		&Config{},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer docker.Destroy(container3)
+
+	if docker.Get("test1") != container1 {
+		t.Errorf("Get(test1) returned %v while expecting %v", docker.Get("test1"), container1)
+	}
+
+	if docker.Get("test2") != container2 {
+		t.Errorf("Get(test2) returned %v while expecting %v", docker.Get("test2"), container2)
+	}
+
+	if docker.Get("test3") != container3 {
+		t.Errorf("Get(test3) returned %v while expecting %v", docker.Get("test3"), container3)
+	}
+
+}
+
+func TestRestore(t *testing.T) {
+	root, err := ioutil.TempDir("", "docker-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	docker1, err := NewFromDirectory(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(docker1)
+
+	if layer, err := layerArchive(testLayerPath); err != nil {
+		panic(err)
+	} else {
+		_, err = docker1.Store.Create(layer, nil, "docker-ut", "unit tests")
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	// Create a container with one instance of docker
+	container1, err := docker1.Create(
+		"restore_test",
+		"ls",
+		[]string{"-al"},
+		GetTestImage(docker1),
+		&Config{},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer docker1.Destroy(container1)
+	if len(docker1.List()) != 1 {
+		t.Errorf("Expected 1 container, %v found", len(docker1.List()))
+	}
+	if err := container1.Run(); err != nil {
+		t.Fatal(err)
+	}
+
+	// Here are are simulating a docker restart - that is, reloading all containers
+	// from scratch
+	docker2, err := NewFromDirectory(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer nuke(docker2)
+	if len(docker2.List()) != 1 {
+		t.Errorf("Expected 1 container, %v found", len(docker2.List()))
+	}
+	container2 := docker2.Get("restore_test")
+	if container2 == nil {
+		t.Fatal("Unable to Get container")
+	}
+	if err := container2.Run(); err != nil {
+		t.Fatal(err)
+	}
+}

dockerd/dockerd.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	".."
+	"../server"
+	"flag"
+	"log"
+)
+
+func main() {
+	if docker.SelfPath() == "/sbin/init" {
+		// Running in init mode
+		docker.SysInit()
+		return
+	}
+	flag.Parse()
+	d, err := server.New()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if err := d.ListenAndServe(); err != nil {
+		log.Fatal(err)
+	}
+}

docs/Makefile

@@ -1,185 +0,0 @@
-# Makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line.
-SPHINXOPTS    =
-SPHINXBUILD   = sphinx-build
-PAPER         =
-BUILDDIR      = _build
-
-# Internal variables.
-PAPEROPT_a4     = -D latex_paper_size=a4
-PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) sources
-# the i18n builder cannot share the environment and doctrees with the others
-I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-
-.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
-
-help:
-	@echo "Please use \`make <target>' where <target> is one of"
-#	@echo "  html       to make standalone HTML files"
-#	@echo "  dirhtml    to make HTML files named index.html in directories"
-#	@echo "  singlehtml to make a single large HTML file"
-#	@echo "  pickle     to make pickle files"
-#	@echo "  json       to make JSON files"
-#	@echo "  htmlhelp   to make HTML files and a HTML help project"
-#	@echo "  qthelp     to make HTML files and a qthelp project"
-#	@echo "  devhelp    to make HTML files and a Devhelp project"
-#	@echo "  epub       to make an epub"
-#	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
-#	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
-#	@echo "  text       to make text files"
-#	@echo "  man        to make manual pages"
-#	@echo "  texinfo    to make Texinfo files"
-#	@echo "  info       to make Texinfo files and run them through makeinfo"
-#	@echo "  gettext    to make PO message catalogs"
-#	@echo "  changes    to make an overview of all changed/added/deprecated items"
-#	@echo "  linkcheck  to check all external links for integrity"
-#	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
-	@echo "  docs       to build the docs and copy the static files to the outputdir"
-	@echo "  publish    to publish the app to dotcloud"
-
-clean:
-	-rm -rf $(BUILDDIR)/*
-
-docs:
-	-rm -rf $(BUILDDIR)/*
-	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/html
-	cp sources/index.html $(BUILDDIR)/html/
-	cp -r sources/gettingstarted $(BUILDDIR)/html/
-	cp sources/dotcloud.yml $(BUILDDIR)/html/
-	cp sources/CNAME $(BUILDDIR)/html/
-	cp sources/.nojekyll $(BUILDDIR)/html/
-	cp sources/nginx.conf $(BUILDDIR)/html/
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
-
-connect:
-	@echo pushing changes to staging site
-	@cd _build/html/ ; \
-	@dotcloud list ; \
-	dotcloud connect dockerwebsite
-
-push:
-	@cd _build/html/ ; \
-	dotcloud push
-
-github-deploy: docs
-	rm -fr github-deploy
-	git clone ssh://git@github.com/dotcloud/docker github-deploy
-	cd github-deploy && git checkout -f gh-pages && git rm -r * && rsync -avH ../_build/html/ ./ && touch .nojekyll && echo "docker.io" > CNAME && git add * && git commit -m "Updating docs"
-
-$(VERSIONS):
-	@echo "Hello world"
-
-html:
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
-
-dirhtml:
-	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
-
-singlehtml:
-	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
-	@echo
-	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
-
-pickle:
-	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
-	@echo
-	@echo "Build finished; now you can process the pickle files."
-
-json:
-	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
-	@echo
-	@echo "Build finished; now you can process the JSON files."
-
-htmlhelp:
-	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
-	@echo
-	@echo "Build finished; now you can run HTML Help Workshop with the" \
-	      ".hhp project file in $(BUILDDIR)/htmlhelp."
-
-qthelp:
-	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
-	@echo
-	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
-	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
-	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Docker.qhcp"
-	@echo "To view the help file:"
-	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Docker.qhc"
-
-devhelp:
-	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
-	@echo
-	@echo "Build finished."
-	@echo "To view the help file:"
-	@echo "# mkdir -p $$HOME/.local/share/devhelp/Docker"
-	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Docker"
-	@echo "# devhelp"
-
-epub:
-	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
-	@echo
-	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
-
-latex:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo
-	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
-	@echo "Run \`make' in that directory to run these through (pdf)latex" \
-	      "(use \`make latexpdf' here to do that automatically)."
-
-latexpdf:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through pdflatex..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-text:
-	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
-	@echo
-	@echo "Build finished. The text files are in $(BUILDDIR)/text."
-
-man:
-	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
-	@echo
-	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
-
-texinfo:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo
-	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
-	@echo "Run \`make' in that directory to run these through makeinfo" \
-	      "(use \`make info' here to do that automatically)."
-
-info:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo "Running Texinfo files through makeinfo..."
-	make -C $(BUILDDIR)/texinfo info
-	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
-
-gettext:
-	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
-	@echo
-	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
-
-changes:
-	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
-	@echo
-	@echo "The overview file is in $(BUILDDIR)/changes."
-
-linkcheck:
-	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
-	@echo
-	@echo "Link check complete; look for any errors in the above output " \
-	      "or in $(BUILDDIR)/linkcheck/output.txt."
-
-doctest:
-	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
-	@echo "Testing of doctests in the sources finished, look at the " \
-	      "results in $(BUILDDIR)/doctest/output.txt."

docs/README.md

@@ -1,74 +0,0 @@
-Docker documentation and website
-================================
-
-Documentation
--------------
-This is your definite place to contribute to the docker documentation. The documentation is generated from the
-.rst files under sources.
-
-The folder also contains the other files to create the http://docker.io website, but you can generally ignore
-most of those.
-
-
-Installation
-------------
-
-* Work in your own fork of the code, we accept pull requests.
-* Install sphinx: ``pip install sphinx``
-* If pip is not available you can probably install it using your favorite package manager as **python-pip**
-
-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 dir
-* to preview what you have generated, cd into _build/html and then run 'python -m SimpleHTTPServer 8000'
-
-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.
-
-Images
-------
-When you need to add images, try to make them as small as possible (e.g. as gif).
-
-
-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:
-
-  ```
-    .. _hello_world:
-
-    Hello world
-    ===========
-
-    This is.. (etc.)
-  ```
-
-  The ``_hello_world:`` will make it possible to link to this position (page and marker) from all other pages.
-
-* Notes, warnings and alarms
-
-  ```
-    # a note (use when something is important)
-    .. note::
-
-    # a warning (orange)
-    .. warning::
-
-    # danger (red, use sparsely)
-    .. danger::
-
-* Code examples
-
-  Start without $, so it's easy to copy and paste.

docs/sources/CNAME

@@ -1 +0,0 @@
-docker.io

docs/sources/commandline/basics.rst

@@ -1,101 +0,0 @@
-:title: Base commands
-:description: Common usage and commands
-:keywords: Examples, Usage
-
-
-The basics
-=============
-
-Starting Docker
----------------
-
-If you have used one of the quick install paths', Docker may have been installed with upstart, Ubuntu's
-system for starting processes at boot time. You should be able to run ``docker help`` and get output.
-
-If you get ``docker: command not found`` or something like ``/var/lib/docker/repositories: permission denied``
-you will need to specify the path to it and manually start it.
-
-.. code-block:: bash
-
-    # Run docker in daemon mode
-    sudo <path to>/docker -d &
-
-
-Running an interactive shell
-----------------------------
-
-.. code-block:: bash
-
-  # Download a base image
-  docker pull base
-
-  # Run an interactive shell in the base image,
-  # allocate a tty, attach stdin and stdout
-  docker run -i -t base /bin/bash
-
-
-Starting a long-running worker process
---------------------------------------
-
-.. code-block:: bash
-
-  # Start a very useful long-running process
-  JOB=$(docker run -d base /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
-
-
-Listing all running containers
-------------------------------
-
-.. code-block:: bash
-
-  docker ps
-
-Expose a service on a TCP port
-------------------------------
-
-.. code-block:: 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.
-  IP=$(ifconfig eth0 | perl -n -e 'if (m/inet addr:([\d\.]+)/g) { print $1 }')
-  echo hello world | nc $IP $PORT
-
-  # Verify that the network connection worked
-  echo "Daemon received: $(docker logs $JOB)"
-
-
-Committing (saving) an image
------------------------------
-
-Save your containers state to a container image, so the state can be re-used.
-
-When you commit your container only the differences between the image the container was created from
-and the current state of the container will be stored (as a diff). See which images you already have
-using ``docker images``
-
-.. code-block:: bash
-
-    # Commit your container to a new named image
-    docker commit <container_id> <some_name>
-
-    # List your containers
-    docker images
-
-You now have a image state from which you can create new instances.
-
-
-
-Read more about :ref:`working_with_the_repository` or continue to the complete :ref:`cli`
-

docs/sources/commandline/cli.rst

@@ -1,53 +0,0 @@
-:title: Command Line Interface
-:description: Docker's CLI command description and usage
-:keywords: Docker, Docker documentation, CLI, command line
-
-.. _cli:
-
-Command Line Interface
-======================
-
-Docker Usage
-~~~~~~~~~~~~
-
-To list available commands, either run ``docker`` with no parameters or execute
-``docker help``::
-
-  $ docker
-    Usage: docker COMMAND [arg...]
-
-    A self-sufficient runtime for linux containers.
-
-    ...
-
-Available Commands
-~~~~~~~~~~~~~~~~~~
-
-.. toctree::
-   :maxdepth: 1
-
-   command/attach
-   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/start
-   command/stop
-   command/tag
-   command/version
-   command/wait

docs/sources/commandline/command/attach.rst

@@ -1,9 +0,0 @@
-===========================================
-``attach`` -- Attach to a running container
-===========================================
-
-::
-
-    Usage: docker attach CONTAINER
-
-    Attach to a running container

docs/sources/commandline/command/commit.rst

@@ -1,11 +0,0 @@
-===========================================================
-``commit`` -- Create a new image from a container's changes
-===========================================================
-
-::
-
-    Usage: docker commit [OPTIONS] CONTAINER [REPOSITORY [TAG]]
-
-    Create a new image from a container's changes
-
-      -m="": Commit message

docs/sources/commandline/command/diff.rst

@@ -1,9 +0,0 @@
-=======================================================
-``diff`` -- Inspect changes on a container's filesystem
-=======================================================
-
-::
-
-    Usage: docker diff CONTAINER [OPTIONS]
-
-    Inspect changes on a container's filesystem

docs/sources/commandline/command/export.rst

@@ -1,9 +0,0 @@
-=================================================================
-``export`` -- Stream the contents of a container as a tar archive
-=================================================================
-
-::
-
-    Usage: docker export CONTAINER
-
-    Export the contents of a filesystem as a tar archive

docs/sources/commandline/command/history.rst

@@ -1,9 +0,0 @@
-===========================================
-``history`` -- Show the history of an image
-===========================================
-
-::
-
-    Usage: docker history [OPTIONS] IMAGE
-
-    Show the history of an image

docs/sources/commandline/command/images.rst

@@ -1,12 +0,0 @@
-=========================
-``images`` -- List images
-=========================
-
-::
-
-    Usage: docker images [OPTIONS] [NAME]
-
-    List images
-
-      -a=false: show all images
-      -q=false: only show numeric IDs

docs/sources/commandline/command/import.rst

@@ -1,9 +0,0 @@
-==========================================================================
-``import`` -- Create a new filesystem image from the contents of a tarball
-==========================================================================
-
-::
-
-    Usage: docker import [OPTIONS] URL|- [REPOSITORY [TAG]]
-
-    Create a new filesystem image from the contents of a tarball

docs/sources/commandline/command/info.rst

@@ -1,9 +0,0 @@
-===========================================
-``info`` -- Display system-wide information
-===========================================
-
-::
-
-    Usage: docker info
-
-    Display system-wide information.

docs/sources/commandline/command/inspect.rst

@@ -1,9 +0,0 @@
-==========================================================
-``inspect`` -- Return low-level information on a container
-==========================================================
-
-::
-
-    Usage: docker inspect [OPTIONS] CONTAINER
-
-    Return low-level information on a container

docs/sources/commandline/command/kill.rst

@@ -1,9 +0,0 @@
-====================================
-``kill`` -- Kill a running container
-====================================
-
-::
-
-    Usage: docker kill [OPTIONS] CONTAINER [CONTAINER...]
-
-    Kill a running container

docs/sources/commandline/command/login.rst

@@ -1,9 +0,0 @@
-============================================================
-``login`` -- Register or Login to the docker registry server
-============================================================
-
-::
-
-    Usage: docker login
-
-    Register or Login to the docker registry server

docs/sources/commandline/command/logs.rst

@@ -1,9 +0,0 @@
-=========================================
-``logs`` -- Fetch the logs of a container
-=========================================
-
-::
-
-    Usage: docker logs [OPTIONS] CONTAINER
-
-    Fetch the logs of a container

docs/sources/commandline/command/port.rst

@@ -1,9 +0,0 @@
-=========================================================================
-``port`` -- Lookup the public-facing port which is NAT-ed to PRIVATE_PORT
-=========================================================================
-
-::
-
-    Usage: docker port [OPTIONS] CONTAINER PRIVATE_PORT
-
-    Lookup the public-facing port which is NAT-ed to PRIVATE_PORT

docs/sources/commandline/command/ps.rst

@@ -1,13 +0,0 @@
-=========================
-``ps`` -- List containers
-=========================
-
-::
-
-    Usage: docker ps [OPTIONS]
-
-    List containers
-
-      -a=false: Show all containers. Only running containers are shown by default.
-      -notrunc=false: Don't truncate output
-      -q=false: Only display numeric IDs

docs/sources/commandline/command/pull.rst

@@ -1,9 +0,0 @@
-=========================================================================
-``pull`` -- Pull an image or a repository from the docker registry server
-=========================================================================
-
-::
-
-    Usage: docker pull NAME
-
-    Pull an image or a repository from the registry

docs/sources/commandline/command/push.rst

@@ -1,9 +0,0 @@
-=======================================================================
-``push`` -- Push an image or a repository to the docker registry server
-=======================================================================
-
-::
-
-    Usage: docker push NAME
-
-    Push an image or a repository to the registry

docs/sources/commandline/command/restart.rst

@@ -1,9 +0,0 @@
-==========================================
-``restart`` -- Restart a running container
-==========================================
-
-::
-
-    Usage: docker restart [OPTIONS] NAME
-
-    Restart a running container

docs/sources/commandline/command/rm.rst

@@ -1,9 +0,0 @@
-============================
-``rm`` -- Remove a container
-============================
-
-::
-
-    Usage: docker rm [OPTIONS] CONTAINER
-
-    Remove a container

docs/sources/commandline/command/rmi.rst

@@ -1,9 +0,0 @@
-==========================
-``rmi`` -- Remove an image
-==========================
-
-::
-
-    Usage: docker rmimage [OPTIONS] IMAGE
-
-    Remove an image

docs/sources/commandline/command/run.rst

@@ -1,19 +0,0 @@
-===========================================
-``run`` -- Run a command in a new container
-===========================================
-
-::
-
-    Usage: docker run [OPTIONS] IMAGE COMMAND [ARG...]
-
-    Run a command in a new container
-
-      -a=map[]: Attach to stdin, stdout or stderr.
-      -d=false: Detached mode: leave the container running in the background
-      -e=[]: Set environment variables
-      -h="": Container host name
-      -i=false: Keep stdin open even if not attached
-      -m=0: Memory limit (in bytes)
-      -p=[]: Map a network port to the container
-      -t=false: Allocate a pseudo-tty
-      -u="": Username or UID

docs/sources/commandline/command/start.rst

@@ -1,9 +0,0 @@
-======================================
-``start`` -- Start a stopped container
-======================================
-
-::
-
-    Usage: docker start [OPTIONS] NAME
-
-    Start a stopped container

docs/sources/commandline/command/stop.rst

@@ -1,9 +0,0 @@
-====================================
-``stop`` -- Stop a running container
-====================================
-
-::
-
-    Usage: docker stop [OPTIONS] NAME
-
-    Stop a running container

docs/sources/commandline/command/tag.rst

@@ -1,11 +0,0 @@
-=========================================
-``tag`` -- Tag an image into a repository
-=========================================
-
-::
-
-    Usage: docker tag [OPTIONS] IMAGE REPOSITORY [TAG]
-
-    Tag an image into a repository
-
-      -f=false: Force

docs/sources/commandline/command/version.rst

@@ -1,3 +0,0 @@
-==================================================
-``version`` -- Show the docker version information
-==================================================

docs/sources/commandline/command/wait.rst

@@ -1,9 +0,0 @@
-===================================================================
-``wait`` -- Block until a container stops, then print its exit code
-===================================================================
-
-::
-
-    Usage: docker wait [OPTIONS] NAME
-
-    Block until a container stops, then print its exit code.

docs/sources/commandline/index.rst

@@ -1,16 +0,0 @@
-:title: docker documentation
-:description: -- todo: change me
-:keywords: todo: change me
-
-
-Commands
-========
-
-Contents:
-
-.. toctree::
-  :maxdepth: 2
-
-  basics
-  workingwithrepository
-  cli

docs/sources/commandline/workingwithrepository.rst

@@ -1,42 +0,0 @@
-.. _working_with_the_repository:
-
-Working with the repository
-============================
-
-Connecting to the repository
-----------------------------
-
-You create a user on the central docker repository by running
-
-.. code-block:: bash
-
-    docker login
-
-
-If your username does not exist it will prompt you to also enter a password and your e-mail address. It will then
-automatically log you in.
-
-
-Committing a container to a named image
----------------------------------------
-
-In order to commit to the repository it is required to have committed your container to an image with your namespace.
-
-.. code-block:: bash
-
-    # for example docker commit $CONTAINER_ID dhrp/kickassapp
-    docker commit <container_id> <your username>/<some_name>
-
-
-Pushing a container to the repository
------------------------------------------
-
-In order to push an image to the repository you need to have committed your container to a named image (see above)
-
-Now you can commit this image to the repository
-
-.. code-block:: bash
-
-    # for example docker push dhrp/kickassapp
-    docker push <image-name>
-

docs/sources/concepts/buildingblocks.rst

@@ -1,25 +0,0 @@
-:title: Building blocks
-:description: An introduction to docker and standard containers?
-:keywords: containers, lxc, concepts, explanation
-
-
-Building blocks
-===============
-
-.. _images:
-
-Images
-------
-An original container image. These are stored on disk and are comparable with what you normally expect from a stopped virtual machine image. Images are stored (and retrieved from) repository
-
-Images are stored on your local file system under /var/lib/docker/images
-
-
-.. _containers:
-
-Containers
-----------
-A container is a local version of an image. It can be running or stopped, The equivalent would be a virtual machine instance.
-
-Containers are stored on your local file system under /var/lib/docker/containers
-

docs/sources/concepts/containers.rst

@@ -1,128 +0,0 @@
-:title: Introduction
-:description: An introduction to docker and standard containers?
-:keywords: containers, lxc, concepts, explanation
-
-
-:note: This version of the introduction is temporary, just to make sure we don't break the links from the website when the documentation is updated
-
-
-Introduction
-============
-
-Docker - The Linux container runtime
-------------------------------------
-
-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.
-
-
-
-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 (http://bricks.argz.com/ins/7823-1/12) 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.
-
-
-Standard Container Specification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-(TODO)
-
-Image format
-~~~~~~~~~~~~
-
-Standard operations
-~~~~~~~~~~~~~~~~~~~
-
--  Copy
--  Run
--  Stop
--  Wait
--  Commit
--  Attach standard streams
--  List filesystem changes
--  ...
-
-Execution environment
-~~~~~~~~~~~~~~~~~~~~~
-
-Root filesystem
-^^^^^^^^^^^^^^^
-
-Environment variables
-^^^^^^^^^^^^^^^^^^^^^
-
-Process arguments
-^^^^^^^^^^^^^^^^^
-
-Networking
-^^^^^^^^^^
-
-Process namespacing
-^^^^^^^^^^^^^^^^^^^
-
-Resource limits
-^^^^^^^^^^^^^^^
-
-Process monitoring
-^^^^^^^^^^^^^^^^^^
-
-Logging
-^^^^^^^
-
-Signals
-^^^^^^^
-
-Pseudo-terminal allocation
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Security
-^^^^^^^^
-

docs/sources/concepts/index.rst

@@ -1,17 +0,0 @@
-:title: docker documentation
-:description: -- todo: change me
-:keywords: todo: change me
-
-
-
-Concepts
-========
-
-Contents:
-
-.. toctree::
-   :maxdepth: 1
-
-   introduction
-   buildingblocks
-

docs/sources/concepts/introduction.rst

@@ -1,127 +0,0 @@
-:title: Introduction
-:description: An introduction to docker and standard containers?
-:keywords: containers, lxc, concepts, explanation
-
-
-
-Introduction
-============
-
-Docker - The Linux container runtime
-------------------------------------
-
-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:: http://www.docker.io/_static/lego_docker.jpg
-
-
-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 (http://bricks.argz.com/ins/7823-1/12) 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.
-
-
-Standard Container Specification
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-(TODO)
-
-Image format
-~~~~~~~~~~~~
-
-Standard operations
-~~~~~~~~~~~~~~~~~~~
-
--  Copy
--  Run
--  Stop
--  Wait
--  Commit
--  Attach standard streams
--  List filesystem changes
--  ...
-
-Execution environment
-~~~~~~~~~~~~~~~~~~~~~
-
-Root filesystem
-^^^^^^^^^^^^^^^
-
-Environment variables
-^^^^^^^^^^^^^^^^^^^^^
-
-Process arguments
-^^^^^^^^^^^^^^^^^
-
-Networking
-^^^^^^^^^^
-
-Process namespacing
-^^^^^^^^^^^^^^^^^^^
-
-Resource limits
-^^^^^^^^^^^^^^^
-
-Process monitoring
-^^^^^^^^^^^^^^^^^^
-
-Logging
-^^^^^^^
-
-Signals
-^^^^^^^
-
-Pseudo-terminal allocation
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Security
-^^^^^^^^
-

docs/sources/conf.py

@@ -1,247 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Docker documentation build configuration file, created by
-# sphinx-quickstart on Tue Mar 19 12:34:07 2013.
-#
-# This file is execfile()d with the current directory set to its containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-import sys, os
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#sys.path.insert(0, os.path.abspath('.'))
-
-# -- General configuration -----------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be extensions
-# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = []
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix of source filenames.
-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
-
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = u'Docker'
-copyright = u'2013, Team Docker'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = '0.1'
-# The full version, including alpha/beta/rc tags.
-release = '0'
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#language = None
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-#today = ''
-# Else, today_fmt is used as the format for a strftime call.
-#today_fmt = '%B %d, %Y'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-exclude_patterns = ['_build']
-
-# The reST default role (used for this markup: `text`) to use for all documents.
-#default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
-
-
-# -- Options for HTML output ---------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-html_theme = 'docker'
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#html_theme_options = {}
-
-# Add any paths that contain custom themes here, relative to this directory.
-#html_theme_path = []
-html_theme_path = ['../theme']
-
-# The name for this set of Sphinx documents.  If None, it defaults to
-# "<project> v<release> documentation".
-#html_title = None
-
-# A shorter title for the navigation bar.  Default is the same as html_title.
-#html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-#html_logo = None
-
-# The name of an image file (within the static path) to use as favicon of the
-# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-#html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['static_files']
-
-# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
-# using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#html_additional_pages = {}
-
-# If false, no module index is generated.
-#html_domain_indices = True
-
-# If false, no index is generated.
-#html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#html_split_index = False
-
-# If true, links to the reST sources are added to the pages.
-html_show_sourcelink = False
-
-# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#html_show_sphinx = True
-
-# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#html_show_copyright = True
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-#html_use_opensearch = ''
-
-# This is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = None
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'Dockerdoc'
-
-
-# -- Options for LaTeX output --------------------------------------------------
-
-latex_elements = {
-# The paper size ('letterpaper' or 'a4paper').
-#'papersize': 'letterpaper',
-
-# The font size ('10pt', '11pt' or '12pt').
-#'pointsize': '10pt',
-
-# Additional stuff for the LaTeX preamble.
-#'preamble': '',
-}
-
-# 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',
-   u'Team Docker', 'manual'),
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-#latex_logo = None
-
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-#latex_use_parts = False
-
-# If true, show page references after internal links.
-#latex_show_pagerefs = False
-
-# If true, show URL addresses after external links.
-#latex_show_urls = False
-
-# Documents to append as an appendix to all manuals.
-#latex_appendices = []
-
-# If false, no module index is generated.
-#latex_domain_indices = True
-
-
-# -- Options for manual page output --------------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-    ('index', 'docker', u'Docker Documentation',
-     [u'Team Docker'], 1)
-]
-
-# If true, show URL addresses after external links.
-#man_show_urls = False
-
-
-# -- Options for Texinfo output ------------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-  ('index', 'Docker', u'Docker Documentation',
-   u'Team Docker', 'Docker', 'One line description of project.',
-   'Miscellaneous'),
-]
-
-# Documents to append as an appendix to all manuals.
-#texinfo_appendices = []
-
-# If false, no module index is generated.
-#texinfo_domain_indices = True
-
-# How to display URL addresses: 'footnote', 'no', or 'inline'.
-#texinfo_show_urls = 'footnote'

docs/sources/contributing/contributing.rst

@@ -1,101 +0,0 @@
-Contributing to Docker
-======================
-
-Want to hack on Docker? Awesome! There are instructions to get you
-started on the website: http://docker.io/gettingstarted.html
-
-They are probably not perfect, please let us know if anything feels
-wrong or incomplete.
-
-Contribution guidelines
------------------------
-
-Pull requests are always welcome
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-We are always thrilled to receive pull requests, and do our best to
-process them as fast as possible. Not sure if that typo is worth a pull
-request? Do it! We will appreciate it.
-
-If your pull request is not accepted on the first try, don't be
-discouraged! If there's a problem with the implementation, hopefully you
-received feedback on what to improve.
-
-We're trying very hard to keep Docker lean and focused. We don't want it
-to do everything for everybody. This means that we might decide against
-incorporating a new feature. However, there might be a way to implement
-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>`__
-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
-else is working on the same thing.
-
-Create issues...
-~~~~~~~~~~~~~~~~
-
-Any significant improvement should be documented as `a github
-issue <https://github.com/dotcloud/docker/issues>`__ before anybody
-starts working on it.
-
-...but check for existing issues first!
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Please take a moment to check that an issue doesn't already exist
-documenting your bug report or improvement proposal. If it does, it
-never hurts to add a quick "+1" or "I have this problem too". This will
-help prioritize the most common problems and requests.
-
-Conventions
-~~~~~~~~~~~
-
-Fork the repo and make changes on your fork in a feature branch:
-
-- If it's a bugfix branch, name it XXX-something where XXX is the number of the
-  issue
-- If it's a feature branch, create an enhancement issue to announce your
-  intentions, and name it XXX-something where XXX is the number of the issue.
-
-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.
-
-Write clean code. Universally formatted code promotes ease of writing, reading,
-and maintenance. Always run ``go fmt`` before committing your changes. Most
-editors have plugins that do this automatically, and there's also a git
-pre-commit hook:
-
-.. code-block:: bash
-
-    curl -o .git/hooks/pre-commit https://raw.github.com/edsrzf/gofmt-git-hook/master/fmt-check && chmod +x .git/hooks/pre-commit
-
-
-Pull requests descriptions should be as clear as possible and include a
-reference to all the issues that they address.
-
-Code review comments may be added to your pull request. Discuss, then make the
-suggested modifications and push additional commits to your feature branch. Be
-sure to post a comment after pushing. The new commits will show up in the pull
-request automatically, but the reviewers will not be notified unless you
-comment.
-
-Before the pull request is merged, make sure that you squash your commits into
-logical units of work using ``git rebase -i`` and ``git push -f``. After every
-commit the test suite should be passing. Include documentation changes in the
-same commit so that a revert would remove all traces of the feature or fix.
-
-Commits that fix or close an issue should include a reference like ``Closes #XXX``
-or ``Fixes #XXX``, which will automatically close the issue when merged.
-
-Add your name to the AUTHORS file, but make sure the list is sorted and your
-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.

docs/sources/contributing/devenvironment.rst

@@ -1,33 +0,0 @@
-:title: Setting up a dev environment
-:description: Guides on how to contribute to docker
-:keywords: Docker, documentation, developers, contributing, dev environment
-
-Setting up a dev environment
-============================
-
-Instructions that have been verified to work on Ubuntu 12.10,
-
-.. code-block:: bash
-
-    sudo apt-get -y install lxc wget bsdtar curl 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 git@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,
-
-.. code-block:: bash
-
-    sudo $GOPATH/bin/docker -d
-
-
-Run the ``go install`` command (above) to recompile docker.

docs/sources/contributing/index.rst

@@ -1,14 +0,0 @@
-:title: Contributing to Docker
-:description: Guides on how to contribute to docker
-:keywords: Docker, documentation, developers, contributing, dev environment
-
-
-
-Contributing
-============
-
-.. toctree::
-   :maxdepth: 1
-
-   contributing
-   devenvironment

docs/sources/dotcloud.yml

@@ -1,2 +0,0 @@
-www:
-  type: static

docs/sources/examples/example_header.inc

@@ -1,4 +0,0 @@
-
-.. note::
-    
-    This example assumes you have Docker running in daemon mode. For more information please see :ref:`running_examples`

docs/sources/examples/hello_world.rst

@@ -1,50 +0,0 @@
-:title: Hello world example
-:description: A simple hello world example with Docker
-:keywords: docker, example, hello world
-
-.. _hello_world:
-
-Hello World
-===========
-
-.. include:: example_header.inc
-
-This is the most basic example available for using Docker.
-
-Download the base container
-
-.. code-block:: bash
-
-    # Download a base image
-    docker pull base
-
-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.
-
-
-.. 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
-
-**Explanation:**
-
-- **"docker run"** run a command in a new container 
-- **"base"** 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
-
-
-
-**Video:**
-
-See the example in action
-
-.. raw:: html
-
-    <div style="margin-top:10px;">
-      <iframe width="560" height="350" src="http://ascii.io/a/2603/raw" frameborder="0"></iframe>
-    </div>
-
-
-Continue to the :ref:`hello_world_daemon` example.

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,20 +0,0 @@
-:title: Docker Examples
-:description: Examples on how to use Docker
-:keywords: docker, hello world, examples
-
-
-
-Examples
-============
-
-Contents:
-
-.. toctree::
-   :maxdepth: 1
-
-   running_examples
-   hello_world
-   hello_world_daemon
-   python_web_app
-   running_redis_service
-   running_ssh_service

docs/sources/examples/python_web_app.rst

@@ -1,88 +0,0 @@
-:title: Python Web app example
-:description: Building your own python web app using docker
-:keywords: docker, example, python, web app
-
-.. _python_web_app:
-
-Building a 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.
-
-**Steps:**
-
-.. code-block:: bash
-
-    docker pull shykes/pybuilder
-
-We are downloading the "shykes/pybuilder" docker image
-
-.. code-block:: bash
-
-    URL=http://github.com/shykes/helloflask/archive/master.tar.gz
-
-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)
-
-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
-    [...]
-
-We 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/hykes/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.
-
-.. code-block:: bash
-
-    WEB_WORKER=$(docker run -d -p 5000 $BUILD_IMG /usr/local/bin/runapp)
-
-- **"docker run -d "** run a command in a new container. We pass "-d" so it runs as a daemon.
-- **"-p 5000"** the web app is going to listen on this port, so it must be mapped from the container to the host system.
-- **"$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.
-
-.. code-block:: bash
-
-    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.
-
-.. code-block:: bash
-
-    WEB_PORT=$(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.
-
-.. code-block:: bash
-
-    curl http://`hostname`:$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.
-
-**Video:**
-
-See the example in action
-
-.. raw:: html
-
-    <div style="margin-top:10px;">
-      <iframe width="720" height="350" src="http://ascii.io/a/2573/raw" frameborder="0"></iframe>
-    </div>
-
-Continue to :ref:`running_ssh_service`.

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

@@ -1,81 +0,0 @@
-:title: Running a Redis service
-:description: Installing and running an redis service
-:keywords: docker, example, package installation, networking, redis
-
-.. _running_redis_service:
-
-Create a redis service
-======================
-
-.. include:: example_header.inc
-
-Very simple, no frills, redis service.
-
-Open a docker container
------------------------
-
-.. code-block:: bash
-
-    docker run -i -t base /bin/bash
-
-Building your image
--------------------
-
-Update your docker container, install the redis server.  Once installed, exit out of docker.
-
-.. code-block:: bash
-
-    apt-get update
-    apt-get install redis-server
-    exit
-
-Snapshot the installation
--------------------------
-
-.. code-block:: bash
-
-    docker ps -a  # grab the container id (this will be the last one in the list)
-    docker commit <container_id> <your username>/redis
-
-Run the service
----------------
-
-Running the service with `-d` runs the container in detached mode, leaving the
-container running in the background. Use your snapshot.
-
-.. code-block:: bash
-
-    docker run -d -p 6379 <your username>/redis /usr/bin/redis-server
-
-Test 1
-++++++
-
-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
-    redis-cli -h <ipaddress> -p 6379
-    redis 10.0.3.32:6379> set docker awesome
-    OK
-    redis 10.0.3.32:6379> get docker
-    "awesome"
-    redis 10.0.3.32:6379> exit
-
-Test 2
-++++++
-
-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
-    ifconfig   # grab the host ip address
-    redis-cli -h <host ipaddress> -p <external port>
-    redis 192.168.0.1:49153> set docker awesome
-    OK
-    redis 192.168.0.1:49153> get docker
-    "awesome"
-    redis 192.168.0.1:49153> exit

docs/sources/examples/running_ssh_service.rst

@@ -1,32 +0,0 @@
-:title: Running an SSH service
-:description: A screencast of installing and running an sshd service
-:keywords: docker, example, package installation, networking
-
-.. _running_ssh_service:
-
-Create an ssh daemon service
-============================
-
-.. include:: example_header.inc
-
-
-**Video:**
-
-I've create a little screencast to show how to create a sshd service and connect to it. It is something like 11
-minutes and not entirely smooth, but gives you a good idea.
-
-.. raw:: html
-
-    <div style="margin-top:10px;">
-      <iframe width="800" height="400" src="http://ascii.io/a/2637/raw" frameborder="0"></iframe>
-    </div>
-
-
-You can also get this sshd container by using
-::
-
-    docker pull dhrp/sshd
-
-
-The password is 'screencast'
-

docs/sources/faq.rst

@@ -1,47 +0,0 @@
-FAQ
-===
-
-
-Most frequently asked questions.
---------------------------------
-
-1. **How much does Docker cost?**
-
-   Docker is 100% free, it is open source, so you can use it without paying.
-
-2. **What open source license are you using?**
-
-   We are using the Apache License Version 2.0, see it here: https://github.com/dotcloud/docker/blob/master/LICENSE
-
-3. **Does Docker run on Mac OS X or Windows?**
-
-   Not at this time, Docker currently only runs on Linux, but you can use VirtualBox to run Docker in a virtual machine on your box, and get the best of both worlds. Check out the MacOSX_ and Windows_ intallation guides.
-
-4. **How do containers compare to virtual machines?**
-
-   They are complementary. VMs are best used to allocate chunks of hardware resources. Containers operate at the process level, which makes them very lightweight and perfect as a unit of software delivery.
-
-5. **Can I help by adding some questions and answers?**
-
-   Definitely! You can fork `the repo`_ and edit the documentation sources.
-
-
-42. **Where can I find more answers?**
-
-    You can find more answers on:
-
-    * `IRC: docker on freenode`_
-    * `Github`_
-    * `Ask questions on Stackoverflow`_
-    * `Join the conversation on Twitter`_
-
-    .. _Windows: ../documentation/installation/windows.html
-    .. _MacOSX: ../documentation/installation/macos.html
-    .. _the repo: http://www.github.com/dotcloud/docker
-    .. _IRC\: docker on freenode: irc://chat.freenode.net#docker
-    .. _Github: http://www.github.com/dotcloud/docker
-    .. _Ask questions on Stackoverflow: http://stackoverflow.com/search?q=docker
-    .. _Join the conversation on Twitter: http://twitter.com/getdocker
-
-
-Looking for something else to read? Checkout the :ref:`hello_world` example.