Bump to version 1.6.2

Signed-off-by: Michael Crosby <crosbymichael@gmail.com>
Update libcontainer to 227771c8f611f03639f0ee
2026-01-16 10:21:47 +00:00 · 2015-05-11 15:05:16 -07:00 · 2015-05-11 15:05:07 -07:00 · 2015-05-07 14:59:23 -07:00 · 2015-05-07 10:07:01 -07:00 · 2015-04-30 14:08:02 -07:00
4807 changed files with 214847 additions and 844261 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,3 +1,2 @@
 bundles
 .gopath
-vendor/pkg
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,51 +0,0 @@
-<!--
-If you are reporting a new issue, make sure that we do not have any duplicates
-already open. You can ensure this by searching the issue list for this
-repository. If there is a duplicate, please close your issue and add a comment
-to the existing issue instead.
-
-If you suspect your issue is a bug, please edit your issue description to
-include the BUG REPORT INFORMATION shown below. If you fail to provide this
-information within 7 days, we cannot debug your issue and will close it. We
-will, however, reopen it if you later provide the information.
-
-For more information about reporting issues, see
-https://github.com/docker/docker/blob/master/CONTRIBUTING.md#reporting-other-issues
-
---------------------------------------------------
-BUG REPORT INFORMATION
---------------------------------------------------
-Use the commands below to provide key information from your environment:
-You do NOT have to include this information if this is a FEATURE REQUEST
-->
-
-**Output of `docker version`:**
-
-```
-(paste your output here)
-```
-
-
-**Output of `docker info`:**
-
-```
-(paste your output here)
-```
-
-**Additional environment details (AWS, VirtualBox, physical, etc.):**
-
-
-
-**Steps to reproduce the issue:**
-1.
-2.
-3.
-
-
-**Describe the results you received:**
-
-
-**Describe the results you expected:**
-
-
-**Additional information you deem important (e.g. issue happens only occasionally):**
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,30 +0,0 @@
-<!--
-Please make sure you've read and understood our contributing guidelines;
-https://github.com/docker/docker/blob/master/CONTRIBUTING.md
-
-** Make sure all your commits include a signature generated with `git commit -s` **
-
-For additional information on our contributing process, read our contributing
-guide https://docs.docker.com/opensource/code/
-
-If this is a bug fix, make sure your description includes "fixes #xxxx", or
-"closes #xxxx"
-
-Please provide the following information:
-->
-
-**- What I did**
-
-**- How I did it**
-
-**- How to verify it**
-
-**- Description for the changelog**
-<!--
-Write a short (one line) summary that describes the changes in this
-pull request for inclusion in the changelog:
-->
-
-
-**- A picture of a cute animal (not mandatory but encouraged)**
-
--- a/.gitignore
+++ b/.gitignore
@@ -1,30 +1,33 @@
 # Docker project generated files to ignore
 #  if you want to ignore files created by your editor/tools,
 #  please consider a global .gitignore https://help.github.com/articles/ignoring-files
+.vagrant*
+bin
+docker/docker
 *.exe
-*.exe~
-*.orig
-*.test
 .*.swp
+a.out
+*.orig
+build_src
+.flymake*
+.idea
 .DS_Store
-# a .bashrc may be added to customize the build environment
-.bashrc
-.gopath/
-autogen/
-bundles/
-cmd/dockerd/dockerd
-cmd/docker/docker
-dockerversion/version_autogen.go
-docs/AWS_S3_BUCKET
-docs/GITCOMMIT
-docs/GIT_BRANCH
-docs/VERSION
 docs/_build
 docs/_static
 docs/_templates
-docs/changed-files
-# generated by man/md2man-all.sh
-man/man1
-man/man5
-man/man8
+.gopath/
+.dotcloud
+*.test
+bundles/
+.hg/
+.git/
 vendor/pkg/
+pyenv
+Vagrantfile
+docs/AWS_S3_BUCKET
+docs/GIT_BRANCH
+docs/VERSION
+docs/GITCOMMIT
+docs/changed-files
+autogen/
+.bashrc
--- a/.mailmap
+++ b/.mailmap
@@ -90,12 +90,10 @@ Sven Dowideit <SvenDowideit@home.org.au>
 Sven Dowideit <SvenDowideit@home.org.au> <SvenDowideit@fosiki.com>
 Sven Dowideit <SvenDowideit@home.org.au> <SvenDowideit@docker.com>
 Sven Dowideit <SvenDowideit@home.org.au> <¨SvenDowideit@home.org.au¨>
-Sven Dowideit <SvenDowideit@home.org.au> <SvenDowideit@home.org.au>
 Sven Dowideit <SvenDowideit@home.org.au> <SvenDowideit@users.noreply.github.com>
 Sven Dowideit <SvenDowideit@home.org.au> <sven@t440s.home.gateway>
 <alexl@redhat.com> <alexander.larsson@gmail.com>
-Alexander Morozov <lk4d4@docker.com> <lk4d4math@gmail.com>
-Alexander Morozov <lk4d4@docker.com>
+Alexandr Morozov <lk4d4math@gmail.com>
 <git.nivoc@neverbox.com> <kuehnle@online.de>
 O.S. Tezer <ostezer@gmail.com>
 <ostezer@gmail.com> <ostezer@users.noreply.github.com>
@@ -108,9 +106,7 @@ Roberto G. Hashioka <roberto.hashioka@docker.com> <roberto_hashioka@hotmail.com>
 Sridhar Ratnakumar <sridharr@activestate.com>
 Sridhar Ratnakumar <sridharr@activestate.com> <github@srid.name>
 Liang-Chi Hsieh <viirya@gmail.com>
-Aleksa Sarai <asarai@suse.de>
-Aleksa Sarai <asarai@suse.de> <asarai@suse.com>
-Aleksa Sarai <asarai@suse.de> <cyphar@cyphar.com>
+Aleksa Sarai <cyphar@cyphar.com>
 Will Weaver <monkey@buildingbananas.com>
 Timothy Hobbs <timothyhobbs@seznam.cz>
 Nathan LeClaire <nathan.leclaire@docker.com> <nathan.leclaire@gmail.com>
@@ -121,27 +117,24 @@ Nathan LeClaire <nathan.leclaire@docker.com> <nathanleclaire@gmail.com>
 <marc@marc-abramowitz.com> <msabramo@gmail.com>
 Matthew Heon <mheon@redhat.com> <mheon@mheonlaptop.redhat.com>
 <bernat@luffy.cx> <vincent@bernat.im>
-<bernat@luffy.cx> <Vincent.Bernat@exoscale.ch>
 <p@pwaller.net> <peter@scraperwiki.com>
 <andrew.weiss@outlook.com> <andrew.weiss@microsoft.com>
 Francisco Carriedo <fcarriedo@gmail.com>
 <julienbordellier@gmail.com> <git@julienbordellier.com>
 <ahmetb@microsoft.com> <ahmetalpbalkan@gmail.com>
+<lk4d4@docker.com> <lk4d4math@gmail.com>
 <arnaud.porterie@docker.com> <icecrime@gmail.com>
 <baloo@gandi.net> <superbaloo+registrations.github@superbaloo.net>
 Brian Goff <cpuguy83@gmail.com>
 <cpuguy83@gmail.com> <bgoff@cpuguy83-mbp.home>
-<eric@windisch.us> <ewindisch@docker.com>
+<ewindisch@docker.com> <eric@windisch.us>
 <frank.rosquin+github@gmail.com> <frank.rosquin@gmail.com>
 Hollie Teal <hollie@docker.com>
 <hollie@docker.com> <hollie.teal@docker.com>
 <hollie@docker.com> <hollietealok@users.noreply.github.com>
 <huu@prismskylabs.com> <whoshuu@gmail.com>
-Jessica Frazelle <jess@mesosphere.com>
-Jessica Frazelle <jess@mesosphere.com> <jfrazelle@users.noreply.github.com>
-Jessica Frazelle <jess@mesosphere.com> <acidburn@docker.com>
-Jessica Frazelle <jess@mesosphere.com> <jess@docker.com>
-Jessica Frazelle <jess@mesosphere.com> <princess@docker.com>
+Jessica Frazelle <jess@docker.com> Jessie Frazelle <jfrazelle@users.noreply.github.com>
+<jess@docker.com> <jfrazelle@users.noreply.github.com>
 <konrad.wilhelm.kleine@gmail.com> <kwk@users.noreply.github.com>
 <tintypemolly@gmail.com> <tintypemolly@Ohui-MacBook-Pro.local>
 <estesp@linux.vnet.ibm.com> <estesp@gmail.com>
@@ -149,106 +142,3 @@ Jessica Frazelle <jess@mesosphere.com> <princess@docker.com>
 Thomas LEVEIL <thomasleveil@gmail.com> Thomas LÉVEIL <thomasleveil@users.noreply.github.com>
 <oi@truffles.me.uk> <timruffles@googlemail.com>
 <Vincent.Bernat@exoscale.ch> <bernat@luffy.cx>
-Antonio Murdaca <antonio.murdaca@gmail.com> <amurdaca@redhat.com>
-Antonio Murdaca <antonio.murdaca@gmail.com> <runcom@redhat.com>
-Antonio Murdaca <antonio.murdaca@gmail.com> <me@runcom.ninja>
-Antonio Murdaca <antonio.murdaca@gmail.com> <runcom@linux.com>
-Antonio Murdaca <antonio.murdaca@gmail.com> <runcom@users.noreply.github.com>
-Darren Shepherd <darren.s.shepherd@gmail.com> <darren@rancher.com>
-Deshi Xiao <dxiao@redhat.com> <dsxiao@dataman-inc.com>
-Deshi Xiao <dxiao@redhat.com> <xiaods@gmail.com>
-Doug Davis <dug@us.ibm.com> <duglin@users.noreply.github.com>
-Jacob Atzen <jacob@jacobatzen.dk> <jatzen@gmail.com>
-Jeff Nickoloff <jeff.nickoloff@gmail.com> <jeff@allingeek.com>
-John Howard (VM) <John.Howard@microsoft.com> <jhowardmsft@users.noreply.github.com>
-John Howard (VM) <John.Howard@microsoft.com>
-John Howard (VM) <John.Howard@microsoft.com> <john.howard@microsoft.com>
-John Howard (VM) <John.Howard@microsoft.com> <jhoward@microsoft.com>
-Madhu Venugopal <madhu@socketplane.io> <madhu@docker.com>
-Mary Anthony <mary.anthony@docker.com> <mary@docker.com>
-Mary Anthony <mary.anthony@docker.com> moxiegirl <mary@docker.com>
-Mary Anthony <mary.anthony@docker.com> <moxieandmore@gmail.com>
-mattyw <mattyw@me.com> <gh@mattyw.net>
-resouer <resouer@163.com> <resouer@gmail.com>
-AJ Bowen <aj@gandi.net> soulshake <amy@gandi.net> 
-AJ Bowen <aj@gandi.net> soulshake <aj@gandi.net>
-Tibor Vass <teabee89@gmail.com> <tibor@docker.com>
-Tibor Vass <teabee89@gmail.com> <tiborvass@users.noreply.github.com>
-Vincent Bernat <bernat@luffy.cx> <Vincent.Bernat@exoscale.ch>
-Yestin Sun <sunyi0804@gmail.com> <yestin.sun@polyera.com>
-bin liu <liubin0329@users.noreply.github.com> <liubin0329@gmail.com>
-John Howard (VM) <John.Howard@microsoft.com> jhowardmsft <jhoward@microsoft.com>
-Ankush Agarwal <ankushagarwal11@gmail.com> <ankushagarwal@users.noreply.github.com>
-Tangi COLIN <tangicolin@gmail.com> tangicolin <tangicolin@gmail.com>
-Allen Sun <allen.sun@daocloud.io>
-Adrien Gallouët <adrien@gallouet.fr> <angt@users.noreply.github.com>
-<aanm90@gmail.com> <martins@noironetworks.com>
-Anuj Bahuguna <anujbahuguna.dev@gmail.com>
-Anusha Ragunathan <anusha.ragunathan@docker.com> <anusha@docker.com>
-Avi Miller <avi.miller@oracle.com> <avi.miller@gmail.com>
-Brent Salisbury <brent.salisbury@docker.com> <brent@docker.com>
-Chander G <chandergovind@gmail.com>
-Chun Chen <ramichen@tencent.com> <chenchun.feed@gmail.com>
-Ying Li <cyli@twistedmatrix.com>
-Daehyeok Mun <daehyeok@gmail.com> <daehyeok@daehyeok-ui-MacBook-Air.local>
-<dqminh@cloudflare.com> <dqminh89@gmail.com>
-Daniel, Dao Quang Minh <dqminh@cloudflare.com>
-Daniel Nephin <dnephin@docker.com> <dnephin@gmail.com>
-Dave Tucker <dt@docker.com> <dave@dtucker.co.uk>
-Doug Tangren <d.tangren@gmail.com>
-Frederick F. Kautz IV <fkautz@redhat.com> <fkautz@alumni.cmu.edu>
-Ben Golub <ben.golub@dotcloud.com>
-Harold Cooper <hrldcpr@gmail.com>
-hsinko <21551195@zju.edu.cn> <hsinko@users.noreply.github.com>
-Josh Hawn <josh.hawn@docker.com> <jlhawn@berkeley.edu>
-Justin Cormack <justin.cormack@docker.com>
-<justin.cormack@docker.com> <justin.cormack@unikernel.com>
-<justin.cormack@docker.com> <justin@specialbusservice.com>
-Kamil Domański <kamil@domanski.co>
-Lei Jitang <leijitang@huawei.com>
-<leijitang@huawei.com> <leijitang@gmail.com>
-Linus Heckemann <lheckemann@twig-world.com>
-<lheckemann@twig-world.com> <anonymouse2048@gmail.com>
-Lynda O'Leary <lyndaoleary29@gmail.com>
-<lyndaoleary29@gmail.com> <lyndaoleary@hotmail.com>
-Marianna Tessel <mtesselh@gmail.com>
-Michael Huettermann <michael@huettermann.net>
-Moysés Borges <moysesb@gmail.com>
-<moysesb@gmail.com> <moyses.furtado@wplex.com.br>
-Nigel Poulton <nigelpoulton@hotmail.com>
-Qiang Huang <h.huangqiang@huawei.com>
-<h.huangqiang@huawei.com> <qhuang@10.0.2.15>
-Boaz Shuster <ripcurld.github@gmail.com>
-Shuwei Hao <haosw@cn.ibm.com>
-<haosw@cn.ibm.com> <haoshuwei24@gmail.com>
-Soshi Katsuta <soshi.katsuta@gmail.com>
-<soshi.katsuta@gmail.com> <katsuta_soshi@cyberagent.co.jp>
-Stefan Berger <stefanb@linux.vnet.ibm.com>
-<stefanb@linux.vnet.ibm.com> <stefanb@us.ibm.com>
-Stephen Day <stephen.day@docker.com>
-<stephen.day@docker.com> <stevvooe@users.noreply.github.com>
-Toli Kuznets <toli@docker.com>
-Tristan Carel <tristan@cogniteev.com>
-<tristan@cogniteev.com> <tristan.carel@gmail.com>
-Vincent Demeester <vincent@sbr.pm>
-<vincent@sbr.pm> <vincent+github@demeester.fr>
-Vishnu Kannan <vishnuk@google.com>
-xlgao-zju <xlgao@zju.edu.cn> xlgao <xlgao@zju.edu.cn>
-yuchangchun <yuchangchun1@huawei.com> y00277921 <yuchangchun1@huawei.com> 
-<zij@case.edu> <zjaffee@us.ibm.com>
-<anujbahuguna.dev@gmail.com> <abahuguna@fiberlink.com>
-<eungjun.yi@navercorp.com> <semtlenori@gmail.com>
-<haosw@cn.ibm.com> <haoshuwei1989@163.com>
-Hao Shu Wei <haosw@cn.ibm.com>
-<matt.bentley@docker.com> <mbentley@mbentley.net>
-<MihaiBorob@gmail.com> <MihaiBorobocea@gmail.com>
-<redmond.martin@gmail.com> <xgithub@redmond5.com>
-<redmond.martin@gmail.com> <martin@tinychat.com>
-<srbrahma@us.ibm.com> <sbrahma@us.ibm.com>
-<suda.akihiro@lab.ntt.co.jp> <suda.kyoto@gmail.com>
-<thomas@gazagnaire.org> <thomas@gazagnaire.com>
-Shengbo Song <thomassong@tencent.com> mYmNeo <mymneo@163.com>
-Shengbo Song <thomassong@tencent.com>
-<sylvain@ascribe.io> <sylvain.bellemare@ezeep.com>
-Sylvain Bellemare <sylvain@ascribe.io>
-
--- a/781
+++ b/781
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,9 +2,9 @@

 Want to hack on Docker? Awesome!  We have a contributor's guide that explains
 [setting up a Docker development environment and the contribution
-process](https://docs.docker.com/opensource/project/who-written-for/). 
+process](https://docs.docker.com/project/who-written-for/). 

-[![Contributors guide](docs/static_files/contributors.png)](https://docs.docker.com/opensource/project/who-written-for/)
+![Contributors guide](docs/sources/static_files/contributors.png)

 This page contains information about reporting issues as well as some tips and
 guidelines useful to experienced open source contributors. Finally, make sure
@@ -25,11 +25,11 @@ The Docker maintainers take security seriously. If you discover a security
 issue, please bring it to their attention right away!

 Please **DO NOT** file a public issue, instead send your report privately to
-[security@docker.com](mailto:security@docker.com).
+[security@docker.com](mailto:security@docker.com), 

 Security reports are greatly appreciated and we will publicly thank you for it.
-We also like to send gifts&mdash;if you're into Docker schwag, make sure to let
-us know. We currently do not offer a paid security bounty program, but are not
+We also like to send gifts&mdash;if you're into Docker schwag make sure to let
+us know We currently do not offer a paid security bounty program, but are not
 ruling it out in the future.


@@ -41,28 +41,64 @@ and will thank you for it!

 Check that [our issue database](https://github.com/docker/docker/issues)
 doesn't already include that problem or suggestion before submitting an issue.
-If you find a match, you can use the "subscribe" button to get notified on
-updates. Do *not* leave random "+1" or "I have this too" comments, as they
-only clutter the discussion, and don't help resolving it. However, if you
-have ways to reproduce the issue or have additional information that may help
-resolving the issue, please leave a comment.
+If you find a match, add a quick "+1" or "I have this problem too." Doing this
+helps prioritize the most common problems and requests.

-When reporting issues, always include:
+When reporting issues, please include your host OS (Ubuntu 12.04, Fedora 19,
+etc). Please include:

+* The output of `uname -a`.
 * The output of `docker version`.
-* The output of `docker info`.
+* The output of `docker -D info`.

-Also include the steps required to reproduce the problem if possible and
+Please also include the steps required to reproduce the problem if possible and
 applicable. This information will help us review and fix your issue faster.
-When sending lengthy log-files, consider posting them as a gist (https://gist.github.com).
-Don't forget to remove sensitive data from your logfiles before posting (you can
-replace those parts with "REDACTED").

-## Quick contribution tips and guidelines
+**Issue Report Template**:
+
+```
+Description of problem:
+
+
+`docker version`:
+
+
+`docker info`:
+
+
+`uname -a`:
+
+
+Environment details (AWS, VirtualBox, physical, etc.):
+
+
+How reproducible:
+
+
+Steps to Reproduce:
+1.
+2.
+3.
+
+
+Actual Results:
+
+
+Expected Results:
+
+
+Additional info:
+
+
+
+```
+
+
+##Quick contribution tips and guidelines

 This section gives the experienced contributor some tips and guidelines.

-### Pull requests are always welcome
+###Pull requests are always welcome

 Not sure if that typo is worth a pull request? Found a bug and know how to fix
 it? Do it! We will appreciate it. Any significant improvement should be
@@ -72,7 +108,7 @@ anybody starts working on it.
 We are always thrilled to receive pull requests. We do our best to process them
 quickly. If your pull request is not accepted on the first try,
 don't get discouraged! Our contributor's guide explains [the review process we
-use for simple changes](https://docs.docker.com/opensource/workflow/make-a-contribution/).
+use for simple changes](https://docs.docker.com/project/make-a-contribution/).

 ### Design and cleanup proposals

@@ -80,8 +116,8 @@ You can propose new designs for existing Docker features. You can also design
 entirely new features. We really appreciate contributors who want to refactor or
 otherwise cleanup our project. For information on making these types of
 contributions, see [the advanced contribution
-section](https://docs.docker.com/opensource/workflow/advanced-contributing/) in
-the contributors guide.
+section](https://docs.docker.com/project/advanced-contributing/) in the
+contributors guide.

 We try hard to keep Docker lean and focused. Docker can't do everything for
 everybody. This means that we might decide against incorporating a new feature.
@@ -93,52 +129,42 @@ However, there might be a way to implement that feature *on top of* Docker.
  <col width="45%">
  <col width="65%">
  <tr>
-    <td>Forums</td>
-    <td>
-      A public forum for users to discuss questions and explore current design patterns and
-      best practices about Docker and related projects in the Docker Ecosystem. To participate,
-      just log in with your Docker Hub account on <a href="https://forums.docker.com" target="_blank">https://forums.docker.com</a>.
-    </td>
-  </tr>
-  <tr>
-    <td>Internet&nbsp;Relay&nbsp;Chat&nbsp;(IRC)</td>
+    <td>Internet&nbsp;Relay&nbsp;Chat&nbsp;(IRC)</th>
    <td>
      <p>
        IRC a direct line to our most knowledgeable Docker users; we have
-        both the  <code>#docker</code> and <code>#docker-dev</code> group on
-        <strong>irc.freenode.net</strong>.
+        both the  <code>#docker</code> and <code>#docker-dev</code> group on 
+        <strong>irc.freenode.net</strong>.  
        IRC is a rich chat protocol but it can overwhelm new users. You can search
        <a href="https://botbot.me/freenode/docker/#" target="_blank">our chat archives</a>.
      </p>
-      <p>
-        Read our <a href="https://docs.docker.com/opensource/get-help/#irc-quickstart" target="_blank">IRC quickstart guide</a>
-        for an easy way to get started.
-      </p>
+      Read our <a href="https://docs.docker.com/project/get-help/#irc-quickstart" target="_blank">IRC quickstart guide</a> for an easy way to get started.
    </td>
  </tr>
  <tr>
-    <td>Google Group</td>
+    <td>Google Groups</td>
    <td>
-      The <a href="https://groups.google.com/forum/#!forum/docker-dev" target="_blank">docker-dev</a>
-      group is for contributors and other people contributing to the Docker project.
-      You can join them without a google account by sending an email to 
-      <a href="mailto:docker-dev+subscribe@googlegroups.com">docker-dev+subscribe@googlegroups.com</a>.
-      After receiving the join-request message, you can simply reply to that to confirm the subscribtion.
+      There are two groups.
+      <a href="https://groups.google.com/forum/#!forum/docker-user" target="_blank">Docker-user</a>
+      is for people using Docker containers. 
+      The <a href="https://groups.google.com/forum/#!forum/docker-dev" target="_blank">docker-dev</a> 
+      group is for contributors and other people contributing to the Docker 
+      project.
    </td>
  </tr>
  <tr>
    <td>Twitter</td>
    <td>
      You can follow <a href="https://twitter.com/docker/" target="_blank">Docker's Twitter feed</a>
-      to get updates on our products. You can also tweet us questions or just
+      to get updates on our products. You can also tweet us questions or just 
      share blogs or stories.
    </td>
  </tr>
  <tr>
    <td>Stack Overflow</td>
    <td>
-      Stack Overflow has over 17000 Docker questions listed. We regularly
-      monitor <a href="https://stackoverflow.com/search?tab=newest&q=docker" target="_blank">Docker questions</a>
+      Stack Overflow has over 7000K Docker questions listed. We regularly 
+      monitor <a href="http://stackoverflow.com/search?tab=newest&q=docker" target="_blank">Docker questions</a>
      and so do many other knowledgeable Docker users.
    </td>
  </tr>
@@ -157,14 +183,14 @@ Fork the repository and make changes on your fork in a feature branch:

 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](https://docs.docker.com/opensource/project/test-and-docs/) on your branch before
+suite](https://docs.docker.com/project/test-and-docs/) on your branch before
 submitting a pull request.

 Update the documentation when creating or modifying features. Test your
 documentation changes for clarity, concision, and correctness, as well as a
 clean documentation build. See our contributors guide for [our style
-guide](https://docs.docker.com/opensource/doc-style) and instructions on [building
-the documentation](https://docs.docker.com/opensource/project/test-and-docs/#build-and-test-the-documentation).
+guide](https://docs.docker.com/project/doc-style) and instructions on [building
+the documentation](https://docs.docker.com/project/test-and-docs/#build-and-test-the-documentation).

 Write clean code. Universally formatted code promotes ease of writing, reading,
 and maintenance. Always run `gofmt -s -w file.go` on each changed file before
@@ -194,11 +220,11 @@ set of patches that should be reviewed together: for example, upgrading the
 version of a vendored dependency and taking advantage of its now available new
 feature constitute two separate units of work. Implementing a new function and
 calling it in another file constitute a single logical unit of work. The very
-high majority of submissions should have a single commit, so if in doubt: squash
+high majory of submissions should have a single commit, so if in doubt: squash
 down to one.

 After every commit, [make sure the test suite passes]
-(https://docs.docker.com/opensource/project/test-and-docs/). Include documentation
+((https://docs.docker.com/project/test-and-docs/)). Include documentation
 changes in the same pull request so that a revert would remove all traces of
 the feature or fix.

@@ -208,8 +234,6 @@ close an issue. Including references automatically closes the issue on a merge.
 Please do not add yourself to the `AUTHORS` file, as it is regenerated regularly
 from the Git history.

-Please see the [Coding Style](#coding-style) for further guidelines.
-
 ### Merge approval

 Docker maintainers use LGTM (Looks Good To Me) in comments on the code review to
@@ -276,17 +300,32 @@ Use your real name (sorry, no pseudonyms or anonymous contributions.)
 If you set your `user.name` and `user.email` git configs, you can sign your
 commit automatically with `git commit -s`.

+Note that the old-style `Docker-DCO-1.1-Signed-off-by: ...` format is still
+accepted, so there is no need to update outstanding pull requests to the new
+format right away, but please do adjust your processes for future contributions.
+
 ### How can I become a maintainer?

-The procedures for adding new maintainers are explained in the 
-global [MAINTAINERS](https://github.com/docker/opensource/blob/master/MAINTAINERS)
-file in the [https://github.com/docker/opensource/](https://github.com/docker/opensource/)
-repository.
+* Step 1: Learn the component inside out
+* Step 2: Make yourself useful by contributing code, bug fixes, support etc.
+* Step 3: Volunteer on the IRC channel (#docker at Freenode)
+* Step 4: Propose yourself at a scheduled docker meeting in #docker-dev

 Don't forget: being a maintainer is a time investment. Make sure you
 will have time to make yourself available. You don't have to be a
 maintainer to make a difference on the project!

+### IRC meetings
+
+There are two monthly meetings taking place on #docker-dev IRC to accomodate all
+timezones. Anybody can propose a topic for discussion prior to the meeting.
+
+If you feel the conversation is going off-topic, feel free to point it out.
+
+For the exact dates and times, have a look at [the irc-minutes
+repo](https://github.com/docker/irc-minutes). The minutes also contain all the
+notes from previous meetings.
+
 ## Docker community guidelines

 We want to keep the Docker community awesome, growing and collaborative. We need
@@ -311,12 +350,6 @@ guidelines for the community as a whole:
  to an email you are potentially sending to a large number of people. Please
  consider this before you update. Also remember that nobody likes spam.

-* Don't send email to the maintainers: There's no need to send email to the
-  maintainers to ask them to investigate an issue or to take a look at a
-  pull request. Instead of sending an email, GitHub mentions should be
-  used to ping maintainers to review a pull request, a proposal or an
-  issue.
-
 ### Guideline violations — 3 strikes method

 The point of this section is not to find opportunities to punish people, but we
@@ -352,49 +385,3 @@ do need a fair way to deal with people who are making our community suck.
 	appeals, we know that mistakes happen, and we'll work with you to come up with a
 	fair solution if there has been a misunderstanding.

-## Coding Style
-
-Unless explicitly stated, we follow all coding guidelines from the Go
-community. While some of these standards may seem arbitrary, they somehow seem
-to result in a solid, consistent codebase.
-
-It is possible that the code base does not currently comply with these
-guidelines. We are not looking for a massive PR that fixes this, since that
-goes against the spirit of the guidelines. All new contributions should make a
-best effort to clean up and make the code base better than they left it.
-Obviously, apply your best judgement. Remember, the goal here is to make the
-code base easier for humans to navigate and understand. Always keep that in
-mind when nudging others to comply.
-
-The rules:
-
-1. All code should be formatted with `gofmt -s`.
-2. All code should pass the default levels of
-   [`golint`](https://github.com/golang/lint).
-3. All code should follow the guidelines covered in [Effective
-   Go](http://golang.org/doc/effective_go.html) and [Go Code Review
-   Comments](https://github.com/golang/go/wiki/CodeReviewComments).
-4. Comment the code. Tell us the why, the history and the context.
-5. Document _all_ declarations and methods, even private ones. Declare
-   expectations, caveats and anything else that may be important. If a type
-   gets exported, having the comments already there will ensure it's ready.
-6. Variable name length should be proportional to its context and no longer.
-   `noCommaALongVariableNameLikeThisIsNotMoreClearWhenASimpleCommentWouldDo`.
-   In practice, short methods will have short variable names and globals will
-   have longer names.
-7. No underscores in package names. If you need a compound name, step back,
-   and re-examine why you need a compound name. If you still think you need a
-   compound name, lose the underscore.
-8. No utils or helpers packages. If a function is not general enough to
-   warrant its own package, it has not been written generally enough to be a
-   part of a util package. Just leave it unexported and well-documented.
-9. All tests should run with `go test` and outside tooling should not be
-   required. No, we don't need another unit testing framework. Assertion
-   packages are acceptable if they provide _real_ incremental value.
-10. Even though we call these "rules" above, they are actually just
-    guidelines. Since you've read all the rules, you now know that.
-
-If you are having trouble getting into the mood of idiomatic Go, we recommend
-reading through [Effective Go](https://golang.org/doc/effective_go.html). The
-[Go Blog](https://blog.golang.org) is also a great resource. Drinking the
-kool-aid is a lot easier than going thirsty.
--- a/247
+++ b/247
@@ -19,183 +19,114 @@
 #  -e GPG_PASSPHRASE=gloubiboulga \
 #  docker hack/release.sh
 #
-# Note: AppArmor used to mess with privileged mode, but this is no longer
+# Note: Apparmor used to mess with privileged mode, but this is no longer
 # the case. Therefore, you don't have to disable it anymore.
 #

-FROM debian:jessie
-
-# add zfs ppa
-RUN apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys E871F18B51E0147C77796AC81196BA81F6B0FC61 \
-	|| apt-key adv --keyserver hkp://pgp.mit.edu:80 --recv-keys E871F18B51E0147C77796AC81196BA81F6B0FC61
-RUN echo deb http://ppa.launchpad.net/zfs-native/stable/ubuntu trusty main > /etc/apt/sources.list.d/zfs.list
-
-
-# allow replacing httpredir mirror
-ARG APT_MIRROR=httpredir.debian.org
-RUN sed -i s/httpredir.debian.org/$APT_MIRROR/g /etc/apt/sources.list
+FROM ubuntu:14.04
+MAINTAINER Tianon Gravi <admwiggin@gmail.com> (@tianon)

 # Packaged dependencies
 RUN apt-get update && apt-get install -y \
 	apparmor \
-	apt-utils \
 	aufs-tools \
 	automake \
-	bash-completion \
-	binutils-mingw-w64 \
-	bsdmainutils \
 	btrfs-tools \
 	build-essential \
-	clang \
-	createrepo \
 	curl \
 	dpkg-sig \
-	gcc-mingw-w64 \
 	git \
 	iptables \
-	jq \
 	libapparmor-dev \
 	libcap-dev \
-	libltdl-dev \
 	libsqlite3-dev \
-	libsystemd-journal-dev \
-	libtool \
 	mercurial \
-	net-tools \
-	pkg-config \
-	python-dev \
+	parallel \
 	python-mock \
 	python-pip \
 	python-websocket \
-	ubuntu-zfs \
-	xfsprogs \
-	libzfs-dev \
-	tar \
-	zip \
-	--no-install-recommends \
-	&& pip install awscli==1.10.15
+	reprepro \
+	ruby1.9.1 \
+	ruby1.9.1-dev \
+	s3cmd=1.1.0* \
+	--no-install-recommends
+
 # Get lvm2 source for compiling statically
-ENV LVM2_VERSION 2.02.103
-RUN mkdir -p /usr/local/lvm2 \
-	&& curl -fsSL "https://mirrors.kernel.org/sourceware/lvm2/LVM2.${LVM2_VERSION}.tgz" \
-		| tar -xzC /usr/local/lvm2 --strip-components=1
+RUN git clone -b v2_02_103 https://git.fedorahosted.org/git/lvm2.git /usr/local/lvm2
 # see https://git.fedorahosted.org/cgit/lvm2.git/refs/tags for release tags

 # Compile and install lvm2
 RUN cd /usr/local/lvm2 \
-	&& ./configure \
-		--build="$(gcc -print-multiarch)" \
-		--enable-static_link \
+	&& ./configure --enable-static_link \
 	&& make device-mapper \
 	&& make install_device-mapper
 # see https://git.fedorahosted.org/cgit/lvm2.git/tree/INSTALL

-# Configure the container for OSX cross compilation
-ENV OSX_SDK MacOSX10.11.sdk
-ENV OSX_CROSS_COMMIT 8aa9b71a394905e6c5f4b59e2b97b87a004658a4
-RUN set -x \
-	&& export OSXCROSS_PATH="/osxcross" \
-	&& git clone https://github.com/tpoechtrager/osxcross.git $OSXCROSS_PATH \
-	&& ( cd $OSXCROSS_PATH && git checkout -q $OSX_CROSS_COMMIT) \
-	&& curl -sSL https://s3.dockerproject.org/darwin/v2/${OSX_SDK}.tar.xz -o "${OSXCROSS_PATH}/tarballs/${OSX_SDK}.tar.xz" \
-	&& UNATTENDED=yes OSX_VERSION_MIN=10.6 ${OSXCROSS_PATH}/build.sh
-ENV PATH /osxcross/target/bin:$PATH
-
-# install seccomp: the version shipped in trusty is too old
-ENV SECCOMP_VERSION 2.3.1
-RUN set -x \
-	&& export SECCOMP_PATH="$(mktemp -d)" \
-	&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
-		| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
-	&& ( \
-		cd "$SECCOMP_PATH" \
-		&& ./configure --prefix=/usr/local \
-		&& make \
-		&& make install \
-		&& ldconfig \
-	) \
-	&& rm -rf "$SECCOMP_PATH"
+# Install lxc
+ENV LXC_VERSION 1.0.7
+RUN mkdir -p /usr/src/lxc \
+	&& curl -sSL https://linuxcontainers.org/downloads/lxc/lxc-${LXC_VERSION}.tar.gz | tar -v -C /usr/src/lxc/ -xz --strip-components=1
+RUN cd /usr/src/lxc \
+	&& ./configure \
+	&& make \
+	&& make install \
+	&& ldconfig

 # Install Go
-# IMPORTANT: If the version of Go is updated, the Windows to Linux CI machines
-#            will need updating, to avoid errors. Ping #docker-maintainers on IRC
-#            with a heads-up.
-ENV GO_VERSION 1.6.3
+ENV GO_VERSION 1.4.2
+RUN curl -sSL https://golang.org/dl/go${GO_VERSION}.src.tar.gz | tar -v -C /usr/local -xz \
+	&& mkdir -p /go/bin
+ENV PATH /go/bin:/usr/local/go/bin:$PATH
+ENV GOPATH /go:/go/src/github.com/docker/docker/vendor
+RUN cd /usr/local/go/src && ./make.bash --no-clean 2>&1

 # Compile Go for cross compilation
 ENV DOCKER_CROSSPLATFORMS \
 	linux/386 linux/arm \
-	darwin/amd64 \
+	darwin/amd64 darwin/386 \
 	freebsd/amd64 freebsd/386 freebsd/arm \
 	windows/amd64 windows/386

-RUN curl -fsSL "https://storage.googleapis.com/golang/go1.4.3.linux-amd64.tar.gz" \
-	| tar -xzC /root && \
-	mv /root/go /root/go1.4 && \
-	cd /usr/local && \
-	curl -fsSL "https://storage.googleapis.com/golang/go$GO_VERSION.src.tar.gz" \
-	| tar -xzC /usr/local && \
-	cd go && \
-	printf 'diff --git a/src/runtime/sys_darwin_amd64.s b/src/runtime/sys_darwin_amd64.s\nindex e09b906..fa8ff2f 100644\n--- a/src/runtime/sys_darwin_amd64.s\n+++ b/src/runtime/sys_darwin_amd64.s\n@@ -157,6 +157,7 @@ systime:\n\t// Fall back to system call (usually first call in this thread).\n\tMOVQ\tSP, DI\n\tMOVQ\t$0, SI\n+\tMOVQ\t$0, DX  // required as of Sierra; Issue 16570\n\tMOVL\t$(0x2000000+116), AX\n\tSYSCALL\n\tCMPQ\tAX, $0\n' | patch -p1 && \
-	cd src && \
-	./make.bash
+# (set an explicit GOARM of 5 for maximum compatibility)
+ENV GOARM 5
+RUN cd /usr/local/go/src \
+	&& set -x \
+	&& for platform in $DOCKER_CROSSPLATFORMS; do \
+		GOOS=${platform%/*} \
+		GOARCH=${platform##*/} \
+			./make.bash --no-clean 2>&1; \
+	done

-ENV PATH /go/bin:/usr/local/go/bin:$PATH
-ENV GOPATH /go:/go/src/github.com/docker/docker/vendor
+# We still support compiling with older Go, so need to grab older "gofmt"
+ENV GOFMT_VERSION 1.3.3
+RUN curl -sSL https://storage.googleapis.com/golang/go${GOFMT_VERSION}.$(go env GOOS)-$(go env GOARCH).tar.gz | tar -C /go/bin -xz --strip-components=2 go/bin/gofmt

-# This has been commented out and kept as reference because we don't support compiling with older Go anymore.
-# ENV GOFMT_VERSION 1.3.3
-# RUN curl -sSL https://storage.googleapis.com/golang/go${GOFMT_VERSION}.$(go env GOOS)-$(go env GOARCH).tar.gz | tar -C /go/bin -xz --strip-components=2 go/bin/gofmt
-
-ENV GO_TOOLS_COMMIT 823804e1ae08dbb14eb807afc7db9993bc9e3cc3
 # Grab Go's cover tool for dead-simple code coverage testing
-# Grab Go's vet tool for examining go code to find suspicious constructs
-# and help prevent errors that the compiler might not catch
-RUN git clone https://github.com/golang/tools.git /go/src/golang.org/x/tools \
-	&& (cd /go/src/golang.org/x/tools && git checkout -q $GO_TOOLS_COMMIT) \
-	&& go install -v golang.org/x/tools/cmd/cover \
-	&& go install -v golang.org/x/tools/cmd/vet
-# Grab Go's lint tool
-ENV GO_LINT_COMMIT 32a87160691b3c96046c0c678fe57c5bef761456
-RUN git clone https://github.com/golang/lint.git /go/src/github.com/golang/lint \
-	&& (cd /go/src/github.com/golang/lint && git checkout -q $GO_LINT_COMMIT) \
-	&& go install -v github.com/golang/lint/golint
+RUN go get golang.org/x/tools/cmd/cover

-# Install two versions of the registry. The first is an older version that
-# only supports schema1 manifests. The second is a newer version that supports
-# both. This allows integration-cli tests to cover push/pull with both schema1
-# and schema2 manifests.
-ENV REGISTRY_COMMIT_SCHEMA1 ec87e9b6971d831f0eff752ddb54fb64693e51cd
-ENV REGISTRY_COMMIT 47a064d4195a9b56133891bbb13620c3ac83a827
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/distribution.git "$GOPATH/src/github.com/docker/distribution" \
-	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT") \
-	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/registry-v2 github.com/docker/distribution/cmd/registry \
-	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT_SCHEMA1") \
-	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/registry-v2-schema1 github.com/docker/distribution/cmd/registry \
-	&& rm -rf "$GOPATH"
+# TODO replace FPM with some very minimal debhelper stuff
+RUN gem install --no-rdoc --no-ri fpm --version 1.3.2

-# Install notary and notary-server
-ENV NOTARY_VERSION v0.3.0
+# Install registry
+ENV REGISTRY_COMMIT d957768537c5af40e4f4cd96871f7b2bde9e2923
 RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/notary.git "$GOPATH/src/github.com/docker/notary" \
-	&& (cd "$GOPATH/src/github.com/docker/notary" && git checkout -q "$NOTARY_VERSION") \
-	&& GOPATH="$GOPATH/src/github.com/docker/notary/vendor:$GOPATH" \
-		go build -o /usr/local/bin/notary-server github.com/docker/notary/cmd/notary-server \
-	&& GOPATH="$GOPATH/src/github.com/docker/notary/vendor:$GOPATH" \
-		go build -o /usr/local/bin/notary github.com/docker/notary/cmd/notary \
-	&& rm -rf "$GOPATH"
+	&& git clone https://github.com/docker/distribution.git /go/src/github.com/docker/distribution \
+	&& (cd /go/src/github.com/docker/distribution && git checkout -q $REGISTRY_COMMIT) \
+	&& GOPATH=/go/src/github.com/docker/distribution/Godeps/_workspace:/go \
+		go build -o /go/bin/registry-v2 github.com/docker/distribution/cmd/registry

 # Get the "docker-py" source so we can run their integration tests
-ENV DOCKER_PY_COMMIT 7befe694bd21e3c54bb1d7825270ea4bd6864c13
+ENV DOCKER_PY_COMMIT 91985b239764fe54714fa0a93d52aa362357d251
 RUN git clone https://github.com/docker/docker-py.git /docker-py \
 	&& cd /docker-py \
-	&& git checkout -q $DOCKER_PY_COMMIT \
-	&& pip install -r test-requirements.txt
+	&& git checkout -q $DOCKER_PY_COMMIT
+
+# Setup s3cmd config
+RUN { \
+		echo '[default]'; \
+		echo 'access_key=$AWS_ACCESS_KEY'; \
+		echo 'secret_key=$AWS_SECRET_KEY'; \
+	} > ~/.s3cfg

 # Set user.email so crosbymichael's in-container merge commits go smoothly
 RUN git config --global user.email 'docker-dummy@example.com'
@@ -206,64 +137,32 @@ RUN useradd --create-home --gid docker unprivilegeduser

 VOLUME /var/lib/docker
 WORKDIR /go/src/github.com/docker/docker
-ENV DOCKER_BUILDTAGS apparmor pkcs11 seccomp selinux
+ENV DOCKER_BUILDTAGS apparmor selinux btrfs_noversion

 # Let us use a .bashrc file
 RUN ln -sfv $PWD/.bashrc ~/.bashrc

-# Register Docker's bash completion.
-RUN ln -sv $PWD/contrib/completion/bash/docker /etc/bash_completion.d/docker
-
 # Get useful and necessary Hub images so we can "docker load" locally instead of pulling
-COPY contrib/download-frozen-image-v2.sh /go/src/github.com/docker/docker/contrib/
-RUN ./contrib/download-frozen-image-v2.sh /docker-frozen-images \
-	buildpack-deps:jessie@sha256:25785f89240fbcdd8a74bdaf30dd5599a9523882c6dfc567f2e9ef7cf6f79db6 \
-	busybox:latest@sha256:e4f93f6ed15a0cdd342f5aae387886fba0ab98af0a102da6276eaf24d6e6ade0 \
-	debian:jessie@sha256:f968f10b4b523737e253a97eac59b0d1420b5c19b69928d35801a6373ffe330e \
-	hello-world:latest@sha256:8be990ef2aeb16dbcb9271ddfe2610fa6658d13f6dfb8bc72074cc1ca36966a7
+COPY contrib/download-frozen-image.sh /go/src/github.com/docker/docker/contrib/
+RUN ./contrib/download-frozen-image.sh /docker-frozen-images \
+	busybox:latest@4986bf8c15363d1c5d15512d5266f8777bfba4974ac56e3270e7760f6f0a8125 \
+	hello-world:frozen@e45a5af57b00862e5ef5782a9925979a02ba2b12dff832fd0991335f4a11e5c5
 # see also "hack/make/.ensure-frozen-images" (which needs to be updated any time this list is)

-# Download man page generator
+# Install man page generator
+COPY vendor /go/src/github.com/docker/docker/vendor
+# (copy vendor/ because go-md2man needs golang.org/x/net)
 RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone --depth 1 -b v1.0.5 https://github.com/cpuguy83/go-md2man.git "$GOPATH/src/github.com/cpuguy83/go-md2man" \
-	&& git clone --depth 1 -b v1.4 https://github.com/russross/blackfriday.git "$GOPATH/src/github.com/russross/blackfriday" \
-	&& go get -v -d github.com/cpuguy83/go-md2man \
-	&& go build -v -o /usr/local/bin/go-md2man github.com/cpuguy83/go-md2man \
-	&& rm -rf "$GOPATH"
+	&& git clone -b v1.0.1 https://github.com/cpuguy83/go-md2man.git /go/src/github.com/cpuguy83/go-md2man \
+	&& git clone -b v1.2 https://github.com/russross/blackfriday.git /go/src/github.com/russross/blackfriday \
+	&& go install -v github.com/cpuguy83/go-md2man

-# Download toml validator
+# install toml validator
 ENV TOMLV_COMMIT 9baf8a8a9f2ed20a8e54160840c492f937eeaf9a
 RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/BurntSushi/toml.git "$GOPATH/src/github.com/BurntSushi/toml" \
-	&& (cd "$GOPATH/src/github.com/BurntSushi/toml" && git checkout -q "$TOMLV_COMMIT") \
-	&& go build -v -o /usr/local/bin/tomlv github.com/BurntSushi/toml/cmd/tomlv \
-	&& rm -rf "$GOPATH"
-
-# Install runc
-ENV RUNC_COMMIT 02f8fa7863dd3f82909a73e2061897828460d52f
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \
-	&& cd "$GOPATH/src/github.com/opencontainers/runc" \
-	&& git checkout -q "$RUNC_COMMIT" \
-	&& make static BUILDTAGS="seccomp apparmor selinux" \
-	&& cp runc /usr/local/bin/docker-runc \
-	&& rm -rf "$GOPATH"
-
-# Install containerd
-ENV CONTAINERD_COMMIT 0366d7e9693c930cf18c0f50cc16acec064e96c5
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \
-	&& cd "$GOPATH/src/github.com/docker/containerd" \
-	&& git checkout -q "$CONTAINERD_COMMIT" \
-	&& make static \
-	&& cp bin/containerd /usr/local/bin/docker-containerd \
-	&& cp bin/containerd-shim /usr/local/bin/docker-containerd-shim \
-	&& cp bin/ctr /usr/local/bin/docker-containerd-ctr \
-	&& rm -rf "$GOPATH"
+	&& git clone https://github.com/BurntSushi/toml.git /go/src/github.com/BurntSushi/toml \
+	&& (cd /go/src/github.com/BurntSushi/toml && git checkout -q $TOMLV_COMMIT) \
+	&& go install -v github.com/BurntSushi/toml/cmd/tomlv

 # Wrap all commands in the "docker-in-docker" script to allow nested containers
 ENTRYPOINT ["hack/dind"]
--- a/Dockerfile.aarch64
+++ b/Dockerfile.aarch64
@@ -1,211 +0,0 @@
-# This file describes the standard way to build Docker on aarch64, using docker
-#
-# Usage:
-#
-# # Assemble the full dev environment. This is slow the first time.
-# docker build -t docker -f Dockerfile.aarch64 .
-#
-# # Mount your source in an interactive container for quick testing:
-# docker run -v `pwd`:/go/src/github.com/docker/docker --privileged -i -t docker bash
-#
-# # Run the test suite:
-# docker run --privileged docker hack/make.sh test
-#
-# Note: AppArmor used to mess with privileged mode, but this is no longer
-# the case. Therefore, you don't have to disable it anymore.
-#
-
-FROM aarch64/ubuntu:wily
-
-# Packaged dependencies
-RUN apt-get update && apt-get install -y \
-	apparmor \
-	aufs-tools \
-	automake \
-	bash-completion \
-	btrfs-tools \
-	build-essential \
-	createrepo \
-	curl \
-	dpkg-sig \
-	g++ \
-	gcc \
-	git \
-	iptables \
-	jq \
-	libapparmor-dev \
-	libc6-dev \
-	libcap-dev \
-	libltdl-dev \
-	libsqlite3-dev \
-	libsystemd-dev \
-	mercurial \
-	net-tools \
-	parallel \
-	pkg-config \
-	python-dev \
-	python-mock \
-	python-pip \
-	python-websocket \
-	gccgo \
-	--no-install-recommends
-
-# Install armhf loader to use armv6 binaries on armv8
-RUN dpkg --add-architecture armhf \
-	&& apt-get update \
-	&& apt-get install -y libc6:armhf
-
-# Get lvm2 source for compiling statically
-ENV LVM2_VERSION 2.02.103
-RUN mkdir -p /usr/local/lvm2 \
-	&& curl -fsSL "https://mirrors.kernel.org/sourceware/lvm2/LVM2.${LVM2_VERSION}.tgz" \
-		| tar -xzC /usr/local/lvm2 --strip-components=1
-# see https://git.fedorahosted.org/cgit/lvm2.git/refs/tags for release tags
-
-# fix platform enablement in lvm2 to support aarch64 properly
-RUN set -e \
-	&& for f in config.guess config.sub; do \
-		curl -fsSL -o "/usr/local/lvm2/autoconf/$f" "http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=$f;hb=HEAD"; \
-	done
-# "arch.c:78:2: error: #error the arch code needs to know about your machine type"
-
-# Compile and install lvm2
-RUN cd /usr/local/lvm2 \
-	&& ./configure \
-		--build="$(gcc -print-multiarch)" \
-		--enable-static_link \
-	&& make device-mapper \
-	&& make install_device-mapper
-# see https://git.fedorahosted.org/cgit/lvm2.git/tree/INSTALL
-
-# install seccomp: the version shipped in trusty is too old
-ENV SECCOMP_VERSION 2.3.1
-RUN set -x \
-	&& export SECCOMP_PATH="$(mktemp -d)" \
-	&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
-		| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
-	&& ( \
-		cd "$SECCOMP_PATH" \
-		&& ./configure --prefix=/usr/local \
-		&& make \
-		&& make install \
-		&& ldconfig \
-	) \
-	&& rm -rf "$SECCOMP_PATH"
-
-# Install Go
-# We don't have official binary tarballs for ARM64, eigher for Go or bootstrap,
-# so we use the official armv6 released binaries as a GOROOT_BOOTSTRAP, and
-# build Go from source code.
-ENV GO_VERSION 1.6.3
-RUN mkdir /usr/src/go && curl -fsSL https://storage.googleapis.com/golang/go${GO_VERSION}.src.tar.gz | tar -v -C /usr/src/go -xz --strip-components=1 \
-	&& cd /usr/src/go/src \
-	&& GOOS=linux GOARCH=arm64 GOROOT_BOOTSTRAP="$(go env GOROOT)" ./make.bash
-
-ENV PATH /usr/src/go/bin:$PATH
-ENV GOPATH /go:/go/src/github.com/docker/docker/vendor
-
-# Only install one version of the registry, because old version which support
-# schema1 manifests is not working on ARM64, we should skip integration-cli
-# tests for schema1 manifests on ARM64.
-ENV REGISTRY_COMMIT 47a064d4195a9b56133891bbb13620c3ac83a827
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/distribution.git "$GOPATH/src/github.com/docker/distribution" \
-	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT") \
-	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/registry-v2 github.com/docker/distribution/cmd/registry \
-	&& rm -rf "$GOPATH"
-
-# Install notary and notary-server
-ENV NOTARY_VERSION v0.3.0
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/notary.git "$GOPATH/src/github.com/docker/notary" \
-	&& (cd "$GOPATH/src/github.com/docker/notary" && git checkout -q "$NOTARY_VERSION") \
-	&& GOPATH="$GOPATH/src/github.com/docker/notary/vendor:$GOPATH" \
-		go build -o /usr/local/bin/notary-server github.com/docker/notary/cmd/notary-server \
-	&& GOPATH="$GOPATH/src/github.com/docker/notary/vendor:$GOPATH" \
-		go build -o /usr/local/bin/notary github.com/docker/notary/cmd/notary \
-	&& rm -rf "$GOPATH"
-
-# Get the "docker-py" source so we can run their integration tests
-ENV DOCKER_PY_COMMIT 7befe694bd21e3c54bb1d7825270ea4bd6864c13
-RUN git clone https://github.com/docker/docker-py.git /docker-py \
-	&& cd /docker-py \
-	&& git checkout -q $DOCKER_PY_COMMIT \
-	&& pip install -r test-requirements.txt
-
-# Set user.email so crosbymichael's in-container merge commits go smoothly
-RUN git config --global user.email 'docker-dummy@example.com'
-
-# Add an unprivileged user to be used for tests which need it
-RUN groupadd -r docker
-RUN useradd --create-home --gid docker unprivilegeduser
-
-VOLUME /var/lib/docker
-WORKDIR /go/src/github.com/docker/docker
-ENV DOCKER_BUILDTAGS apparmor pkcs11 seccomp selinux
-
-# Let us use a .bashrc file
-RUN ln -sfv $PWD/.bashrc ~/.bashrc
-
-# Register Docker's bash completion.
-RUN ln -sv $PWD/contrib/completion/bash/docker /etc/bash_completion.d/docker
-
-# Get useful and necessary Hub images so we can "docker load" locally instead of pulling
-COPY contrib/download-frozen-image-v2.sh /go/src/github.com/docker/docker/contrib/
-RUN ./contrib/download-frozen-image-v2.sh /docker-frozen-images \
-	aarch64/buildpack-deps:jessie@sha256:6aa1d6910791b7ac78265fd0798e5abd6cb3f27ae992f6f960f6c303ec9535f2 \
-	aarch64/busybox:latest@sha256:b23a6a37cf269dff6e46d2473b6e227afa42b037e6d23435f1d2bc40fc8c2828 \
-	aarch64/debian:jessie@sha256:4be74a41a7c70ebe887b634b11ffe516cf4fcd56864a54941e56bb49883c3170 \
-	aarch64/hello-world:latest@sha256:65a4a158587b307bb02db4de41b836addb0c35175bdc801367b1ac1ddeb9afda
-# see also "hack/make/.ensure-frozen-images" (which needs to be updated any time this list is)
-
-# Download man page generator
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone --depth 1 -b v1.0.5 https://github.com/cpuguy83/go-md2man.git "$GOPATH/src/github.com/cpuguy83/go-md2man" \
-	&& git clone --depth 1 -b v1.4 https://github.com/russross/blackfriday.git "$GOPATH/src/github.com/russross/blackfriday" \
-	&& go get -v -d github.com/cpuguy83/go-md2man \
-	&& go build -v -o /usr/local/bin/go-md2man github.com/cpuguy83/go-md2man \
-	&& rm -rf "$GOPATH"
-
-# Download toml validator
-ENV TOMLV_COMMIT 9baf8a8a9f2ed20a8e54160840c492f937eeaf9a
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/BurntSushi/toml.git "$GOPATH/src/github.com/BurntSushi/toml" \
-	&& (cd "$GOPATH/src/github.com/BurntSushi/toml" && git checkout -q "$TOMLV_COMMIT") \
-	&& go build -v -o /usr/local/bin/tomlv github.com/BurntSushi/toml/cmd/tomlv \
-	&& rm -rf "$GOPATH"
-
-# Install runc
-ENV RUNC_COMMIT 02f8fa7863dd3f82909a73e2061897828460d52f
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \
-	&& cd "$GOPATH/src/github.com/opencontainers/runc" \
-	&& git checkout -q "$RUNC_COMMIT" \
-	&& make static BUILDTAGS="seccomp apparmor selinux" \
-	&& cp runc /usr/local/bin/docker-runc \
-	&& rm -rf "$GOPATH"
-
-# Install containerd
-ENV CONTAINERD_COMMIT 0366d7e9693c930cf18c0f50cc16acec064e96c5
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \
-	&& cd "$GOPATH/src/github.com/docker/containerd" \
-	&& git checkout -q "$CONTAINERD_COMMIT" \
-	&& make static \
-	&& cp bin/containerd /usr/local/bin/docker-containerd \
-	&& cp bin/containerd-shim /usr/local/bin/docker-containerd-shim \
-	&& cp bin/ctr /usr/local/bin/docker-containerd-ctr \
-	&& rm -rf "$GOPATH"
-
-# Wrap all commands in the "docker-in-docker" script to allow nested containers
-ENTRYPOINT ["hack/dind"]
-
-# Upload docker source
-COPY . /go/src/github.com/docker/docker
--- a/Dockerfile.armhf
+++ b/Dockerfile.armhf
@@ -1,219 +0,0 @@
-# This file describes the standard way to build Docker on ARMv7, using docker
-#
-# Usage:
-#
-# # Assemble the full dev environment. This is slow the first time.
-# docker build -t docker -f Dockerfile.armhf .
-#
-# # Mount your source in an interactive container for quick testing:
-# docker run -v `pwd`:/go/src/github.com/docker/docker --privileged -i -t docker bash
-#
-# # Run the test suite:
-# docker run --privileged docker hack/make.sh test
-#
-# Note: AppArmor used to mess with privileged mode, but this is no longer
-# the case. Therefore, you don't have to disable it anymore.
-#
-
-FROM armhf/debian:jessie
-
-# Packaged dependencies
-RUN apt-get update && apt-get install -y \
-	apparmor \
-	aufs-tools \
-	automake \
-	bash-completion \
-	btrfs-tools \
-	build-essential \
-	createrepo \
-	curl \
-	dpkg-sig \
-	git \
-	iptables \
-	jq \
-	net-tools \
-	libapparmor-dev \
-	libcap-dev \
-	libltdl-dev \
-	libsqlite3-dev \
-	libsystemd-journal-dev \
-	libtool \
-	mercurial \
-	pkg-config \
-	python-dev \
-	python-mock \
-	python-pip \
-	python-websocket \
-	xfsprogs \
-	tar \
-	--no-install-recommends \
-	&& pip install awscli==1.10.15
-
-# Get lvm2 source for compiling statically
-ENV LVM2_VERSION 2.02.103
-RUN mkdir -p /usr/local/lvm2 \
-	&& curl -fsSL "https://mirrors.kernel.org/sourceware/lvm2/LVM2.${LVM2_VERSION}.tgz" \
-		| tar -xzC /usr/local/lvm2 --strip-components=1
-# see https://git.fedorahosted.org/cgit/lvm2.git/refs/tags for release tags
-
-# Compile and install lvm2
-RUN cd /usr/local/lvm2 \
-	&& ./configure \
-		--build="$(gcc -print-multiarch)" \
-		--enable-static_link \
-	&& make device-mapper \
-	&& make install_device-mapper
-# see https://git.fedorahosted.org/cgit/lvm2.git/tree/INSTALL
-
-# Install Go
-ENV GO_VERSION 1.6.3
-RUN curl -fsSL "https://storage.googleapis.com/golang/go${GO_VERSION}.linux-armv6l.tar.gz" \
-	| tar -xzC /usr/local
-ENV PATH /go/bin:/usr/local/go/bin:$PATH
-ENV GOPATH /go:/go/src/github.com/docker/docker/vendor
-
-# we're building for armhf, which is ARMv7, so let's be explicit about that
-ENV GOARCH arm
-ENV GOARM 7
-
-# This has been commented out and kept as reference because we don't support compiling with older Go anymore.
-# ENV GOFMT_VERSION 1.3.3
-# RUN curl -sSL https://storage.googleapis.com/golang/go${GOFMT_VERSION}.$(go env GOOS)-$(go env GOARCH).tar.gz | tar -C /go/bin -xz --strip-components=2 go/bin/gofmt
-
-ENV GO_TOOLS_COMMIT 823804e1ae08dbb14eb807afc7db9993bc9e3cc3
-# Grab Go's cover tool for dead-simple code coverage testing
-# Grab Go's vet tool for examining go code to find suspicious constructs
-# and help prevent errors that the compiler might not catch
-RUN git clone https://github.com/golang/tools.git /go/src/golang.org/x/tools \
-	&& (cd /go/src/golang.org/x/tools && git checkout -q $GO_TOOLS_COMMIT) \
-	&& go install -v golang.org/x/tools/cmd/cover \
-	&& go install -v golang.org/x/tools/cmd/vet
-# Grab Go's lint tool
-ENV GO_LINT_COMMIT 32a87160691b3c96046c0c678fe57c5bef761456
-RUN git clone https://github.com/golang/lint.git /go/src/github.com/golang/lint \
-	&& (cd /go/src/github.com/golang/lint && git checkout -q $GO_LINT_COMMIT) \
-	&& go install -v github.com/golang/lint/golint
-
-# install seccomp: the version shipped in trusty is too old
-ENV SECCOMP_VERSION 2.3.1
-RUN set -x \
-	&& export SECCOMP_PATH="$(mktemp -d)" \
-	&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
-		| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
-	&& ( \
-		cd "$SECCOMP_PATH" \
-		&& ./configure --prefix=/usr/local \
-		&& make \
-		&& make install \
-		&& ldconfig \
-	) \
-	&& rm -rf "$SECCOMP_PATH"
-
-# Install two versions of the registry. The first is an older version that
-# only supports schema1 manifests. The second is a newer version that supports
-# both. This allows integration-cli tests to cover push/pull with both schema1
-# and schema2 manifests.
-ENV REGISTRY_COMMIT_SCHEMA1 ec87e9b6971d831f0eff752ddb54fb64693e51cd
-ENV REGISTRY_COMMIT cb08de17d74bef86ce6c5abe8b240e282f5750be
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/distribution.git "$GOPATH/src/github.com/docker/distribution" \
-	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT") \
-	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/registry-v2 github.com/docker/distribution/cmd/registry \
-	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT_SCHEMA1") \
-	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/registry-v2-schema1 github.com/docker/distribution/cmd/registry \
-	&& rm -rf "$GOPATH"
-
-# Install notary and notary-server
-ENV NOTARY_VERSION v0.3.0
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/notary.git "$GOPATH/src/github.com/docker/notary" \
-	&& (cd "$GOPATH/src/github.com/docker/notary" && git checkout -q "$NOTARY_VERSION") \
-	&& GOPATH="$GOPATH/src/github.com/docker/notary/vendor:$GOPATH" \
-		go build -o /usr/local/bin/notary-server github.com/docker/notary/cmd/notary-server \
-	&& GOPATH="$GOPATH/src/github.com/docker/notary/vendor:$GOPATH" \
-		go build -o /usr/local/bin/notary github.com/docker/notary/cmd/notary \
-	&& rm -rf "$GOPATH"
-
-# Get the "docker-py" source so we can run their integration tests
-ENV DOCKER_PY_COMMIT 7befe694bd21e3c54bb1d7825270ea4bd6864c13
-RUN git clone https://github.com/docker/docker-py.git /docker-py \
-	&& cd /docker-py \
-	&& git checkout -q $DOCKER_PY_COMMIT \
-	&& pip install -r test-requirements.txt
-
-# Set user.email so crosbymichael's in-container merge commits go smoothly
-RUN git config --global user.email 'docker-dummy@example.com'
-
-# Add an unprivileged user to be used for tests which need it
-RUN groupadd -r docker
-RUN useradd --create-home --gid docker unprivilegeduser
-
-VOLUME /var/lib/docker
-WORKDIR /go/src/github.com/docker/docker
-ENV DOCKER_BUILDTAGS apparmor pkcs11 seccomp selinux
-
-# Let us use a .bashrc file
-RUN ln -sfv $PWD/.bashrc ~/.bashrc
-
-# Register Docker's bash completion.
-RUN ln -sv $PWD/contrib/completion/bash/docker /etc/bash_completion.d/docker
-
-# Get useful and necessary Hub images so we can "docker load" locally instead of pulling
-COPY contrib/download-frozen-image-v2.sh /go/src/github.com/docker/docker/contrib/
-RUN ./contrib/download-frozen-image-v2.sh /docker-frozen-images \
-	armhf/buildpack-deps:jessie@sha256:ca6cce8e5bf5c952129889b5cc15cd6aa8d995d77e55e3749bbaadae50e476cb \
-	armhf/busybox:latest@sha256:d98a7343ac750ffe387e3d514f8521ba69846c216778919b01414b8617cfb3d4 \
-	armhf/debian:jessie@sha256:4a2187483f04a84f9830910fe3581d69b3c985cc045d9f01d8e2f3795b28107b \
-	armhf/hello-world:latest@sha256:161dcecea0225975b2ad5f768058212c1e0d39e8211098666ffa1ac74cfb7791
-# see also "hack/make/.ensure-frozen-images" (which needs to be updated any time this list is)
-
-# Download man page generator
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone --depth 1 -b v1.0.5 https://github.com/cpuguy83/go-md2man.git "$GOPATH/src/github.com/cpuguy83/go-md2man" \
-	&& git clone --depth 1 -b v1.4 https://github.com/russross/blackfriday.git "$GOPATH/src/github.com/russross/blackfriday" \
-	&& go get -v -d github.com/cpuguy83/go-md2man \
-	&& go build -v -o /usr/local/bin/go-md2man github.com/cpuguy83/go-md2man \
-	&& rm -rf "$GOPATH"
-
-# Download toml validator
-ENV TOMLV_COMMIT 9baf8a8a9f2ed20a8e54160840c492f937eeaf9a
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/BurntSushi/toml.git "$GOPATH/src/github.com/BurntSushi/toml" \
-	&& (cd "$GOPATH/src/github.com/BurntSushi/toml" && git checkout -q "$TOMLV_COMMIT") \
-	&& go build -v -o /usr/local/bin/tomlv github.com/BurntSushi/toml/cmd/tomlv \
-	&& rm -rf "$GOPATH"
-
-# Install runc
-ENV RUNC_COMMIT 02f8fa7863dd3f82909a73e2061897828460d52f
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \
-	&& cd "$GOPATH/src/github.com/opencontainers/runc" \
-	&& git checkout -q "$RUNC_COMMIT" \
-	&& make static BUILDTAGS="seccomp apparmor selinux" \
-	&& cp runc /usr/local/bin/docker-runc \
-	&& rm -rf "$GOPATH"
-
-# Install containerd
-ENV CONTAINERD_COMMIT 0366d7e9693c930cf18c0f50cc16acec064e96c5
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \
-	&& cd "$GOPATH/src/github.com/docker/containerd" \
-	&& git checkout -q "$CONTAINERD_COMMIT" \
-	&& make static \
-	&& cp bin/containerd /usr/local/bin/docker-containerd \
-	&& cp bin/containerd-shim /usr/local/bin/docker-containerd-shim \
-	&& cp bin/ctr /usr/local/bin/docker-containerd-ctr \
-	&& rm -rf "$GOPATH"
-
-ENTRYPOINT ["hack/dind"]
-
-# Upload docker source
-COPY . /go/src/github.com/docker/docker
--- a/Dockerfile.gccgo
+++ b/Dockerfile.gccgo
@@ -1,104 +0,0 @@
-# This file describes the standard way to build Docker, using docker
-#
-# Usage:
-#
-# # Assemble the full dev environment. This is slow the first time.
-# docker build -t docker -f Dockerfile.gccgo .
-#
-
-FROM gcc:6.1
-
-# Packaged dependencies
-RUN apt-get update && apt-get install -y \
-	apparmor \
-	aufs-tools \
-	btrfs-tools \
-	build-essential \
-	curl \
-	git \
-	iptables \
-	jq \
-	net-tools \
-	libapparmor-dev \
-	libcap-dev \
-	libsqlite3-dev \
-	mercurial \
-	net-tools \
-	parallel \
-	python-dev \
-	python-mock \
-	python-pip \
-	python-websocket \
-	--no-install-recommends
-
-# Get lvm2 source for compiling statically
-RUN git clone -b v2_02_103 https://git.fedorahosted.org/git/lvm2.git /usr/local/lvm2
-# see https://git.fedorahosted.org/cgit/lvm2.git/refs/tags for release tags
-
-# Compile and install lvm2
-RUN cd /usr/local/lvm2 \
-	&& ./configure --enable-static_link \
-	&& make device-mapper \
-	&& make install_device-mapper
-# see https://git.fedorahosted.org/cgit/lvm2.git/tree/INSTALL
-
-# install seccomp: the version shipped in jessie is too old
-ENV SECCOMP_VERSION v2.3.1
-RUN set -x \
-    && export SECCOMP_PATH=$(mktemp -d) \
-    && git clone https://github.com/seccomp/libseccomp.git "$SECCOMP_PATH" \
-    && ( \
-        cd "$SECCOMP_PATH" \
-        && git checkout "$SECCOMP_VERSION" \
-        && ./autogen.sh \
-        && ./configure --prefix=/usr \
-        && make \
-        && make install \
-    ) \
-    && rm -rf "$SECCOMP_PATH"
-
-ENV GOPATH /go:/go/src/github.com/docker/docker/vendor
-
-# Get the "docker-py" source so we can run their integration tests
-ENV DOCKER_PY_COMMIT 7befe694bd21e3c54bb1d7825270ea4bd6864c13
-RUN git clone https://github.com/docker/docker-py.git /docker-py \
-	&& cd /docker-py \
-	&& git checkout -q $DOCKER_PY_COMMIT
-
-# Add an unprivileged user to be used for tests which need it
-RUN groupadd -r docker
-RUN useradd --create-home --gid docker unprivilegeduser
-
-VOLUME /var/lib/docker
-WORKDIR /go/src/github.com/docker/docker
-ENV DOCKER_BUILDTAGS apparmor seccomp selinux
-
-# Install runc
-ENV RUNC_COMMIT 02f8fa7863dd3f82909a73e2061897828460d52f
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-    && git clone https://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \
-	&& cd "$GOPATH/src/github.com/opencontainers/runc" \
-	&& git checkout -q "$RUNC_COMMIT" \
-	&& make static BUILDTAGS="seccomp apparmor selinux" \
-	&& cp runc /usr/local/bin/docker-runc \
-	&& rm -rf "$GOPATH"
-
-# Install containerd
-ENV CONTAINERD_COMMIT 0366d7e9693c930cf18c0f50cc16acec064e96c5
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \
-	&& cd "$GOPATH/src/github.com/docker/containerd" \
-	&& git checkout -q "$CONTAINERD_COMMIT" \
-	&& make static \
-	&& cp bin/containerd /usr/local/bin/docker-containerd \
-	&& cp bin/containerd-shim /usr/local/bin/docker-containerd-shim \
-	&& cp bin/ctr /usr/local/bin/docker-containerd-ctr \
-	&& rm -rf "$GOPATH"
-
-# Wrap all commands in the "docker-in-docker" script to allow nested containers
-ENTRYPOINT ["hack/dind"]
-
-# Upload docker source
-COPY . /go/src/github.com/docker/docker
--- a/Dockerfile.ppc64le
+++ b/Dockerfile.ppc64le
@@ -1,232 +0,0 @@
-# This file describes the standard way to build Docker on ppc64le, using docker
-#
-# Usage:
-#
-# # Assemble the full dev environment. This is slow the first time.
-# docker build -t docker -f Dockerfile.ppc64le .
-#
-# # Mount your source in an interactive container for quick testing:
-# docker run -v `pwd`:/go/src/github.com/docker/docker --privileged -i -t docker bash
-#
-# # Run the test suite:
-# docker run --privileged docker hack/make.sh test
-#
-# Note: AppArmor used to mess with privileged mode, but this is no longer
-# the case. Therefore, you don't have to disable it anymore.
-#
-
-FROM ppc64le/gcc:6.1
-
-# Packaged dependencies
-RUN apt-get update && apt-get install -y \
-	apparmor \
-	aufs-tools \
-	automake \
-	bash-completion \
-	btrfs-tools \
-	build-essential \
-	createrepo \
-	curl \
-	dpkg-sig \
-	git \
-	iptables \
-	jq \
-	net-tools \
-	libapparmor-dev \
-	libcap-dev \
-	libltdl-dev \
-	libsqlite3-dev \
-	libsystemd-journal-dev \
-	libtool \
-	mercurial \
-	pkg-config \
-	python-dev \
-	python-mock \
-	python-pip \
-	python-websocket \
-	xfsprogs \
-	tar \
-	--no-install-recommends
-
-# Get lvm2 source for compiling statically
-ENV LVM2_VERSION 2.02.103
-RUN mkdir -p /usr/local/lvm2 \
-	&& curl -fsSL "https://mirrors.kernel.org/sourceware/lvm2/LVM2.${LVM2_VERSION}.tgz" \
-		| tar -xzC /usr/local/lvm2 --strip-components=1
-# see https://git.fedorahosted.org/cgit/lvm2.git/refs/tags for release tags
-
-# fix platform enablement in lvm2 to support ppc64le properly
-RUN set -e \
-	&& for f in config.guess config.sub; do \
-		curl -fsSL -o "/usr/local/lvm2/autoconf/$f" "http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=$f;hb=HEAD"; \
-	done
-# "arch.c:78:2: error: #error the arch code needs to know about your machine type"
-
-# Compile and install lvm2
-RUN cd /usr/local/lvm2 \
-	&& ./configure \
-		--build="$(gcc -print-multiarch)" \
-		--enable-static_link \
-	&& make device-mapper \
-	&& make install_device-mapper
-# see https://git.fedorahosted.org/cgit/lvm2.git/tree/INSTALL
-
-# install seccomp: the version shipped in jessie is too old
-ENV SECCOMP_VERSION 2.3.1
-RUN set -x \
-        && export SECCOMP_PATH="$(mktemp -d)" \
-        && curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
-                | tar -xzC "$SECCOMP_PATH" --strip-components=1 \
-        && ( \
-                cd "$SECCOMP_PATH" \
-                && ./configure --prefix=/usr/local \
-                && make \
-                && make install \
-                && ldconfig \
-        ) \
-        && rm -rf "$SECCOMP_PATH"
-
-
-## BUILD GOLANG 1.6
-# NOTE: ppc64le has compatibility issues with older versions of go, so make sure the version >= 1.6
-ENV GO_VERSION 1.6.3
-ENV GO_DOWNLOAD_URL https://golang.org/dl/go${GO_VERSION}.src.tar.gz
-ENV GOROOT_BOOTSTRAP /usr/local
-
-RUN curl -fsSL "$GO_DOWNLOAD_URL" -o golang.tar.gz \
-    && tar -C /usr/src -xzf golang.tar.gz \
-    && rm golang.tar.gz \
-    && cd /usr/src/go/src && ./make.bash 2>&1
-
-ENV GOROOT_BOOTSTRAP /usr/src/
-
-ENV PATH /usr/src/go/bin/:/go/bin:$PATH
-ENV GOPATH /go:/go/src/github.com/docker/docker/vendor
-
-# This has been commented out and kept as reference because we don't support compiling with older Go anymore.
-# ENV GOFMT_VERSION 1.3.3
-# RUN curl -sSL https://storage.googleapis.com/golang/go${GOFMT_VERSION}.$(go env GOOS)-$(go env GOARCH).tar.gz | tar -C /go/bin -xz --strip-components=2 go/bin/gofmt
-
-ENV GO_TOOLS_COMMIT 823804e1ae08dbb14eb807afc7db9993bc9e3cc3
-# Grab Go's cover tool for dead-simple code coverage testing
-# Grab Go's vet tool for examining go code to find suspicious constructs
-# and help prevent errors that the compiler might not catch
-RUN git clone https://github.com/golang/tools.git /go/src/golang.org/x/tools \
-	&& (cd /go/src/golang.org/x/tools && git checkout -q $GO_TOOLS_COMMIT) \
-	&& go install -v golang.org/x/tools/cmd/cover \
-	&& go install -v golang.org/x/tools/cmd/vet
-# Grab Go's lint tool
-ENV GO_LINT_COMMIT 32a87160691b3c96046c0c678fe57c5bef761456
-RUN git clone https://github.com/golang/lint.git /go/src/github.com/golang/lint \
-	&& (cd /go/src/github.com/golang/lint && git checkout -q $GO_LINT_COMMIT) \
-	&& go install -v github.com/golang/lint/golint
-
-# Install two versions of the registry. The first is an older version that
-# only supports schema1 manifests. The second is a newer version that supports
-# both. This allows integration-cli tests to cover push/pull with both schema1
-# and schema2 manifests.
-ENV REGISTRY_COMMIT_SCHEMA1 ec87e9b6971d831f0eff752ddb54fb64693e51cd
-ENV REGISTRY_COMMIT 47a064d4195a9b56133891bbb13620c3ac83a827
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/distribution.git "$GOPATH/src/github.com/docker/distribution" \
-	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT") \
-	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/registry-v2 github.com/docker/distribution/cmd/registry \
-	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT_SCHEMA1") \
-	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/registry-v2-schema1 github.com/docker/distribution/cmd/registry \
-	&& rm -rf "$GOPATH"
-
-# Install notary and notary-server
-ENV NOTARY_VERSION v0.3.0
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/notary.git "$GOPATH/src/github.com/docker/notary" \
-	&& (cd "$GOPATH/src/github.com/docker/notary" && git checkout -q "$NOTARY_VERSION") \
-	&& GOPATH="$GOPATH/src/github.com/docker/notary/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/notary-server github.com/docker/notary/cmd/notary-server \
-	&& GOPATH="$GOPATH/src/github.com/docker/notary/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/notary github.com/docker/notary/cmd/notary \
-	&& rm -rf "$GOPATH"
-
-# Get the "docker-py" source so we can run their integration tests
-ENV DOCKER_PY_COMMIT 7befe694bd21e3c54bb1d7825270ea4bd6864c13
-RUN git clone https://github.com/docker/docker-py.git /docker-py \
-	&& cd /docker-py \
-	&& git checkout -q $DOCKER_PY_COMMIT \
-	&& pip install -r test-requirements.txt
-
-# Set user.email so crosbymichael's in-container merge commits go smoothly
-RUN git config --global user.email 'docker-dummy@example.com'
-
-# Add an unprivileged user to be used for tests which need it
-RUN groupadd -r docker
-RUN useradd --create-home --gid docker unprivilegeduser
-
-VOLUME /var/lib/docker
-WORKDIR /go/src/github.com/docker/docker
-ENV DOCKER_BUILDTAGS apparmor pkcs11 seccomp selinux
-
-# Let us use a .bashrc file
-RUN ln -sfv $PWD/.bashrc ~/.bashrc
-
-# Register Docker's bash completion.
-RUN ln -sv $PWD/contrib/completion/bash/docker /etc/bash_completion.d/docker
-
-# Get useful and necessary Hub images so we can "docker load" locally instead of pulling
-COPY contrib/download-frozen-image-v2.sh /go/src/github.com/docker/docker/contrib/
-RUN ./contrib/download-frozen-image-v2.sh /docker-frozen-images \
-	ppc64le/buildpack-deps:jessie@sha256:902bfe4ef1389f94d143d64516dd50a2de75bca2e66d4a44b1d73f63ddf05dda \
-	ppc64le/busybox:latest@sha256:38bb82085248d5a3c24bd7a5dc146f2f2c191e189da0441f1c2ca560e3fc6f1b \
-	ppc64le/debian:jessie@sha256:412845f51b6ab662afba71bc7a716e20fdb9b84f185d180d4c7504f8a75c4f91 \
-	ppc64le/hello-world:latest@sha256:186a40a9a02ca26df0b6c8acdfb8ac2f3ae6678996a838f977e57fac9d963974
-# see also "hack/make/.ensure-frozen-images" (which needs to be updated any time this list is)
-
-# Download man page generator
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone --depth 1 -b v1.0.5 https://github.com/cpuguy83/go-md2man.git "$GOPATH/src/github.com/cpuguy83/go-md2man" \
-	&& git clone --depth 1 -b v1.4 https://github.com/russross/blackfriday.git "$GOPATH/src/github.com/russross/blackfriday" \
-	&& go get -v -d github.com/cpuguy83/go-md2man \
-	&& go build -v -o /usr/local/bin/go-md2man github.com/cpuguy83/go-md2man \
-	&& rm -rf "$GOPATH"
-
-# Download toml validator
-ENV TOMLV_COMMIT 9baf8a8a9f2ed20a8e54160840c492f937eeaf9a
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/BurntSushi/toml.git "$GOPATH/src/github.com/BurntSushi/toml" \
-	&& (cd "$GOPATH/src/github.com/BurntSushi/toml" && git checkout -q "$TOMLV_COMMIT") \
-	&& go build -v -o /usr/local/bin/tomlv github.com/BurntSushi/toml/cmd/tomlv \
-	&& rm -rf "$GOPATH"
-
-# Install runc
-ENV RUNC_COMMIT 02f8fa7863dd3f82909a73e2061897828460d52f
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \
-	&& cd "$GOPATH/src/github.com/opencontainers/runc" \
-	&& git checkout -q "$RUNC_COMMIT" \
-	&& make static BUILDTAGS="apparmor seccomp selinux" \
-	&& cp runc /usr/local/bin/docker-runc \
-	&& rm -rf "$GOPATH"
-
-# Install containerd
-ENV CONTAINERD_COMMIT 0366d7e9693c930cf18c0f50cc16acec064e96c5
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \
-	&& cd "$GOPATH/src/github.com/docker/containerd" \
-	&& git checkout -q "$CONTAINERD_COMMIT" \
-	&& make static \
-	&& cp bin/containerd /usr/local/bin/docker-containerd \
-	&& cp bin/containerd-shim /usr/local/bin/docker-containerd-shim \
-	&& cp bin/ctr /usr/local/bin/docker-containerd-ctr \
-	&& rm -rf "$GOPATH"
-
-# Wrap all commands in the "docker-in-docker" script to allow nested containers
-ENTRYPOINT ["hack/dind"]
-
-# Upload docker source
-COPY . /go/src/github.com/docker/docker
--- a/Dockerfile.s390x
+++ b/Dockerfile.s390x
@@ -1,227 +0,0 @@
-# This file describes the standard way to build Docker on s390x, using docker
-#
-# Usage:
-#
-# # Assemble the full dev environment. This is slow the first time.
-# docker build -t docker -f Dockerfile.s390x .
-#
-# # Mount your source in an interactive container for quick testing:
-# docker run -v `pwd`:/go/src/github.com/docker/docker --privileged -i -t docker bash
-#
-# # Run the test suite:
-# docker run --privileged docker hack/make.sh test
-#
-# Note: AppArmor used to mess with privileged mode, but this is no longer
-# the case. Therefore, you don't have to disable it anymore.
-#
-
-FROM s390x/gcc:6.1
-
-# Packaged dependencies
-RUN apt-get update && apt-get install -y \
-	apparmor \
-	aufs-tools \
-	automake \
-	bash-completion \
-	btrfs-tools \
-	build-essential \
-	createrepo \
-	curl \
-	dpkg-sig \
-	git \
-	iptables \
-	jq \
-	net-tools \
-	libapparmor-dev \
-	libcap-dev \
-	libltdl-dev \
-	libsqlite3-dev \
-	libsystemd-journal-dev \
-	libtool \
-	mercurial \
-	pkg-config \
-	python-dev \
-	python-mock \
-	python-pip \
-	python-websocket \
-	xfsprogs \
-	tar \
-	--no-install-recommends
-
-# install seccomp: the version shipped in jessie is too old
-ENV SECCOMP_VERSION 2.3.1
-RUN set -x \
-	&& export SECCOMP_PATH="$(mktemp -d)" \
-	&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
-		| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
-	&& ( \
-		cd "$SECCOMP_PATH" \
-		&& ./configure --prefix=/usr/local \
-		&& make \
-		&& make install \
-		&& ldconfig \
-	) \
-	&& rm -rf "$SECCOMP_PATH"
-
-# Get lvm2 source for compiling statically
-ENV LVM2_VERSION 2.02.103
-RUN mkdir -p /usr/local/lvm2 \
-	&& curl -fsSL "https://mirrors.kernel.org/sourceware/lvm2/LVM2.${LVM2_VERSION}.tgz" \
-		| tar -xzC /usr/local/lvm2 --strip-components=1
-# see https://git.fedorahosted.org/cgit/lvm2.git/refs/tags for release tags
-
-# fix platform enablement in lvm2 to support s390x properly
-RUN set -e \
-	&& for f in config.guess config.sub; do \
-		curl -fsSL -o "/usr/local/lvm2/autoconf/$f" "http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=$f;hb=HEAD"; \
-	done
-# "arch.c:78:2: error: #error the arch code needs to know about your machine type"
-
-# Compile and install lvm2
-RUN cd /usr/local/lvm2 \
-	&& ./configure \
-		--build="$(gcc -print-multiarch)" \
-		--enable-static_link \
-	&& make device-mapper \
-	&& make install_device-mapper
-# see https://git.fedorahosted.org/cgit/lvm2.git/tree/INSTALL
-
-# Note: Go comes from the base image (gccgo, specifically)
-# We can't compile Go proper because s390x isn't an officially supported architecture yet.
-
-ENV PATH /go/bin:$PATH
-ENV GOPATH /go:/go/src/github.com/docker/docker/vendor
-
-# This has been commented out and kept as reference because we don't support compiling with older Go anymore.
-# ENV GOFMT_VERSION 1.3.3
-# RUN curl -sSL https://storage.googleapis.com/golang/go${GOFMT_VERSION}.$(go env GOOS)-$(go env GOARCH).tar.gz | tar -C /go/bin -xz --strip-components=2 go/bin/gofmt
-
-# TODO update this sha when we upgrade to Go 1.5+
-ENV GO_TOOLS_COMMIT 069d2f3bcb68257b627205f0486d6cc69a231ff9
-# Grab Go's cover tool for dead-simple code coverage testing
-# Grab Go's vet tool for examining go code to find suspicious constructs
-# and help prevent errors that the compiler might not catch
-RUN git clone https://github.com/golang/tools.git /go/src/golang.org/x/tools \
-	&& (cd /go/src/golang.org/x/tools && git checkout -q $GO_TOOLS_COMMIT) \
-	&& go install -v golang.org/x/tools/cmd/cover \
-	&& go install -v golang.org/x/tools/cmd/vet
-# Grab Go's lint tool
-ENV GO_LINT_COMMIT f42f5c1c440621302702cb0741e9d2ca547ae80f
-RUN git clone https://github.com/golang/lint.git /go/src/github.com/golang/lint \
-	&& (cd /go/src/github.com/golang/lint && git checkout -q $GO_LINT_COMMIT) \
-	&& go install -v github.com/golang/lint/golint
-
-
-# Install two versions of the registry. The first is an older version that
-# only supports schema1 manifests. The second is a newer version that supports
-# both. This allows integration-cli tests to cover push/pull with both schema1
-# and schema2 manifests.
-ENV REGISTRY_COMMIT_SCHEMA1 ec87e9b6971d831f0eff752ddb54fb64693e51cd
-ENV REGISTRY_COMMIT 47a064d4195a9b56133891bbb13620c3ac83a827
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/distribution.git "$GOPATH/src/github.com/docker/distribution" \
-	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT") \
-	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/registry-v2 github.com/docker/distribution/cmd/registry \
-	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT_SCHEMA1") \
-	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
-		go build -o /usr/local/bin/registry-v2-schema1 github.com/docker/distribution/cmd/registry \
-	&& rm -rf "$GOPATH"
-
-# Install notary and notary-server
-#
-# Note: We have to explicitly set GO15VENDOREXPERIMENT=0 because gccgo does not
-# support vendoring: https://github.com/golang/go/issues/15628
-ENV NOTARY_VERSION v0.3.0
-RUN set -x \
-	&& export GO15VENDOREXPERIMENT=0 \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/notary.git "$GOPATH/src/github.com/docker/notary" \
-	&& (cd "$GOPATH/src/github.com/docker/notary" && git checkout -q "$NOTARY_VERSION" && ln -s . vendor/src) \
-	&& GOPATH="$GOPATH/src/github.com/docker/notary/vendor:$GOPATH" \
-		go build -o /usr/local/bin/notary-server github.com/docker/notary/cmd/notary-server \
-	&& GOPATH="$GOPATH/src/github.com/docker/notary/vendor:$GOPATH" \
-		go build -o /usr/local/bin/notary github.com/docker/notary/cmd/notary \
-	&& rm -rf "$GOPATH"
-
-# Get the "docker-py" source so we can run their integration tests
-ENV DOCKER_PY_COMMIT 7befe694bd21e3c54bb1d7825270ea4bd6864c13
-RUN git clone https://github.com/docker/docker-py.git /docker-py \
-	&& cd /docker-py \
-	&& git checkout -q $DOCKER_PY_COMMIT \
-	&& pip install -r test-requirements.txt
-
-# Set user.email so crosbymichael's in-container merge commits go smoothly
-RUN git config --global user.email 'docker-dummy@example.com'
-
-# Add an unprivileged user to be used for tests which need it
-RUN groupadd -r docker
-RUN useradd --create-home --gid docker unprivilegeduser
-
-VOLUME /var/lib/docker
-WORKDIR /go/src/github.com/docker/docker
-ENV DOCKER_BUILDTAGS apparmor selinux seccomp
-
-# Let us use a .bashrc file
-RUN ln -sfv $PWD/.bashrc ~/.bashrc
-
-# Register Docker's bash completion.
-RUN ln -sv $PWD/contrib/completion/bash/docker /etc/bash_completion.d/docker
-
-# Get useful and necessary Hub images so we can "docker load" locally instead of pulling
-COPY contrib/download-frozen-image-v2.sh /go/src/github.com/docker/docker/contrib/
-RUN ./contrib/download-frozen-image-v2.sh /docker-frozen-images \
-	s390x/buildpack-deps:jessie@sha256:4d1381224acaca6c4bfe3604de3af6972083a8558a99672cb6989c7541780099 \
-	s390x/busybox:latest@sha256:dd61522c983884a66ed72d60301925889028c6d2d5e0220a8fe1d9b4c6a4f01b \
-	s390x/debian:jessie@sha256:b74c863400909eff3c5e196cac9bfd1f6333ce47aae6a38398d87d5875da170a \
-	s390x/hello-world:latest@sha256:780d80b3a7677c3788c0d5cd9168281320c8d4a6d9183892d8ee5cdd610f5699
-# see also "hack/make/.ensure-frozen-images" (which needs to be updated any time this list is)
-
-# Download man page generator
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone --depth 1 -b v1.0.5 https://github.com/cpuguy83/go-md2man.git "$GOPATH/src/github.com/cpuguy83/go-md2man" \
-	&& git clone --depth 1 -b v1.4 https://github.com/russross/blackfriday.git "$GOPATH/src/github.com/russross/blackfriday" \
-	&& go get -v -d github.com/cpuguy83/go-md2man \
-	&& go build -v -o /usr/local/bin/go-md2man github.com/cpuguy83/go-md2man \
-	&& rm -rf "$GOPATH"
-
-# Download toml validator
-ENV TOMLV_COMMIT 9baf8a8a9f2ed20a8e54160840c492f937eeaf9a
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/BurntSushi/toml.git "$GOPATH/src/github.com/BurntSushi/toml" \
-	&& (cd "$GOPATH/src/github.com/BurntSushi/toml" && git checkout -q "$TOMLV_COMMIT") \
-	&& go build -v -o /usr/local/bin/tomlv github.com/BurntSushi/toml/cmd/tomlv \
-	&& rm -rf "$GOPATH"
-
-# Install runc
-ENV RUNC_COMMIT 02f8fa7863dd3f82909a73e2061897828460d52f
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \
-	&& cd "$GOPATH/src/github.com/opencontainers/runc" \
-	&& git checkout -q "$RUNC_COMMIT" \
-	&& make static BUILDTAGS="seccomp apparmor selinux" \
-	&& cp runc /usr/local/bin/docker-runc \
-	&& rm -rf "$GOPATH"
-
-# Install containerd
-ENV CONTAINERD_COMMIT 0366d7e9693c930cf18c0f50cc16acec064e96c5
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \
-	&& cd "$GOPATH/src/github.com/docker/containerd" \
-	&& git checkout -q "$CONTAINERD_COMMIT" \
-	&& make static \
-	&& cp bin/containerd /usr/local/bin/docker-containerd \
-	&& cp bin/containerd-shim /usr/local/bin/docker-containerd-shim \
-	&& cp bin/ctr /usr/local/bin/docker-containerd-ctr \
-	&& rm -rf "$GOPATH"
-
-# Wrap all commands in the "docker-in-docker" script to allow nested containers
-ENTRYPOINT ["hack/dind"]
-
-# Upload docker source
-COPY . /go/src/github.com/docker/docker
--- a/Dockerfile.simple
+++ b/Dockerfile.simple
@@ -12,11 +12,10 @@ FROM debian:jessie
 # https://github.com/docker/docker/blob/master/project/PACKAGERS.md#runtime-dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
 		btrfs-tools \
-		build-essential \
 		curl \
 		gcc \
 		git \
-		libapparmor-dev \
+		golang \
 		libdevmapper-dev \
 		libsqlite3-dev \
 		\
@@ -24,62 +23,12 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 		e2fsprogs \
 		iptables \
 		procps \
-		xfsprogs \
 		xz-utils \
 		\
 		aufs-tools \
+		lxc \
 	&& rm -rf /var/lib/apt/lists/*

-# install seccomp: the version shipped in trusty is too old
-ENV SECCOMP_VERSION 2.3.1
-RUN set -x \
-	&& export SECCOMP_PATH="$(mktemp -d)" \
-	&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
-		| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
-	&& ( \
-		cd "$SECCOMP_PATH" \
-		&& ./configure --prefix=/usr/local \
-		&& make \
-		&& make install \
-		&& ldconfig \
-	) \
-	&& rm -rf "$SECCOMP_PATH"
-
-# Install Go
-# IMPORTANT: If the version of Go is updated, the Windows to Linux CI machines
-#            will need updating, to avoid errors. Ping #docker-maintainers on IRC
-#            with a heads-up.
-ENV GO_VERSION 1.6.3
-RUN curl -fsSL "https://storage.googleapis.com/golang/go${GO_VERSION}.linux-amd64.tar.gz" \
-	| tar -xzC /usr/local
-ENV PATH /go/bin:/usr/local/go/bin:$PATH
-ENV GOPATH /go:/go/src/github.com/docker/docker/vendor
-ENV CGO_LDFLAGS -L/lib
-
-# Install runc
-ENV RUNC_COMMIT 02f8fa7863dd3f82909a73e2061897828460d52f
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \
-	&& cd "$GOPATH/src/github.com/opencontainers/runc" \
-	&& git checkout -q "$RUNC_COMMIT" \
-	&& make static BUILDTAGS="seccomp apparmor selinux" \
-	&& cp runc /usr/local/bin/docker-runc \
-	&& rm -rf "$GOPATH"
-
-# Install containerd
-ENV CONTAINERD_COMMIT 0366d7e9693c930cf18c0f50cc16acec064e96c5
-RUN set -x \
-	&& export GOPATH="$(mktemp -d)" \
-	&& git clone https://github.com/docker/containerd.git "$GOPATH/src/github.com/docker/containerd" \
-	&& cd "$GOPATH/src/github.com/docker/containerd" \
-	&& git checkout -q "$CONTAINERD_COMMIT" \
-	&& make static \
-	&& cp bin/containerd /usr/local/bin/docker-containerd \
-	&& cp bin/containerd-shim /usr/local/bin/docker-containerd-shim \
-	&& cp bin/ctr /usr/local/bin/docker-containerd-ctr \
-	&& rm -rf "$GOPATH"
-
 ENV AUTO_GOPATH 1
 WORKDIR /usr/src/docker
 COPY . /usr/src/docker
--- a/Dockerfile.windows
+++ b/Dockerfile.windows
@@ -1,89 +0,0 @@
-# This file describes the standard way to build Docker, using a docker container on Windows
-# Server 2016
-#
-# Usage:
-#
-# # Assemble the full dev environment. This is slow the first time. Run this from
-# # a directory containing the sources you are validating. For example from
-# # c:\go\src\github.com\docker\docker
-#
-# docker build -t docker -f Dockerfile.windows .
-#
-#
-# # Build docker in a container. Run the following from a Windows cmd command prommpt,
-# # replacing c:\built with the directory you want the binaries to be placed on the
-# # host system.
-#
-# docker run --rm -v "c:\built:c:\target" docker sh -c 'cd /c/go/src/github.com/docker/docker; hack/make.sh binary; ec=$?; if [ $ec -eq 0 ]; then robocopy /c/go/src/github.com/docker/docker/bundles/$(cat VERSION)/binary /c/target/binary; fi; exit $ec'
-#
-# Important notes:
-# ---------------
-#
-# The posix utilities from GIT aren't usable interactively as at January 2016. This
-# is because they require a console window which isn't present in a container in Windows.
-# See the example at the top of this file. Do NOT use -it in that docker run!!!
-#
-# Don't try to use a volume for passing the source through. The posix utilities will
-# balk at reparse points. Again, see the example at the top of this file on how use a volume
-# to get the built binary out of the container.
-#
-# The steps are minimised dramatically to improve performance
-
-FROM windowsservercore
-
-# Environment variable notes:
-#  - GO_VERSION must consistent with 'Dockerfile' used by Linux'.
-#  - FROM_DOCKERFILE is used for detection of building within a container.
-ENV GO_VERSION=1.6.3 \
-    GIT_LOCATION=https://github.com/git-for-windows/git/releases/download/v2.7.2.windows.1/Git-2.7.2-64-bit.exe \
-    GOPATH=C:/go;C:/go/src/github.com/docker/docker/vendor \
-    FROM_DOCKERFILE=1
-
-WORKDIR c:/
-
-# Everything downloaded/installed in one go (better performance, esp on TP4)
-RUN \
- setx /M Path "c:\git\cmd;c:\git\bin;c:\git\usr\bin;%Path%;c:\gcc\bin;c:\go\bin" && \
- setx GOROOT "c:\go" && \
- powershell -command \
-  $ErrorActionPreference = 'Stop'; \
-  Function Download-File([string] $source, [string] $target) { \
-   $wc = New-Object net.webclient; $wc.Downloadfile($source, $target) \
-  } \
-  \
-  Write-Host INFO: Downloading git...; \
-  Download-File %GIT_LOCATION% gitsetup.exe; \
-  \
-  Write-Host INFO: Downloading go...; \
-  Download-File https://storage.googleapis.com/golang/go%GO_VERSION%.windows-amd64.msi go.msi; \
-  \
-  Write-Host INFO: Downloading compiler 1 of 3...; \
-  Download-File https://raw.githubusercontent.com/jhowardmsft/docker-tdmgcc/master/gcc.zip gcc.zip; \
-  \
-  Write-Host INFO: Downloading compiler 2 of 3...; \
-  Download-File https://raw.githubusercontent.com/jhowardmsft/docker-tdmgcc/master/runtime.zip runtime.zip; \
-  \
-  Write-Host INFO: Downloading compiler 3 of 3...; \
-  Download-File https://raw.githubusercontent.com/jhowardmsft/docker-tdmgcc/master/binutils.zip binutils.zip; \
-  \
-  Write-Host INFO: Installing git...; \
-  Start-Process gitsetup.exe -ArgumentList '/VERYSILENT /SUPPRESSMSGBOXES /CLOSEAPPLICATIONS /DIR=c:\git\' -Wait; \
-  \
-  Write-Host INFO: Installing go..."; \
-  Start-Process msiexec -ArgumentList '-i go.msi -quiet' -Wait; \
-  \
-  Write-Host INFO: Unzipping compiler...; \
-  c:\git\usr\bin\unzip.exe -q -o gcc.zip -d /c/gcc; \
-  c:\git\usr\bin\unzip.exe -q -o runtime.zip -d /c/gcc; \
-  c:\git\usr\bin\unzip.exe -q -o binutils.zip -d /c/gcc"; \
-  \
-  Write-Host INFO: Removing interim files; \
-  Remove-Item *.zip; \
-  Remove-Item go.msi; \
-  Remove-Item gitsetup.exe; \
-  \
-  Write-Host INFO: Completed
-
-# Prepare for building
-COPY . /go/src/github.com/docker/docker
-
--- a/6
+++ b/6
@@ -1,7 +1,7 @@

                                 Apache License
                           Version 2.0, January 2004
-                        https://www.apache.org/licenses/
+                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

@@ -176,13 +176,13 @@

   END OF TERMS AND CONDITIONS

-   Copyright 2013-2016 Docker, Inc.
+   Copyright 2013-2015 Docker, Inc.

   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

-       https://www.apache.org/licenses/LICENSE-2.0
+       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,
--- a/705
+++ b/705
@@ -1,16 +1,325 @@
 # Docker maintainers file
 #
-# This file describes who runs the docker/docker project and how.
-# This is a living document - if you see something out of date or missing, speak up!
+# This file describes who runs the Docker project and how.
+# This is a living document - if you see something out of date or missing,
+# speak up!
 #
 # It is structured to be consumable by both humans and programs.
 # To extract its contents programmatically, use any TOML-compliant
 # parser.
-#
-# This file is compiled into the MAINTAINERS file in docker/opensource.
-#
+
+[Rules]
+
+	[Rules.maintainers]
+
+		title = "What is a maintainer?"
+
+		text = """
+There are different types of maintainers, with different responsibilities, but
+all maintainers have 3 things in common:
+
+1) They share responsibility in the project's success.
+2) They have made a long-term, recurring time investment to improve the project.
+3) They spend that time doing whatever needs to be done, not necessarily what
+is the most interesting or fun.
+
+Maintainers are often under-appreciated, because their work is harder to appreciate.
+It's easy to appreciate a really cool and technically advanced feature. It's harder
+to appreciate the absence of bugs, the slow but steady improvement in stability,
+or the reliability of a release process. But those things distinguish a good
+project from a great one.
+"""
+
+	[Rules.bdfl]
+
+		title = "The Benevolent dictator for life (BDFL)"
+
+		text = """
+Docker follows the timeless, highly efficient and totally unfair system
+known as [Benevolent dictator for
+life](http://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life), with
+yours truly, Solomon Hykes, in the role of BDFL. This means that all
+decisions are made, by default, by Solomon. Since making every decision
+myself would be highly un-scalable, in practice decisions are spread
+across multiple maintainers.
+
+Ideally, the BDFL role is like the Queen of England: awesome crown, but not
+an actual operational role day-to-day. The real job of a BDFL is to NEVER GO AWAY.
+Every other rule can change, perhaps drastically so, but the BDFL will always
+be there, preserving the philosophy and principles of the project, and keeping
+ultimate authority over its fate. This gives us great flexibility in experimenting
+with various governance models, knowing that we can always press the "reset" button
+without fear of fragmentation or deadlock. See the US congress for a counter-example.
+
+BDFL daily routine:
+
+* Is the project governance stuck in a deadlock or irreversibly fragmented?
+	* If yes: refactor the project governance
+* Are there issues or conflicts escalated by core?
+	* If yes: resolve them
+* Go back to polishing that crown.
+"""
+
+	[Rules.decisions]
+
+		title = "How are decisions made?"
+
+		text = """
+Short answer: EVERYTHING IS A PULL REQUEST.
+
+Docker is an open-source project with an open design philosophy. This
+means that the repository is the source of truth for EVERY aspect of the
+project, including its philosophy, design, road map, and APIs. *If it's
+part of the project, it's in the repo. If it's in the repo, it's part of
+the project.*
+
+As a result, all decisions can be expressed as changes to the
+repository. An implementation change is a change to the source code. An
+API change is a change to the API specification. A philosophy change is
+a change to the philosophy manifesto, and so on.
+
+All decisions affecting Docker, big and small, follow the same 3 steps:
+
+* Step 1: Open a pull request. Anyone can do this.
+
+* Step 2: Discuss the pull request. Anyone can do this.
+
+* Step 3: Merge or refuse the pull request. Who does this depends on the nature
+of the pull request and which areas of the project it affects. See *review flow*
+for details.
+
+Because Docker is such a large and active project, it's important for everyone to know
+who is responsible for deciding what. That is determined by a precise set of rules.
+
+* For every *decision* in the project, the rules should designate, in a deterministic way,
+who should *decide*.
+
+* For every *problem* in the project, the rules should designate, in a deterministic way,
+who should be responsible for *fixing* it.
+
+* For every *question* in the project, the rules should designate, in a deterministic way,
+who should be expected to have the *answer*.
+"""
+
+	[Rules.review]
+
+		title = "Review flow"
+
+		text = """
+Pull requests should be processed according to the following flow:
+
+* For each subsystem affected by the change, the maintainers of the subsystem must approve or refuse it.
+It is the responsibility of the subsystem maintainers to process patches affecting them in a timely
+manner.
+
+* If the change affects areas of the code which are not part of a subsystem,
+or if subsystem maintainers are unable to reach a timely decision, it must be approved by 
+the core maintainers.
+
+* If the change affects the UI or public APIs, or if it represents a major change in architecture,
+the architects must approve or refuse it.
+
+* If the change affects the operations of the project, it must be approved or rejected by
+the relevant operators.
+
+* If the change affects the governance, philosophy, goals or principles of the project,
+it must be approved by BDFL.
+
+* A pull request can be in 1 of 5 distinct states, for each of which there is a corresponding label
+that needs to be applied. `Rules.review.states` contains the list of states with possible targets
+for each.
+"""
+
+		# Triage
+		[Rules.review.states.0-triage]
+
+			# Maintainers are expected to triage new incoming pull requests by removing
+			# the `0-triage` label and adding the correct labels (e.g. `1-design-review`)
+			# potentially skipping some steps depending on the kind of pull request.
+			# Use common sense for judging.
+			#
+			# Checking for DCO should be done at this stage.
+			#
+			# If an owner, responsible for closing or merging, can be assigned to the PR,
+			# the better.
+
+			close = "e.g. unresponsive contributor without DCO"
+			3-docs-review = "non-proposal documentation-only change"
+			2-code-review = "e.g. trivial bugfix"
+			1-design-review = "general case"
+
+		# Design review
+		[Rules.review.states.1-design-review]
+
+			# Maintainers are expected to comment on the design of the pull request.
+			# Review of documentation is expected only in the context of design validation,
+			# not for stylistic changes.
+			#
+			# Ideally, documentation should reflect the expected behavior of the code.
+			# No code review should take place in this step.
+			#
+			# Once design is approved, a maintainer should make sure to remove this label
+			# and add the next one.
+
+			close = "design rejected"
+			3-docs-review = "proposals with only documentation changes"
+			2-code-review = "general case"
+
+		# Code review
+		[Rules.review.states.2-code-review]
+
+			# Maintainers are expected to review the code and ensure that it is good
+			# quality and in accordance with the documentation in the PR.
+			#
+			# If documentation is absent but expected, maintainers should ask for documentation.
+			#
+			# All tests should pass.
+			#
+			# Once code is approved according to the rules of the subsystem, a maintainer
+			# should make sure to remove this label and add the next one.
+
+			close = ""
+			1-design-review = "raises design concerns"
+			4-merge = "trivial change not impacting documentation"
+			3-docs-review = "general case"
+
+		# Docs review
+		[Rules.review.states.3-docs-review]
+
+			# Maintainers are expected to review the documentation in its bigger context,
+			# ensuring consistency, completeness, validity, and breadth of coverage across
+			# all extent and new documentation.
+			#
+			# They should ask for any editorial change that makes the documentation more
+			# consistent and easier to understand.
+			#
+			# Once documentation is approved (see below), a maintainer should make sure to remove this
+			# label and add the next one.
+
+			close = ""
+			2-code-review = "requires more code changes"
+			1-design-review = "raises design concerns"
+			4-merge = "general case"
+			
+		# Docs approval
+		[Rules.review.docs-approval]
+			# Changes and additions to docs must be reviewed and approved (LGTM'd) by a minimum of two docs sub-project maintainers.
+			# If the docs change originates with a docs maintainer, only one additional LGTM is required (since we assume a docs maintainer approves of their own PR). 	
+
+		# Merge
+		[Rules.review.states.4-merge]
+
+			# Maintainers are expected to merge this pull request as soon as possible.
+			# They can ask for a rebase, or carry the pull request themselves.
+			# These should be the easy PRs to merge.
+
+			close = "carry PR"
+			merge = ""
+
+	[Rules.DCO]
+
+	title = "Helping contributors with the DCO"
+
+	text = """
+The [DCO or `Sign your work`](
+https://github.com/docker/docker/blob/master/CONTRIBUTING.md#sign-your-work)
+requirement is not intended as a roadblock or speed bump.
+
+Some Docker contributors are not as familiar with `git`, or have used a web based
+editor, and thus asking them to `git commit --amend -s` is not the best way forward.
+
+In this case, maintainers can update the commits based on clause (c) of the DCO. The
+most trivial way for a contributor to allow the maintainer to do this, is to add
+a DCO signature in a Pull Requests's comment, or a maintainer can simply note that
+the change is sufficiently trivial that it does not substantivly change the existing
+contribution - i.e., a spelling change.
+
+When you add someone's DCO, please also add your own to keep a log.
+"""
+
+	[Rules.holiday]
+
+	title = "I'm a maintainer, and I'm going on holiday"
+
+	text = """
+Please let your co-maintainers and other contributors know by raising a pull
+request that comments out your `MAINTAINERS` file entry using a `#`.
+"""
+
+	[Rules."no direct push"]
+
+	title = "I'm a maintainer. Should I make pull requests too?"
+
+	text = """
+Yes. Nobody should ever push to master directly. All changes should be
+made through a pull request.
+"""
+
+	[Rules.meta]
+
+	title = "How is this process changed?"
+
+	text = "Just like everything else: by making a pull request :)"
+
+# Current project organization
 [Org]

+	bdfl = "shykes"
+
+	# The chief architect is responsible for the overall integrity of the technical architecture
+	# across all subsystems, and the consistency of APIs and UI.
+	# 
+	# Changes to UI, public APIs and overall architecture (for example a plugin system) must
+	# be approved by the chief architect.
+	"Chief Architect" = "shykes"
+
+	# The Chief Operator is responsible for the day-to-day operations of the project including:
+	# - facilitating communications amongst all the contributors;
+	# - tracking release schedules;
+	# - managing the relationship with downstream distributions and upstream dependencies;
+	# - helping new contributors to get involved and become successful contributors and maintainers
+	#
+	# The role is also responsible for managing and measuring the success of the overall project
+	# and ensuring it is governed properly working in concert with the Docker Governance Advisory Board (DGAB).
+	"Chief Operator" = "spf13"
+
+	[Org.Operators]
+
+	# The operators make sure the trains run on time. They are responsible for overall operations
+	# of the project. This includes facilitating communication between all the participants; helping
+	# newcomers get involved and become successful contributors and maintainers; tracking the schedule
+	# of releases; managing the relationship with downstream distributions and upstream dependencies;
+	# define measures of success for the project and measure progress; Devise and implement tools and
+	# processes which make contributors and maintainers happier and more efficient.
+
+
+		[Org.Operators.security]
+
+			people = [
+				"erw"
+			]
+
+		[Org.Operators."monthly meetings"]
+
+			people = [
+				"sven",
+				"tianon"
+			]
+
+		[Org.Operators.infrastructure]
+
+			people = [
+				"jfrazelle",
+				"crosbymichael"
+			]
+
+	# The chief maintainer is responsible for all aspects of quality for the project including
+	# code reviews, usability, stability, security, performance, etc. 
+	# The most important function of the chief maintainer is to lead by example. On the first
+	# day of a new maintainer, the best advice should be "follow the C.M.'s example and you'll
+	# be fine".
+	"Chief Maintainer" = "crosbymichael"
+
 	[Org."Core maintainers"]

 	# The Core maintainers are the ghostbusters of the project: when there's a problem others
@@ -24,119 +333,150 @@
 	# For each release (including minor releases), a "release captain" is assigned from the
 	# pool of core maintainers. Rotation is encouraged across all maintainers, to ensure
 	# the release process is clear and up-to-date.
+	#
+	# It is common for core maintainers to "branch out" to join or start a subsystem.
+
+

 		people = [
-			"aaronlehmann",
-			"calavera",
-			"coolljt0725",
-			"cpuguy83",
+			"unclejack",
 			"crosbymichael",
-			"duglin",
+			"erikh",
 			"estesp",
 			"icecrime",
-			"jhowardmsft",
-			"justincormack",
-			"lk4d4",
-			"mavenugo",
-			"mhbauer",
-			"runcom",
-			"tianon",
-			"tibor",
-			"tonistiigi",
-			"unclejack",
-			"vdemeester"
-		]
-
-	[Org."Docs maintainers"]
-
-	# TODO Describe the docs maintainers role.
-
-		people = [
-			"jamtur01",
-			"moxiegirl",
-			"sven",
-			"thajeztah"
-		]
-
-	[Org.Curators]
-
-	# The curators help ensure that incoming issues and pull requests are properly triaged and
-	# that our various contribution and reviewing processes are respected. With their knowledge of
-	# the repository activity, they can also guide contributors to relevant material or
-	# discussions.
-	#
-	# They are neither code nor docs reviewers, so they are never expected to merge. They can
-	# however:
-	# - close an issue or pull request when it's an exact duplicate
-	# - close an issue or pull request when it's inappropriate or off-topic
-
-		people = [
-			"programmerq",
-			"thajeztah"
-		]
-
-	[Org.Alumni]
-
-	# This list contains maintainers that are no longer active on the project.
-	# It is thanks to these people that the project has become what it is today.
-	# Thank you!
-
-		people = [
-			# As a maintainer, Erik was responsible for the "builder", and
-			# started the first designs for the new networking model in
-			# Docker. Erik is now working on all kinds of plugins for Docker
-			# (https://github.com/contiv) and various open source projects
-			# in his own repository https://github.com/erikh. You may
-			# still stumble into him in our issue tracker, or on IRC.
-			"erikh",
-
-			# Jessica Frazelle, also known as the "Keyser Söze of containers",
-			# runs *everything* in containers. She started contributing to
-			# Docker with a (fun fun) change involving both iptables and regular
-			# expressions (coz, YOLO!) on July 10, 2014
-			# https://github.com/docker/docker/pull/6950/commits/f3a68ffa390fb851115c77783fa4031f1d3b2995.
-			# Jess was Release Captain for Docker 1.4, 1.6 and 1.7, and contributed
-			# many features and improvement, among which "seccomp profiles" (making 
-			# containers a lot more secure). Besides being a maintainer, she
-			# set up the CI infrastructure for the project, giving everyone
-			# something to shout at if a PR failed ("noooo Janky!").
-			# Jess is currently working on the DCOS security team at Mesosphere,
-			# and contributing to various open source projects.
-			# Be sure you don't miss her talks at a conference near you (a must-see),
-			# read her blog at https://blog.jessfraz.com (a must-read), and
-			# check out her open source projects on GitHub https://github.com/jfrazelle (a must-try).
 			"jfrazelle",
-
-			# Vincent "vbatts!" Batts made his first contribution to the project
-			# in November 2013, to become a maintainer a few months later, on 
-			# May 10, 2014 (https://github.com/docker/docker/commit/d6e666a87a01a5634c250358a94c814bf26cb778).
-			# As a maintainer, Vincent made important contributions to core elements
-			# of Docker, such as "distribution" (tarsum) and graphdrivers (btrfs, devicemapper).
-			# He also contributed the "tar-split" library, an important element
-			# for the content-addressable store.
-			# Vincent is currently a member of the Open Containers Initiative
-			# Technical Oversight Board (TOB), besides his work at Red Hat and
-			# Project Atomic. You can still find him regularly hanging out in
-			# our repository and the #docker-dev and #docker-maintainers IRC channels
-			# for a chat, as he's always a lot of fun.
+			"lk4d4",
+			"tibor",
 			"vbatts",
-
-			# Victor is one of the earliest contributors to Docker, having worked on the
-			# project when it was still "dotCloud" in April 2013. He's been responsible
-			# for multiple releases (https://github.com/docker/docker/pulls?q=is%3Apr+bump+in%3Atitle+author%3Avieux),
-			# and up until today (2015), our number 2 contributor. Although he's no longer
-			# a maintainer for the Docker "Engine", he's still actively involved in other
-			# Docker projects, and most likely can be found in the Docker Swarm repository,
-			# for which he's a core maintainer.
 			"vieux",
-
-			# Vishnu became a maintainer to help out on the daemon codebase and
-			# libcontainer integration. He's currently involved in the
-			# Open Containers Initiative, working on the specifications,
-			# besides his work on cAdvisor and Kubernetes for Google.
 			"vishh"
 		]

+
+	[Org.Subsystems]
+
+	# As the project grows, it gets separated into well-defined subsystems. Each subsystem
+	# has a dedicated group of maintainers, which are dedicated to that subsytem and responsible
+	# for its quality.
+	# This "cellular division" is the primary mechanism for scaling maintenance of the project as it grows.
+	# 
+	# The maintainers of each subsytem are responsible for:
+	# 
+	# 1. Exposing a clear road map for improving their subsystem.
+	# 2. Deliver prompt feedback and decisions on pull requests affecting their subsystem.
+	# 3. Be available to anyone with questions, bug reports, criticism etc.
+	#   on their component. This includes IRC, GitHub requests and the mailing
+	#   list.
+	# 4. Make sure their subsystem respects the philosophy, design and
+	#   road map of the project.
+	#
+	# #### How to review patches to your subsystem
+	# 
+	# Accepting pull requests:
+	# 
+	#   - If the pull request appears to be ready to merge, give it a `LGTM`, which
+	#     stands for "Looks Good To Me".
+	#   - If the pull request has some small problems that need to be changed, make
+	#     a comment adressing the issues.
+	#   - If the changes needed to a PR are small, you can add a "LGTM once the
+	#     following comments are adressed..." this will reduce needless back and
+	#     forth.
+	#   - If the PR only needs a few changes before being merged, any MAINTAINER can
+	#     make a replacement PR that incorporates the existing commits and fixes the
+	#     problems before a fast track merge.
+	# 
+	# Closing pull requests:
+	# 
+	#   - If a PR appears to be abandoned, after having attempted to contact the
+	#     original contributor, then a replacement PR may be made.  Once the
+	#     replacement PR is made, any contributor may close the original one.
+	#   - If you are not sure if the pull request implements a good feature or you
+	#     do not understand the purpose of the PR, ask the contributor to provide
+	#     more documentation.  If the contributor is not able to adequately explain
+	#     the purpose of the PR, the PR may be closed by any MAINTAINER.
+	#   - If a MAINTAINER feels that the pull request is sufficiently architecturally
+	#     flawed, or if the pull request needs significantly more design discussion
+	#     before being considered, the MAINTAINER should close the pull request with
+	#     a short explanation of what discussion still needs to be had.  It is
+	#     important not to leave such pull requests open, as this will waste both the
+	#     MAINTAINER's time and the contributor's time.  It is not good to string a
+	#     contributor on for weeks or months, having them make many changes to a PR
+	#     that will eventually be rejected.
+
+		[Org.Subsystems.Documentation]
+
+			people = [
+				"fredlf",
+				"james",
+				"sven",
+				"spf13",
+				"mary"
+			]
+
+		[Org.Subsystems.libcontainer]
+
+			people = [
+				"crosbymichael",
+				"vmarmol",
+				"mpatel",
+				"jnagal",
+				"lk4d4"
+			]
+
+		[Org.Subsystems.registry]
+
+			people = [
+				"dmp42",
+				"vbatts",
+				"joffrey",
+				"samalba",
+				"sday",
+				"jlhawn",
+				"dmcg"
+			]
+
+		[Org.Subsystems."build tools"]
+
+			people = [
+				"shykes",
+				"tianon"
+			]
+
+		[Org.Subsystem."remote api"]
+
+			people = [
+				"vieux"
+			]
+
+		[Org.Subsystem.swarm]
+
+			people = [
+				"aluzzardi",
+				"vieux"
+			]
+
+		[Org.Subsystem.machine]
+
+			people = [
+				"bfirsh",
+				"ehazlett"
+			]
+
+		[Org.Subsystem.compose]
+
+			people = [
+				"aanand"
+			]
+
+		[Org.Subsystem.builder]
+
+			people = [
+				"erikh",
+				"tibor",
+				"duglin"
+			]
+
+
 [people]

 # A reference list of all people associated with the project.
@@ -145,25 +485,20 @@

 	# ADD YOURSELF HERE IN ALPHABETICAL ORDER

-	[people.aaronlehmann]
-	Name = "Aaron Lehmann"
-	Email = "aaron.lehmann@docker.com"
-	GitHub = "aaronlehmann"
+	[people.aanand]
+	Name = "Aanand Prasad"
+	Email = "aanand@docker.com"
+	GitHub = "aanand"

-	[people.calavera]
-	Name = "David Calavera"
-	Email = "david.calavera@gmail.com"
-	GitHub = "calavera"
+	[people.aluzzardi]
+	Name = "Andrea Luzzardi"
+	Email = "aluzzardi@docker.com"
+	GitHub = "aluzzardi"

-	[people.coolljt0725]
-	Name = "Lei Jitang"
-	Email = "leijitang@huawei.com"
-	GitHub = "coolljt0725"
-
-	[people.cpuguy83]
-	Name = "Brian Goff"
-	Email = "cpuguy83@gmail.com"
-	Github = "cpuguy83"
+	[people.bfirsh]
+	Name = "Ben Firshman"
+	Email = "ben@firshman.co.uk"
+	GitHub = "bfirsh"

 	[people.crosbymichael]
 	Name = "Michael Crosby"
@@ -175,86 +510,91 @@
 	Email = "dug@us.ibm.com"
 	GitHub = "duglin"

+	[people.dmcg]
+	Name = "Derek McGowan"
+	Email = "derek@docker.com"
+	Github = "dmcgowan"
+
+	[people.dmp42]
+	Name = "Olivier Gambier"
+	Email = "olivier@docker.com"
+	Github = "dmp42"
+
+	[people.ehazlett]
+	Name = "Evan Hazlett"
+	Email = "ejhazlett@gmail.com"
+	GitHub = "ehazlett"
+
 	[people.erikh]
 	Name = "Erik Hollensbe"
 	Email = "erik@docker.com"
 	GitHub = "erikh"

+	[people.erw]
+	Name = "Eric Windisch"
+	Email = "eric@windisch.us"
+	GitHub = "ewindisch"
+
 	[people.estesp]
 	Name = "Phil Estes"
 	Email = "estesp@linux.vnet.ibm.com"
 	GitHub = "estesp"

+	[people.fredlf]
+	Name = "Fred Lifton"
+	Email = "fred.lifton@docker.com"
+	GitHub = "fredlf"
+
 	[people.icecrime]
 	Name = "Arnaud Porterie"
 	Email = "arnaud@docker.com"
 	GitHub = "icecrime"

-	[people.jamtur01]
-	Name = "James Turnbull"
-	Email = "james@lovedthanlost.net"
-	GitHub = "jamtur01"
-
-	[people.jhowardmsft]
-	Name = "John Howard"
-	Email = "jhoward@microsoft.com"
-	GitHub = "jhowardmsft"
-
 	[people.jfrazelle]
 	Name = "Jessie Frazelle"
-	Email = "jess@linux.com"
+	Email = "jess@docker.com"
 	GitHub = "jfrazelle"

-	[people.justincormack]
-	Name = "Justin Cormack"
-	Email = "justin.cormack@docker.com"
-	GitHub = "justincormack"
+	[people.jlhawn]
+	Name = "Josh Hawn"
+	Email = "josh.hawn@docker.com"
+	Github = "jlhawn"
+
+	[people.joffrey]
+	Name = "Joffrey Fuhrer"
+	Email = "joffrey@docker.com"
+	Github = "shin-"

 	[people.lk4d4]
 	Name = "Alexander Morozov"
 	Email = "lk4d4@docker.com"
 	GitHub = "lk4d4"

-	[people.mavenugo]
-	Name = "Madhu Venugopal"
-	Email = "madhu@docker.com"
-	GitHub = "mavenugo"
-
-	[people.mhbauer]
-	Name = "Morgan Bauer"
-	Email = "mbauer@us.ibm.com"
-	GitHub = "mhbauer"
-
-	[people.moxiegirl]
+	[people.mary]
 	Name = "Mary Anthony"
 	Email = "mary.anthony@docker.com"
 	GitHub = "moxiegirl"

-	[people.programmerq]
-	Name = "Jeff Anderson"
-	Email = "jeff@docker.com"
-	GitHub = "programmerq"
-
-	[people.runcom]
-	Name = "Antonio Murdaca"
-	Email = "runcom@redhat.com"
-	GitHub = "runcom"
+	[people.sday]
+	Name = "Stephen Day"
+	Email = "stephen.day@docker.com"
+	Github = "stevvooe"

 	[people.shykes]
 	Name = "Solomon Hykes"
 	Email = "solomon@docker.com"
 	GitHub = "shykes"
-
+    
+	[people.spf13]
+	Name = "Steve Francia"
+	Email = "steve.francia@gmail.com"
+	GitHub = "spf13"
+	
 	[people.sven]
 	Name = "Sven Dowideit"
 	Email = "SvenDowideit@home.org.au"
 	GitHub = "SvenDowideit"

-	[people.thajeztah]
-	Name = "Sebastiaan van Stijn"
-	Email = "github@gone.nl"
-	GitHub = "thaJeztah"
-
 	[people.tianon]
 	Name = "Tianon Gravi"
 	Email = "admwiggin@gmail.com"
@@ -265,31 +605,36 @@
 	Email = "tibor@docker.com"
 	GitHub = "tiborvass"

-	[people.tonistiigi]
-	Name = "Tõnis Tiigi"
-	Email = "tonis@docker.com"
-	GitHub = "tonistiigi"
-
-	[people.unclejack]
-	Name = "Cristian Staretu"
-	Email = "cristian.staretu@gmail.com"
-	GitHub = "unclejack"
-
 	[people.vbatts]
 	Name = "Vincent Batts"
 	Email = "vbatts@redhat.com"
 	GitHub = "vbatts"

-	[people.vdemeester]
-	Name = "Vincent Demeester"
-	Email = "vincent@sbr.pm"
-	GitHub = "vdemeester"
-
 	[people.vieux]
 	Name = "Victor Vieux"
 	Email = "vieux@docker.com"
 	GitHub = "vieux"

+	[people.vmarmol]
+	Name = "Victor Marmol"
+	Email = "vmarmol@google.com"
+	GitHub = "vmarmol"
+
+	[people.jnagal]
+	Name = "Rohit Jnagal"
+	Email = "jnagal@google.com"
+	GitHub = "rjnagal"
+
+	[people.mpatel]
+	Name = "Mrunal Patel"
+	Email = "mpatel@redhat.com"
+	GitHub = "mrunalp"
+
+	[people.unclejack]
+	Name = "Cristian Staretu"
+	Email = "cristian.staretu@gmail.com"
+	GitHub = "unclejack"
+
 	[people.vishh]
 	Name = "Vishnu Kannan"
 	Email = "vishnuk@google.com"
--- a/159
+++ b/159
@@ -1,28 +1,13 @@
-.PHONY: all binary build build-gccgo cross default docs docs-build docs-shell shell gccgo test test-docker-py test-integration-cli test-unit validate help
-
-# set the graph driver as the current graphdriver if not set
-DOCKER_GRAPHDRIVER := $(if $(DOCKER_GRAPHDRIVER),$(DOCKER_GRAPHDRIVER),$(shell docker info 2>&1 | grep "Storage Driver" | sed 's/.*: //'))
-
-# get OS/Arch of docker engine
-DOCKER_OSARCH := $(shell bash -c 'source hack/make/.detect-daemon-osarch && echo $${DOCKER_ENGINE_OSARCH:-$$DOCKER_CLIENT_OSARCH}')
-DOCKERFILE := $(shell bash -c 'source hack/make/.detect-daemon-osarch && echo $${DOCKERFILE}')
+.PHONY: all binary build cross default docs docs-build docs-shell shell test test-unit test-integration test-integration-cli test-docker-py validate

 # env vars passed through directly to Docker's build scripts
-# to allow things like `make KEEPBUNDLE=1 binary` easily
+# to allow things like `make DOCKER_CLIENTONLY=1 binary` easily
 # `docs/sources/contributing/devenvironment.md ` and `project/PACKAGERS.md` have some limited documentation of some of these
 DOCKER_ENVS := \
 	-e BUILDFLAGS \
-	-e KEEPBUNDLE \
-	-e DOCKER_BUILD_GOGC \
-	-e DOCKER_BUILD_PKGS \
-	-e DOCKER_DEBUG \
-	-e DOCKER_EXPERIMENTAL \
-	-e DOCKER_GITCOMMIT \
-	-e DOCKER_GRAPHDRIVER=$(DOCKER_GRAPHDRIVER) \
-	-e DOCKER_INCREMENTAL_BINARY \
-	-e DOCKER_REMAP_ROOT \
-	-e DOCKER_STORAGE_OPTS \
-	-e DOCKER_USERLANDPROXY \
+	-e DOCKER_CLIENTONLY \
+	-e DOCKER_EXECDRIVER \
+	-e DOCKER_GRAPHDRIVER \
 	-e TESTDIRS \
 	-e TESTFLAGS \
 	-e TIMEOUT
@@ -34,93 +19,79 @@ DOCKER_ENVS := \
 BIND_DIR := $(if $(BINDDIR),$(BINDDIR),$(if $(DOCKER_HOST),,bundles))
 DOCKER_MOUNT := $(if $(BIND_DIR),-v "$(CURDIR)/$(BIND_DIR):/go/src/github.com/docker/docker/$(BIND_DIR)")

-# This allows the test suite to be able to run without worrying about the underlying fs used by the container running the daemon (e.g. aufs-on-aufs), so long as the host running the container is running a supported fs.
-# The volume will be cleaned up when the container is removed due to `--rm`.
-# Note that `BIND_DIR` will already be set to `bundles` if `DOCKER_HOST` is not set (see above BIND_DIR line), in such case this will do nothing since `DOCKER_MOUNT` will already be set.
-DOCKER_MOUNT := $(if $(DOCKER_MOUNT),$(DOCKER_MOUNT),-v "/go/src/github.com/docker/docker/bundles")
+# to allow `make DOCSDIR=docs docs-shell` (to create a bind mount in docs)
+DOCS_MOUNT := $(if $(DOCSDIR),-v $(CURDIR)/$(DOCSDIR):/$(DOCSDIR))
+
+# to allow `make DOCSPORT=9000 docs`
+DOCSPORT := 8000

 GIT_BRANCH := $(shell git rev-parse --abbrev-ref HEAD 2>/dev/null)
-GIT_BRANCH_CLEAN := $(shell echo $(GIT_BRANCH) | sed -e "s/[^[:alnum:]]/-/g")
-DOCKER_IMAGE := docker-dev$(if $(GIT_BRANCH_CLEAN),:$(GIT_BRANCH_CLEAN))
-DOCKER_DOCS_IMAGE := docker-docs$(if $(GIT_BRANCH_CLEAN),:$(GIT_BRANCH_CLEAN))
+DOCKER_IMAGE := docker$(if $(GIT_BRANCH),:$(GIT_BRANCH))
+DOCKER_DOCS_IMAGE := docker-docs$(if $(GIT_BRANCH),:$(GIT_BRANCH))

-DOCKER_FLAGS := docker run --rm -i --privileged $(DOCKER_ENVS) $(DOCKER_MOUNT)
+DOCKER_RUN_DOCKER := docker run --rm -it --privileged $(DOCKER_ENVS) $(DOCKER_MOUNT) "$(DOCKER_IMAGE)"

-# if this session isn't interactive, then we don't want to allocate a
-# TTY, which would fail, but if it is interactive, we do want to attach
-# so that the user can send e.g. ^C through.
-INTERACTIVE := $(shell [ -t 0 ] && echo 1 || echo 0)
-ifeq ($(INTERACTIVE), 1)
-	DOCKER_FLAGS += -t
-endif
+DOCKER_RUN_DOCS := docker run --rm -it $(DOCS_MOUNT) -e AWS_S3_BUCKET -e NOCACHE

-DOCKER_RUN_DOCKER := $(DOCKER_FLAGS) "$(DOCKER_IMAGE)"
+# for some docs workarounds (see below in "docs-build" target)
+GITCOMMIT := $(shell git rev-parse --short HEAD 2>/dev/null)

 default: binary

-all: build ## validate all checks, build linux binaries, run all tests\ncross build non-linux binaries and generate archives
+all: build
 	$(DOCKER_RUN_DOCKER) hack/make.sh

-binary: build ## build the linux binaries
+binary: build
 	$(DOCKER_RUN_DOCKER) hack/make.sh binary

-build: bundles
-	docker build ${DOCKER_BUILD_ARGS} -t "$(DOCKER_IMAGE)" -f "$(DOCKERFILE)" .
+cross: build
+	$(DOCKER_RUN_DOCKER) hack/make.sh binary cross

-build-gccgo: bundles
-	docker build ${DOCKER_BUILD_ARGS} -t "$(DOCKER_IMAGE)-gccgo" -f Dockerfile.gccgo .
+docs: docs-build
+	$(DOCKER_RUN_DOCS) -p $(if $(DOCSPORT),$(DOCSPORT):)8000 "$(DOCKER_DOCS_IMAGE)" mkdocs serve
+
+docs-shell: docs-build
+	$(DOCKER_RUN_DOCS) -p $(if $(DOCSPORT),$(DOCSPORT):)8000 "$(DOCKER_DOCS_IMAGE)" bash
+
+docs-release: docs-build
+	$(DOCKER_RUN_DOCS) -e OPTIONS -e BUILD_ROOT -e DISTRIBUTION_ID \
+		-v $(CURDIR)/docs/awsconfig:/docs/awsconfig \
+		"$(DOCKER_DOCS_IMAGE)" ./release.sh
+
+docs-test: docs-build
+	$(DOCKER_RUN_DOCS) "$(DOCKER_DOCS_IMAGE)" ./test.sh
+
+test: build
+	$(DOCKER_RUN_DOCKER) hack/make.sh binary cross test-unit test-integration test-integration-cli test-docker-py
+
+test-unit: build
+	$(DOCKER_RUN_DOCKER) hack/make.sh test-unit
+
+test-integration: build
+	$(DOCKER_RUN_DOCKER) hack/make.sh test-integration
+
+test-integration-cli: build
+	$(DOCKER_RUN_DOCKER) hack/make.sh binary test-integration-cli
+
+test-docker-py: build
+	$(DOCKER_RUN_DOCKER) hack/make.sh binary test-docker-py
+
+validate: build
+	$(DOCKER_RUN_DOCKER) hack/make.sh validate-gofmt validate-dco validate-toml
+
+shell: build
+	$(DOCKER_RUN_DOCKER) bash
+
+build: bundles
+	docker build -t "$(DOCKER_IMAGE)" .
+
+docs-build:
+	cp ./VERSION docs/VERSION
+	echo "$(GIT_BRANCH)" > docs/GIT_BRANCH
+#	echo "$(AWS_S3_BUCKET)" > docs/AWS_S3_BUCKET
+	echo "$(GITCOMMIT)" > docs/GITCOMMIT
+	docker pull docs/base
+	docker build -t "$(DOCKER_DOCS_IMAGE)" docs

 bundles:
 	mkdir bundles
-
-cross: build ## cross build the binaries for darwin, freebsd and\nwindows
-	$(DOCKER_RUN_DOCKER) hack/make.sh dynbinary binary cross
-
-win: build ## cross build the binary for windows
-	$(DOCKER_RUN_DOCKER) hack/make.sh win
-
-tgz: build ## build the archives (.zip on windows and .tgz\notherwise) containing the binaries
-	$(DOCKER_RUN_DOCKER) hack/make.sh dynbinary binary cross tgz
-
-deb: build  ## build the deb packages
-	$(DOCKER_RUN_DOCKER) hack/make.sh dynbinary build-deb
-
-docs: ## build the docs
-	$(MAKE) -C docs docs
-
-gccgo: build-gccgo ## build the gcc-go linux binaries
-	$(DOCKER_FLAGS) "$(DOCKER_IMAGE)-gccgo" hack/make.sh gccgo
-
-install: ## install the linux binaries
-	KEEPBUNDLE=1 hack/make.sh install-binary
-
-rpm: build ## build the rpm packages
-	$(DOCKER_RUN_DOCKER) hack/make.sh dynbinary build-rpm
-
-shell: build ## start a shell inside the build env
-	$(DOCKER_RUN_DOCKER) bash
-
-test: build ## run the unit, integration and docker-py tests
-	$(DOCKER_RUN_DOCKER) hack/make.sh dynbinary cross test-unit test-integration-cli test-docker-py
-
-test-docker-py: build ## run the docker-py tests
-	$(DOCKER_RUN_DOCKER) hack/make.sh dynbinary test-docker-py
-
-test-integration-cli: build ## run the integration tests
-	$(DOCKER_RUN_DOCKER) hack/make.sh dynbinary test-integration-cli
-
-test-unit: build ## run the unit tests
-	$(DOCKER_RUN_DOCKER) hack/make.sh test-unit
-
-validate: build ## validate DCO, Seccomp profile generation, gofmt,\n./pkg/ isolation, golint, tests, tomls, go vet and vendor 
-	$(DOCKER_RUN_DOCKER) hack/make.sh validate-dco validate-default-seccomp validate-gofmt validate-pkg validate-lint validate-test validate-toml validate-vet validate-vendor
-
-manpages: ## Generate man pages from go source and markdown
-	docker build -t docker-manpage-dev -f "man/$(DOCKERFILE)" ./man
-	docker run \
-		-v $(PWD):/go/src/github.com/docker/docker/ \
-		docker-manpage-dev
-
-help: ## this help
-	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {sub("\\\\n",sprintf("\n%22c"," "), $$2);printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
-
--- a/12
+++ b/12
@@ -1,7 +1,7 @@
 Docker
-Copyright 2012-2016 Docker, Inc.
+Copyright 2012-2015 Docker, Inc.

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

 This product contains software (https://github.com/kr/pty) developed
 by Keith Rarick, licensed under the MIT License.
@@ -10,10 +10,10 @@ The following is courtesy of our legal counsel:


 Use and transfer of Docker may be subject to certain restrictions by the
-United States and other governments.
+United States and other governments.  
 It is your responsibility to ensure that your use and/or transfer does not
-violate applicable laws.
+violate applicable laws. 

-For more information, please see https://www.bis.doc.gov
+For more information, please see http://www.bis.doc.gov

-See also https://www.apache.org/dev/crypto.html and/or seek legal counsel.
+See also http://www.apache.org/dev/crypto.html and/or seek legal counsel.
--- a/README.md
+++ b/README.md
@@ -1,36 +1,36 @@
-Docker: the container engine [![Release](https://img.shields.io/github/release/docker/docker.svg)](https://github.com/docker/docker/releases/latest)
-============================
+Docker: the Linux container engine
+==================================

 Docker is an open source project to pack, ship and run any application
-as a lightweight container.
+as a lightweight container

 Docker containers are both *hardware-agnostic* and *platform-agnostic*.
 This means they can run anywhere, from your laptop to the largest
-cloud compute instance and everything in between - and they don't require
+EC2 compute instance and everything in between - and they don't require
 you to use a particular language, framework or packaging system. That
 makes them great building blocks for deploying and scaling web apps,
 databases, and backend services without depending on a particular stack
 or provider.

 Docker began as an open-source implementation of the deployment engine which
-powered [dotCloud](http://web.archive.org/web/20130530031104/https://www.dotcloud.com/),
-a popular Platform-as-a-Service. It benefits directly from the experience
-accumulated over several years of large-scale operation and support of hundreds
-of thousands of applications and databases.
+powers [dotCloud](http://dotcloud.com), a popular Platform-as-a-Service.
+It benefits directly from the experience accumulated over several years
+of large-scale operation and support of hundreds of thousands of
+applications and databases.

-![Docker logo](docs/static_files/docker-logo-compressed.png "Docker")
+![Docker L](docs/sources/static_files/docker-logo-compressed.png "Docker")

 ## Security Disclosure

-Security is very important to us. If you have any issue regarding security,
-please disclose the information responsibly by sending an email to
+Security is very important to us. If you have any issue regarding security, 
+please disclose the information responsibly by sending an email to 
 security@docker.com and not by creating a github issue.

 ## Better than VMs

 A common method for distributing applications and sandboxing their
 execution is to use virtual machines, or VMs. Typical VM formats are
-VMware's vmdk, Oracle VirtualBox's vdi, and Amazon EC2's ami. In theory
+VMWare's vmdk, Oracle Virtualbox's vdi, and Amazon EC2's ami. In theory
 these formats should allow every developer to automatically package
 their application into a "machine" for easy distribution and deployment.
 In practice, that almost never happens, for a few reasons:
@@ -56,12 +56,12 @@ By contrast, Docker relies on a different sandboxing method known as
 *containerization*. Unlike traditional virtualization, containerization
 takes place at the kernel level. Most modern operating system kernels
 now support the primitives necessary for containerization, including
-Linux with [openvz](https://openvz.org),
+Linux with [openvz](http://openvz.org),
 [vserver](http://linux-vserver.org) and more recently
-[lxc](https://linuxcontainers.org/), Solaris with
-[zones](https://docs.oracle.com/cd/E26502_01/html/E29024/preface-1.html#scrolltoc),
+[lxc](http://lxc.sourceforge.net), Solaris with
+[zones](http://docs.oracle.com/cd/E26502_01/html/E29024/preface-1.html#scrolltoc),
 and FreeBSD with
-[Jails](https://www.freebsd.org/doc/handbook/jails.html).
+[Jails](http://www.freebsd.org/doc/handbook/jails.html).

 Docker builds on top of these low-level primitives to offer developers a
 portable format and runtime environment that solves all four problems.
@@ -105,7 +105,7 @@ This is usually difficult for several reasons:
    these situations with various degrees of ease - but they all
    handle them in different and incompatible ways, which again forces
    the developer to do extra work.
-
+  
  * *Custom dependencies*. A developer may need to prepare a custom
    version of their application's dependency. Some packaging systems
    can handle custom versions of a dependency, others can't - and all
@@ -115,7 +115,7 @@ This is usually difficult for several reasons:
 Docker solves the problem of dependency hell by giving the developer a simple
 way to express *all* their application's dependencies in one place, while
 streamlining the process of assembling them. If this makes you think of
-[XKCD 927](https://xkcd.com/927/), don't worry. Docker doesn't
+[XKCD 927](http://xkcd.com/927/), don't worry. Docker doesn't
 *replace* your favorite packaging systems. It simply orchestrates
 their use in a simple and repeatable way. How does it do that? With
 layers.
@@ -143,19 +143,23 @@ as they can be built by running a Unix command in a container.
 Getting started
 ===============

-Docker can be installed either on your computer for building applications or
-on servers for running them. To get started, [check out the installation
-instructions in the
-documentation](https://docs.docker.com/engine/installation/).
+Docker can be installed on your local machine as well as servers - both
+bare metal and virtualized.  It is available as a binary on most modern
+Linux systems, or as a VM on Windows, Mac and other systems.
+
+We also offer an [interactive tutorial](http://www.docker.com/tryit/)
+for quickly learning the basics of using Docker.
+
+For up-to-date install instructions, see the [Docs](http://docs.docker.com).

 Usage examples
 ==============

 Docker can be used to run short-lived commands, long-running daemons
-(app servers, databases, etc.), interactive shell sessions, etc.
+(app servers, databases etc.), interactive shell sessions, etc.

 You can find a [list of real-world
-examples](https://docs.docker.com/engine/examples/) in the
+examples](http://docs.docker.com/examples/) in the
 documentation.

 Under the hood
@@ -164,23 +168,22 @@ Under the hood
 Under the hood, Docker is built on the following components:

 * The
-  [cgroups](https://www.kernel.org/doc/Documentation/cgroup-v1/cgroups.txt)
+  [cgroup](http://blog.dotcloud.com/kernel-secrets-from-the-paas-garage-part-24-c)
  and
-  [namespaces](http://man7.org/linux/man-pages/man7/namespaces.7.html)
-  capabilities of the Linux kernel
-* The [Go](https://golang.org) programming language
-* The [Docker Image Specification](https://github.com/docker/docker/blob/master/image/spec/v1.md)
-* The [Libcontainer Specification](https://github.com/opencontainers/runc/blob/master/libcontainer/SPEC.md)
+  [namespacing](http://blog.dotcloud.com/under-the-hood-linux-kernels-on-dotcloud-part)
+  capabilities of the Linux kernel;
+* The [Go](http://golang.org) programming language.
+* The [Docker Image Specification] (https://github.com/docker/docker/blob/master/image/spec/v1.md)
+* The [Libcontainer Specification] (https://github.com/docker/libcontainer/blob/master/SPEC.md)

-Contributing to Docker [![GoDoc](https://godoc.org/github.com/docker/docker?status.svg)](https://godoc.org/github.com/docker/docker)
+Contributing to Docker
 ======================

-| **Master** (Linux) | **Experimental** (linux) | **Windows** | **FreeBSD** |
-|------------------|----------------------|---------|---------|
-| [![Jenkins Build Status](https://jenkins.dockerproject.org/view/Docker/job/Docker%20Master/badge/icon)](https://jenkins.dockerproject.org/view/Docker/job/Docker%20Master/) | [![Jenkins Build Status](https://jenkins.dockerproject.org/view/Docker/job/Docker%20Master%20%28experimental%29/badge/icon)](https://jenkins.dockerproject.org/view/Docker/job/Docker%20Master%20%28experimental%29/) | [![Build Status](http://jenkins.dockerproject.org/job/Docker%20Master%20(windows)/badge/icon)](http://jenkins.dockerproject.org/job/Docker%20Master%20(windows)/) | [![Build Status](http://jenkins.dockerproject.org/job/Docker%20Master%20(freebsd)/badge/icon)](http://jenkins.dockerproject.org/job/Docker%20Master%20(freebsd)/) |
+[![GoDoc](https://godoc.org/github.com/docker/docker?status.png)](https://godoc.org/github.com/docker/docker)
+[![Jenkins Build Status](https://jenkins.dockerproject.com/job/Docker%20Master/badge/icon)](https://jenkins.dockerproject.com/job/Docker%20Master/)

 Want to hack on Docker? Awesome! We have [instructions to help you get
-started contributing code or documentation](https://docs.docker.com/opensource/project/who-written-for/).
+started contributing code or documentation.](https://docs.docker.com/project/who-written-for/).

 These instructions are probably not perfect, please let us know if anything
 feels wrong or incomplete. Better yet, submit a PR and improve them yourself.
@@ -188,13 +191,13 @@ feels wrong or incomplete. Better yet, submit a PR and improve them yourself.
 Getting the development builds
 ==============================

-Want to run Docker from a master build? You can download
-master builds at [master.dockerproject.org](https://master.dockerproject.org).
+Want to run Docker from a master build? You can download 
+master builds at [master.dockerproject.com](https://master.dockerproject.com). 
 They are updated with each commit merged into the master branch.

 Don't know how to use that super cool new feature in the master build? Check
 out the master docs at
-[docs.master.dockerproject.org](http://docs.master.dockerproject.org).
+[docs.master.dockerproject.com](http://docs.master.dockerproject.com).

 How the project is run
 ======================
@@ -204,73 +207,17 @@ or want to get more involved, the best place to start is [the project directory]

 We are always open to suggestions on process improvements, and are always looking for more maintainers.

-### Talking to other Docker users and contributors
-
-<table class="tg">
-  <col width="45%">
-  <col width="65%">
-  <tr>
-    <td>Internet&nbsp;Relay&nbsp;Chat&nbsp;(IRC)</td>
-    <td>
-      <p>
-        IRC is a direct line to our most knowledgeable Docker users; we have
-        both the  <code>#docker</code> and <code>#docker-dev</code> group on
-        <strong>irc.freenode.net</strong>.
-        IRC is a rich chat protocol but it can overwhelm new users. You can search
-        <a href="https://botbot.me/freenode/docker/#" target="_blank">our chat archives</a>.
-      </p>
-      Read our <a href="https://docs.docker.com/project/get-help/#irc-quickstart" target="_blank">IRC quickstart guide</a> for an easy way to get started.
-    </td>
-  </tr>
-  <tr>
-    <td>Docker Community Forums</td>
-    <td>
-      The <a href="https://forums.docker.com/c/open-source-projects/de" target="_blank">Docker Engine</a>
-      group is for users of the Docker Engine project.
-    </td>
-  </tr>
-  <tr>
-    <td>Google Groups</td>
-    <td>
-      The <a href="https://groups.google.com/forum/#!forum/docker-dev"
-      target="_blank">docker-dev</a> group is for contributors and other people
-      contributing to the Docker project.  You can join this group without a
-      Google account by sending an email to <a
-      href="mailto:docker-dev+subscribe@googlegroups.com">docker-dev+subscribe@googlegroups.com</a>.
-      You'll receive a join-request message; simply reply to the message to
-      confirm your subscribtion.
-    </td>
-  </tr>
-  <tr>
-    <td>Twitter</td>
-    <td>
-      You can follow <a href="https://twitter.com/docker/" target="_blank">Docker's Twitter feed</a>
-      to get updates on our products. You can also tweet us questions or just
-      share blogs or stories.
-    </td>
-  </tr>
-  <tr>
-    <td>Stack Overflow</td>
-    <td>
-      Stack Overflow has over 7000 Docker questions listed. We regularly
-      monitor <a href="https://stackoverflow.com/search?tab=newest&q=docker" target="_blank">Docker questions</a>
-      and so do many other knowledgeable Docker users.
-    </td>
-  </tr>
-</table>
-
 ### Legal

 *Brought to you courtesy of our legal counsel. For more context,
-please see the [NOTICE](https://github.com/docker/docker/blob/master/NOTICE) document in this repo.*
+please see the "NOTICE" document in this repo.*

 Use and transfer of Docker may be subject to certain restrictions by the
-United States and other governments.
-
+United States and other governments.  
 It is your responsibility to ensure that your use and/or transfer does not
-violate applicable laws.
+violate applicable laws. 

-For more information, please see https://www.bis.doc.gov
+For more information, please see http://www.bis.doc.gov


 Licensing
@@ -283,22 +230,17 @@ Other Docker Related Projects
 =============================
 There are a number of projects under development that are based on Docker's
 core technology. These projects expand the tooling built around the
-Docker platform to broaden its application and utility.
-
-* [Docker Registry](https://github.com/docker/distribution): Registry
-server for Docker (hosting/delivery of repositories and images)
-* [Docker Machine](https://github.com/docker/machine): Machine management
-for a container-centric world
-* [Docker Swarm](https://github.com/docker/swarm): A Docker-native clustering
-system
-* [Docker Compose](https://github.com/docker/compose) (formerly Fig):
-Define and run multi-container apps
-* [Kitematic](https://github.com/docker/kitematic): The easiest way to use
-Docker on Mac and Windows
+Docker platform to broaden its application and utility. 

 If you know of another project underway that should be listed here, please help
 us keep this list up-to-date by submitting a PR.

-Awesome-Docker
-==============
-You can find more projects, tools and articles related to Docker on the [awesome-docker list](https://github.com/veggiemonk/awesome-docker). Add your project there.
+* [Docker Registry](https://github.com/docker/distribution): Registry 
+server for Docker (hosting/delivery of repositories and images)
+* [Docker Machine](https://github.com/docker/machine): Machine management 
+for a container-centric world 
+* [Docker Swarm](https://github.com/docker/swarm): A Docker-native clustering 
+system 
+* [Docker Compose](https://github.com/docker/compose) (formerly Fig): 
+Define and run multi-container apps
+
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -1,140 +0,0 @@
-Docker Engine Roadmap
-=====================
-
-### How should I use this document?
-
-This document provides description of items that the project decided to prioritize. This should
-serve as a reference point for Docker contributors to understand where the project is going, and
-help determine if a contribution could be conflicting with some longer terms plans.
-
-The fact that a feature isn't listed here doesn't mean that a patch for it will automatically be
-refused (except for those mentioned as "frozen features" below)! We are always happy to receive
-patches for new cool features we haven't thought about, or didn't judge priority. Please however
-understand that such patches might take longer for us to review.
-
-### How can I help?
-
-Short term objectives are listed in the [wiki](https://github.com/docker/docker/wiki) and described
-in [Issues](https://github.com/docker/docker/issues?q=is%3Aopen+is%3Aissue+label%3Aroadmap). Our
-goal is to split down the workload in such way that anybody can jump in and help. Please comment on
-issues if you want to take it to avoid duplicating effort! Similarly, if a maintainer is already
-assigned on an issue you'd like to participate in, pinging him on IRC or GitHub to offer your help is
-the best way to go.
-
-### How can I add something to the roadmap?
-
-The roadmap process is new to the Docker Engine: we are only beginning to structure and document the
-project objectives. Our immediate goal is to be more transparent, and work with our community to
-focus our efforts on fewer prioritized topics.
-
-We hope to offer in the near future a process allowing anyone to propose a topic to the roadmap, but
-we are not quite there yet. For the time being, the BDFL remains the keeper of the roadmap, and we
-won't be accepting pull requests adding or removing items from this file.
-
-# 1. Features and refactoring
-
-## 1.1 Runtime improvements
-
-We recently introduced [`runC`](https://runc.io) as a standalone low-level tool for container
-execution. The initial goal was to integrate runC as a replacement in the Engine for the traditional
-default libcontainer `execdriver`, but the Engine internals were not ready for this.
-
-As runC continued evolving, and the OCI specification along with it, we created
-[`containerd`](https://containerd.tools/), a daemon to control and monitor multiple `runC`. This is
-the new target for Engine integration, as it can entirely replace the whole `execdriver`
-architecture, and container monitoring along with it.
-
-Docker Engine will rely on a long-running `containerd` companion daemon for all container execution
-related operations. This could open the door in the future for Engine restarts without interrupting
-running containers.
-
-## 1.2 Plugins improvements
-
-Docker Engine 1.7.0 introduced plugin support, initially for the use cases of volumes and networks
-extensions. The plugin infrastructure was kept minimal as we were collecting use cases and real
-world feedback before optimizing for any particular workflow.
-
-In the future, we'd like plugins to become first class citizens, and encourage an ecosystem of
-plugins. This implies in particular making it trivially easy to distribute plugins as containers
-through any Registry instance, as well as solving the commonly heard pain points of plugins needing
-to be treated as somewhat special (being active at all time, started before any other user
-containers, and not as easily dismissed).
-
-## 1.3 Internal decoupling
-
-A lot of work has been done in trying to decouple the Docker Engine's internals. In particular, the
-API implementation has been refactored and ongoing work is happening to move the code to a separate
-repository ([`docker/engine-api`](https://github.com/docker/engine-api)), and the Builder side of
-the daemon is now [fully independent](https://github.com/docker/docker/tree/master/builder) while
-still residing in the same repository.
-
-We are exploring ways to go further with that decoupling, capitalizing on the work introduced by the
-runtime renovation and plugins improvement efforts. Indeed, the combination of `containerd` support
-with the concept of "special" containers opens the door for bootstrapping more Engine internals
-using the same facilities.
-
-## 1.4 Cluster capable Engine
-
-The community has been pushing for a more cluster capable Docker Engine, and a huge effort was spent
-adding features such as multihost networking, and node discovery down at the Engine level. Yet, the
-Engine is currently incapable of taking scheduling decisions alone, and continues relying on Swarm
-for that.
-
-We plan to complete this effort and make Engine fully cluster capable. Multiple instances of the
-Docker Engine being already capable of discovering each other and establish overlay networking for
-their container to communicate, the next step is for a given Engine to gain ability to dispatch work
-to another node in the cluster. This will be introduced in a backward compatible way, such that a
-`docker run` invocation on a particular node remains fully deterministic.
-
-# 2 Frozen features
-
-## 2.1 Docker exec
-
-We won't accept patches expanding the surface of `docker exec`, which we intend to keep as a
-*debugging* feature, as well as being strongly dependent on the Runtime ingredient effort.
-
-## 2.2 Dockerfile syntax
-
-The Dockerfile syntax as we know it is simple, and has proven successful in supporting all our
-[official images](https://github.com/docker-library/official-images). Although this is *not* a
-definitive move, we temporarily won't accept more patches to the Dockerfile syntax for several
-reasons:
-
-  - Long term impact of syntax changes is a sensitive matter that require an amount of attention the
-    volume of Engine codebase and activity today doesn't allow us to provide.
-  - Allowing the Builder to be implemented as a separate utility consuming the Engine's API will
-    open the door for many possibilities, such as offering alternate syntaxes or DSL for existing
-    languages without cluttering the Engine's codebase.
-  - A standalone Builder will also offer the opportunity for a better dedicated group of maintainers
-    to own the Dockerfile syntax and decide collectively on the direction to give it.
-  - Our experience with official images tend to show that no new instruction or syntax expansion is
-    *strictly* necessary for the majority of use cases, and although we are aware many things are
-    still lacking for many, we cannot make it a priority yet for the above reasons.
-
-Again, this is not about saying that the Dockerfile syntax is done, it's about making choices about
-what we want to do first!
-
-## 2.3 Remote Registry Operations
-
-A large amount of work is ongoing in the area of image distribution and provenance. This includes
-moving to the V2 Registry API and heavily refactoring the code that powers these features. The
-desired result is more secure, reliable and easier to use image distribution.
-
-Part of the problem with this part of the code base is the lack of a stable and flexible interface.
-If new features are added that access the registry without solidifying these interfaces, achieving
-feature parity will continue to be elusive. While we get a handle on this situation, we are imposing
-a moratorium on new code that accesses the Registry API in commands that don't already make remote
-calls.
-
-Currently, only the following commands cause interaction with a remote registry:
-
-  - push
-  - pull
-  - run
-  - build
-  - search
-  - login
-
-In the interest of stabilizing the registry access model during this ongoing work, we are not
-accepting additions to other commands that will cause remote interaction with the Registry API. This
-moratorium will lift when the goals of the distribution project have been met.
--- a/VENDORING.md
+++ b/VENDORING.md
@@ -1,45 +0,0 @@
-# Vendoring policies
-
-This document outlines recommended Vendoring policies for Docker repositories.
-(Example, libnetwork is a Docker repo and logrus is not.)
-
-## Vendoring using tags
-
-Commit ID based vendoring provides little/no information about the updates
-vendored. To fix this, vendors will now require that repositories use annotated
-tags along with commit ids to snapshot commits. Annotated tags by themselves
-are not sufficient, since the same tag can be force updated to reference
-different commits.
-
-Each tag should:
- Follow Semantic Versioning rules (refer to section on "Semantic Versioning")
- Have a corresponding entry in the change tracking document.
-
-Each repo should:
- Have a change tracking document between tags/releases. Ex: CHANGELOG.md,
-github releases file.
-
-The goal here is for consuming repos to be able to use the tag version and
-changelog updates to determine whether the vendoring will cause any  breaking or
-backward incompatible changes. This also means that repos can specify having
-dependency on a package of a specific version or greater up to the next major
-release, without encountering breaking changes.
-
-## Semantic Versioning
-Annotated version tags should follow Schema Versioning policies.
-According to http://semver.org:
-
-"Given a version number MAJOR.MINOR.PATCH, increment the:
-    MAJOR version when you make incompatible API changes,
-    MINOR version when you add functionality in a backwards-compatible manner, and
-    PATCH version when you make backwards-compatible bug fixes.
-Additional labels for pre-release and build metadata are available as extensions
-to the MAJOR.MINOR.PATCH format."
-
-## Vendoring cadence
-In order to avoid huge vendoring changes, it is recommended to have a regular
-cadence for vendoring updates. e.g. monthly.
-
-## Pre-merge vendoring tests
-All related repos will be vendored into docker/docker.
-CI on docker/docker should catch any breaking changes involving multiple repos.
--- a/2
+++ b/2
@@ -1 +1 @@
-1.12.2
+1.6.2
--- a/api/api_unit_test.go
+++ b/api/api_unit_test.go
@@ -0,0 +1,19 @@
+package api
+
+import (
+	"testing"
+)
+
+func TestJsonContentType(t *testing.T) {
+	if !MatchesContentType("application/json", "application/json") {
+		t.Fail()
+	}
+
+	if !MatchesContentType("application/json; charset=utf-8", "application/json") {
+		t.Fail()
+	}
+
+	if MatchesContentType("dockerapplication/json", "application/json") {
+		t.Fail()
+	}
+}
--- a/api/client/bundlefile/bundlefile.go
+++ b/api/client/bundlefile/bundlefile.go
@@ -1,71 +0,0 @@
-// +build experimental
-
-package bundlefile
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-)
-
-// Bundlefile stores the contents of a bundlefile
-type Bundlefile struct {
-	Version  string
-	Services map[string]Service
-}
-
-// Service is a service from a bundlefile
-type Service struct {
-	Image      string
-	Command    []string          `json:",omitempty"`
-	Args       []string          `json:",omitempty"`
-	Env        []string          `json:",omitempty"`
-	Labels     map[string]string `json:",omitempty"`
-	Ports      []Port            `json:",omitempty"`
-	WorkingDir *string           `json:",omitempty"`
-	User       *string           `json:",omitempty"`
-	Networks   []string          `json:",omitempty"`
-}
-
-// Port is a port as defined in a bundlefile
-type Port struct {
-	Protocol string
-	Port     uint32
-}
-
-// LoadFile loads a bundlefile from a path to the file
-func LoadFile(reader io.Reader) (*Bundlefile, error) {
-	bundlefile := &Bundlefile{}
-
-	decoder := json.NewDecoder(reader)
-	if err := decoder.Decode(bundlefile); err != nil {
-		switch jsonErr := err.(type) {
-		case *json.SyntaxError:
-			return nil, fmt.Errorf(
-				"JSON syntax error at byte %v: %s",
-				jsonErr.Offset,
-				jsonErr.Error())
-		case *json.UnmarshalTypeError:
-			return nil, fmt.Errorf(
-				"Unexpected type at byte %v. Expected %s but received %s.",
-				jsonErr.Offset,
-				jsonErr.Type,
-				jsonErr.Value)
-		}
-		return nil, err
-	}
-
-	return bundlefile, nil
-}
-
-// Print writes the contents of the bundlefile to the output writer
-// as human readable json
-func Print(out io.Writer, bundle *Bundlefile) error {
-	bytes, err := json.MarshalIndent(*bundle, "", "    ")
-	if err != nil {
-		return err
-	}
-
-	_, err = out.Write(bytes)
-	return err
-}
--- a/api/client/bundlefile/bundlefile_test.go
+++ b/api/client/bundlefile/bundlefile_test.go
@@ -1,79 +0,0 @@
-// +build experimental
-
-package bundlefile
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-
-	"github.com/docker/docker/pkg/testutil/assert"
-)
-
-func TestLoadFileV01Success(t *testing.T) {
-	reader := strings.NewReader(`{
-		"Version": "0.1",
-		"Services": {
-			"redis": {
-				"Image": "redis@sha256:4b24131101fa0117bcaa18ac37055fffd9176aa1a240392bb8ea85e0be50f2ce",
-				"Networks": ["default"]
-			},
-			"web": {
-				"Image": "dockercloud/hello-world@sha256:fe79a2cfbd17eefc344fb8419420808df95a1e22d93b7f621a7399fd1e9dca1d",
-				"Networks": ["default"],
-				"User": "web"
-			}
-		}
-	}`)
-
-	bundle, err := LoadFile(reader)
-	assert.NilError(t, err)
-	assert.Equal(t, bundle.Version, "0.1")
-	assert.Equal(t, len(bundle.Services), 2)
-}
-
-func TestLoadFileSyntaxError(t *testing.T) {
-	reader := strings.NewReader(`{
-		"Version": "0.1",
-		"Services": unquoted string
-	}`)
-
-	_, err := LoadFile(reader)
-	assert.Error(t, err, "syntax error at byte 37: invalid character 'u'")
-}
-
-func TestLoadFileTypeError(t *testing.T) {
-	reader := strings.NewReader(`{
-		"Version": "0.1",
-		"Services": {
-			"web": {
-				"Image": "redis",
-				"Networks": "none"
-			}
-		}
-	}`)
-
-	_, err := LoadFile(reader)
-	assert.Error(t, err, "Unexpected type at byte 94. Expected []string but received string")
-}
-
-func TestPrint(t *testing.T) {
-	var buffer bytes.Buffer
-	bundle := &Bundlefile{
-		Version: "0.1",
-		Services: map[string]Service{
-			"web": {
-				Image:   "image",
-				Command: []string{"echo", "something"},
-			},
-		},
-	}
-	assert.NilError(t, Print(&buffer, bundle))
-	output := buffer.String()
-	assert.Contains(t, output, "\"Image\": \"image\"")
-	assert.Contains(t, output,
-		`"Command": [
-                "echo",
-                "something"
-            ]`)
-}
--- a/api/client/cli.go
+++ b/api/client/cli.go
@@ -1,281 +1,185 @@
 package client

 import (
+	"crypto/tls"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
+	"net"
 	"net/http"
 	"os"
-	"runtime"
+	"reflect"
+	"strings"
+	"text/template"
+	"time"

-	"github.com/docker/docker/api"
-	cliflags "github.com/docker/docker/cli/flags"
-	"github.com/docker/docker/cliconfig"
-	"github.com/docker/docker/cliconfig/configfile"
-	"github.com/docker/docker/cliconfig/credentials"
-	"github.com/docker/docker/dockerversion"
-	"github.com/docker/docker/opts"
+	"github.com/docker/docker/pkg/homedir"
+	flag "github.com/docker/docker/pkg/mflag"
 	"github.com/docker/docker/pkg/term"
-	"github.com/docker/engine-api/client"
-	"github.com/docker/go-connections/sockets"
-	"github.com/docker/go-connections/tlsconfig"
+	"github.com/docker/docker/registry"
 )

-// DockerCli represents the docker command line client.
-// Instances of the client can be returned from NewDockerCli.
 type DockerCli struct {
-	// initializing closure
-	init func() error
-
-	// configFile has the client configuration file
-	configFile *configfile.ConfigFile
-	// in holds the input stream and closer (io.ReadCloser) for the client.
-	in io.ReadCloser
-	// out holds the output stream (io.Writer) for the client.
-	out io.Writer
-	// err holds the error stream (io.Writer) for the client.
-	err io.Writer
-	// keyFile holds the key file as a string.
-	keyFile string
-	// inFd holds the file descriptor of the client's STDIN (if valid).
+	proto      string
+	addr       string
+	configFile *registry.ConfigFile
+	in         io.ReadCloser
+	out        io.Writer
+	err        io.Writer
+	keyFile    string
+	tlsConfig  *tls.Config
+	scheme     string
+	// inFd holds file descriptor of the client's STDIN, if it's a valid file
 	inFd uintptr
-	// outFd holds file descriptor of the client's STDOUT (if valid).
+	// outFd holds file descriptor of the client's STDOUT, if it's a valid file
 	outFd uintptr
-	// isTerminalIn indicates whether the client's STDIN is a TTY
+	// isTerminalIn describes if client's STDIN is a TTY
 	isTerminalIn bool
-	// isTerminalOut indicates whether the client's STDOUT is a TTY
+	// isTerminalOut describes if client's STDOUT is a TTY
 	isTerminalOut bool
-	// client is the http client that performs all API operations
-	client client.APIClient
-	// state holds the terminal input state
-	inState *term.State
-	// outState holds the terminal output state
-	outState *term.State
+	transport     *http.Transport
 }

-// Initialize calls the init function that will setup the configuration for the client
-// such as the TLS, tcp and other parameters used to run the client.
-func (cli *DockerCli) Initialize() error {
-	if cli.init == nil {
-		return nil
+var funcMap = template.FuncMap{
+	"json": func(v interface{}) string {
+		a, _ := json.Marshal(v)
+		return string(a)
+	},
+}
+
+func (cli *DockerCli) getMethod(args ...string) (func(...string) error, bool) {
+	camelArgs := make([]string, len(args))
+	for i, s := range args {
+		if len(s) == 0 {
+			return nil, false
+		}
+		camelArgs[i] = strings.ToUpper(s[:1]) + strings.ToLower(s[1:])
 	}
-	return cli.init()
+	methodName := "Cmd" + strings.Join(camelArgs, "")
+	method := reflect.ValueOf(cli).MethodByName(methodName)
+	if !method.IsValid() {
+		return nil, false
+	}
+	return method.Interface().(func(...string) error), true
 }

-// Client returns the APIClient
-func (cli *DockerCli) Client() client.APIClient {
-	return cli.client
+// Cmd executes the specified command
+func (cli *DockerCli) Cmd(args ...string) error {
+	if len(args) > 1 {
+		method, exists := cli.getMethod(args[:2]...)
+		if exists {
+			return method(args[2:]...)
+		}
+	}
+	if len(args) > 0 {
+		method, exists := cli.getMethod(args[0])
+		if !exists {
+			fmt.Fprintf(cli.err, "docker: '%s' is not a docker command. See 'docker --help'.\n", args[0])
+			os.Exit(1)
+		}
+		return method(args[1:]...)
+	}
+	return cli.CmdHelp()
 }

-// Out returns the writer used for stdout
-func (cli *DockerCli) Out() io.Writer {
-	return cli.out
+func (cli *DockerCli) Subcmd(name, signature, description string, exitOnError bool) *flag.FlagSet {
+	var errorHandling flag.ErrorHandling
+	if exitOnError {
+		errorHandling = flag.ExitOnError
+	} else {
+		errorHandling = flag.ContinueOnError
+	}
+	flags := flag.NewFlagSet(name, errorHandling)
+	flags.Usage = func() {
+		options := ""
+		if signature != "" {
+			signature = " " + signature
+		}
+		if flags.FlagCountUndeprecated() > 0 {
+			options = " [OPTIONS]"
+		}
+		fmt.Fprintf(cli.out, "\nUsage: docker %s%s%s\n\n%s\n\n", name, options, signature, description)
+		flags.SetOutput(cli.out)
+		flags.PrintDefaults()
+		os.Exit(0)
+	}
+	return flags
 }

-// Err returns the writer used for stderr
-func (cli *DockerCli) Err() io.Writer {
-	return cli.err
+func (cli *DockerCli) LoadConfigFile() (err error) {
+	cli.configFile, err = registry.LoadConfig(homedir.Get())
+	if err != nil {
+		fmt.Fprintf(cli.err, "WARNING: %s\n", err)
+	}
+	return err
 }

-// In returns the reader used for stdin
-func (cli *DockerCli) In() io.ReadCloser {
-	return cli.in
-}
-
-// ConfigFile returns the ConfigFile
-func (cli *DockerCli) ConfigFile() *configfile.ConfigFile {
-	return cli.configFile
-}
-
-// IsTerminalOut returns true if the clients stdin is a TTY
-func (cli *DockerCli) IsTerminalOut() bool {
-	return cli.isTerminalOut
-}
-
-// OutFd returns the fd for the stdout stream
-func (cli *DockerCli) OutFd() uintptr {
-	return cli.outFd
-}
-
-// CheckTtyInput checks if we are trying to attach to a container tty
-// from a non-tty client input stream, and if so, returns an error.
 func (cli *DockerCli) CheckTtyInput(attachStdin, ttyMode bool) error {
 	// In order to attach to a container tty, input stream for the client must
 	// be a tty itself: redirecting or piping the client standard input is
 	// incompatible with `docker run -t`, `docker exec -t` or `docker attach`.
 	if ttyMode && attachStdin && !cli.isTerminalIn {
-		eText := "the input device is not a TTY"
-		if runtime.GOOS == "windows" {
-			return errors.New(eText + ".  If you are using mintty, try prefixing the command with 'winpty'")
-		}
-		return errors.New(eText)
+		return errors.New("cannot enable tty mode on non tty input")
 	}
 	return nil
 }

-// PsFormat returns the format string specified in the configuration.
-// String contains columns and format specification, for example {{ID}}\t{{Name}}.
-func (cli *DockerCli) PsFormat() string {
-	return cli.configFile.PsFormat
-}
+func NewDockerCli(in io.ReadCloser, out, err io.Writer, keyFile string, proto, addr string, tlsConfig *tls.Config) *DockerCli {
+	var (
+		inFd          uintptr
+		outFd         uintptr
+		isTerminalIn  = false
+		isTerminalOut = false
+		scheme        = "http"
+	)

-// ImagesFormat returns the format string specified in the configuration.
-// String contains columns and format specification, for example {{ID}}\t{{Name}}.
-func (cli *DockerCli) ImagesFormat() string {
-	return cli.configFile.ImagesFormat
-}
-
-func (cli *DockerCli) setRawTerminal() error {
-	if os.Getenv("NORAW") == "" {
-		if cli.isTerminalIn {
-			state, err := term.SetRawTerminal(cli.inFd)
-			if err != nil {
-				return err
-			}
-			cli.inState = state
-		}
-		if cli.isTerminalOut {
-			state, err := term.SetRawTerminalOutput(cli.outFd)
-			if err != nil {
-				return err
-			}
-			cli.outState = state
-		}
+	if tlsConfig != nil {
+		scheme = "https"
 	}
-	return nil
-}
-
-func (cli *DockerCli) restoreTerminal(in io.Closer) error {
-	if cli.inState != nil {
-		term.RestoreTerminal(cli.inFd, cli.inState)
-	}
-	if cli.outState != nil {
-		term.RestoreTerminal(cli.outFd, cli.outState)
-	}
-	// WARNING: DO NOT REMOVE THE OS CHECK !!!
-	// For some reason this Close call blocks on darwin..
-	// As the client exists right after, simply discard the close
-	// until we find a better solution.
-	if in != nil && runtime.GOOS != "darwin" {
-		return in.Close()
-	}
-	return nil
-}
-
-// NewDockerCli returns a DockerCli instance with IO output and error streams set by in, out and err.
-// The key file, protocol (i.e. unix) and address are passed in as strings, along with the tls.Config. If the tls.Config
-// is set the client scheme will be set to https.
-// The client will be given a 32-second timeout (see https://github.com/docker/docker/pull/8035).
-func NewDockerCli(in io.ReadCloser, out, err io.Writer, clientFlags *cliflags.ClientFlags) *DockerCli {
-	cli := &DockerCli{
-		in:      in,
-		out:     out,
-		err:     err,
-		keyFile: clientFlags.Common.TrustKey,
+	if in != nil {
+		inFd, isTerminalIn = term.GetFdInfo(in)
 	}

-	cli.init = func() error {
-		clientFlags.PostParse()
-		cli.configFile = LoadDefaultConfigFile(err)
-
-		client, err := NewAPIClientFromFlags(clientFlags, cli.configFile)
-		if err != nil {
-			return err
-		}
-
-		cli.client = client
-
-		if cli.in != nil {
-			cli.inFd, cli.isTerminalIn = term.GetFdInfo(cli.in)
-		}
-		if cli.out != nil {
-			cli.outFd, cli.isTerminalOut = term.GetFdInfo(cli.out)
-		}
-
-		return nil
+	if out != nil {
+		outFd, isTerminalOut = term.GetFdInfo(out)
 	}

-	return cli
-}
-
-// LoadDefaultConfigFile attempts to load the default config file and returns
-// an initialized ConfigFile struct if none is found.
-func LoadDefaultConfigFile(err io.Writer) *configfile.ConfigFile {
-	configFile, e := cliconfig.Load(cliconfig.ConfigDir())
-	if e != nil {
-		fmt.Fprintf(err, "WARNING: Error loading config file:%v\n", e)
-	}
-	if !configFile.ContainsAuth() {
-		credentials.DetectDefaultStore(configFile)
-	}
-	return configFile
-}
-
-// NewAPIClientFromFlags creates a new APIClient from command line flags
-func NewAPIClientFromFlags(clientFlags *cliflags.ClientFlags, configFile *configfile.ConfigFile) (client.APIClient, error) {
-	host, err := getServerHost(clientFlags.Common.Hosts, clientFlags.Common.TLSOptions)
-	if err != nil {
-		return &client.Client{}, err
+	if err == nil {
+		err = out
 	}

-	customHeaders := configFile.HTTPHeaders
-	if customHeaders == nil {
-		customHeaders = map[string]string{}
-	}
-	customHeaders["User-Agent"] = clientUserAgent()
-
-	verStr := api.DefaultVersion
-	if tmpStr := os.Getenv("DOCKER_API_VERSION"); tmpStr != "" {
-		verStr = tmpStr
-	}
-
-	httpClient, err := newHTTPClient(host, clientFlags.Common.TLSOptions)
-	if err != nil {
-		return &client.Client{}, err
-	}
-
-	return client.NewClient(host, verStr, httpClient, customHeaders)
-}
-
-func getServerHost(hosts []string, tlsOptions *tlsconfig.Options) (host string, err error) {
-	switch len(hosts) {
-	case 0:
-		host = os.Getenv("DOCKER_HOST")
-	case 1:
-		host = hosts[0]
-	default:
-		return "", errors.New("Please specify only one -H")
-	}
-
-	host, err = opts.ParseHost(tlsOptions != nil, host)
-	return
-}
-
-func newHTTPClient(host string, tlsOptions *tlsconfig.Options) (*http.Client, error) {
-	if tlsOptions == nil {
-		// let the api client configure the default transport.
-		return nil, nil
-	}
-
-	config, err := tlsconfig.Client(*tlsOptions)
-	if err != nil {
-		return nil, err
-	}
+	// The transport is created here for reuse during the client session
 	tr := &http.Transport{
-		TLSClientConfig: config,
-	}
-	proto, addr, _, err := client.ParseHost(host)
-	if err != nil {
-		return nil, err
+		TLSClientConfig: tlsConfig,
 	}

-	sockets.ConfigureTransport(tr, proto, addr)
+	// Why 32? See issue 8035
+	timeout := 32 * time.Second
+	if proto == "unix" {
+		// no need in compressing for local communications
+		tr.DisableCompression = true
+		tr.Dial = func(_, _ string) (net.Conn, error) {
+			return net.DialTimeout(proto, addr, timeout)
+		}
+	} else {
+		tr.Proxy = http.ProxyFromEnvironment
+		tr.Dial = (&net.Dialer{Timeout: timeout}).Dial
+	}

-	return &http.Client{
-		Transport: tr,
-	}, nil
-}
-
-func clientUserAgent() string {
-	return "Docker-Client/" + dockerversion.Version + " (" + runtime.GOOS + ")"
+	return &DockerCli{
+		proto:         proto,
+		addr:          addr,
+		in:            in,
+		out:           out,
+		err:           err,
+		keyFile:       keyFile,
+		inFd:          inFd,
+		outFd:         outFd,
+		isTerminalIn:  isTerminalIn,
+		isTerminalOut: isTerminalOut,
+		tlsConfig:     tlsConfig,
+		scheme:        scheme,
+		transport:     tr,
+	}
 }
--- a/api/client/client.go
+++ b/api/client/client.go
@@ -1,5 +0,0 @@
-// Package client provides a command-line interface for Docker.
-//
-// Run "docker help SUBCOMMAND" or "docker SUBCOMMAND --help" to see more information on any Docker subcommand, including the full list of options supported for the subcommand.
-// See https://docs.docker.com/installation/ for instructions on installing Docker.
-package client
--- a/api/client/commands.go
+++ b/api/client/commands.go
--- a/api/client/container/attach.go
+++ b/api/client/container/attach.go
@@ -1,129 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"io"
-	"net/http/httputil"
-
-	"golang.org/x/net/context"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/signal"
-	"github.com/docker/engine-api/types"
-	"github.com/spf13/cobra"
-)
-
-type attachOptions struct {
-	noStdin    bool
-	proxy      bool
-	detachKeys string
-
-	container string
-}
-
-// NewAttachCommand creats a new cobra.Command for `docker attach`
-func NewAttachCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts attachOptions
-
-	cmd := &cobra.Command{
-		Use:   "attach [OPTIONS] CONTAINER",
-		Short: "Attach to a running container",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.container = args[0]
-			return runAttach(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.BoolVar(&opts.noStdin, "no-stdin", false, "Do not attach STDIN")
-	flags.BoolVar(&opts.proxy, "sig-proxy", true, "Proxy all received signals to the process")
-	flags.StringVar(&opts.detachKeys, "detach-keys", "", "Override the key sequence for detaching a container")
-	return cmd
-}
-
-func runAttach(dockerCli *client.DockerCli, opts *attachOptions) error {
-	ctx := context.Background()
-
-	c, err := dockerCli.Client().ContainerInspect(ctx, opts.container)
-	if err != nil {
-		return err
-	}
-
-	if !c.State.Running {
-		return fmt.Errorf("You cannot attach to a stopped container, start it first")
-	}
-
-	if c.State.Paused {
-		return fmt.Errorf("You cannot attach to a paused container, unpause it first")
-	}
-
-	if err := dockerCli.CheckTtyInput(!opts.noStdin, c.Config.Tty); err != nil {
-		return err
-	}
-
-	if opts.detachKeys != "" {
-		dockerCli.ConfigFile().DetachKeys = opts.detachKeys
-	}
-
-	options := types.ContainerAttachOptions{
-		Stream:     true,
-		Stdin:      !opts.noStdin && c.Config.OpenStdin,
-		Stdout:     true,
-		Stderr:     true,
-		DetachKeys: dockerCli.ConfigFile().DetachKeys,
-	}
-
-	var in io.ReadCloser
-	if options.Stdin {
-		in = dockerCli.In()
-	}
-
-	if opts.proxy && !c.Config.Tty {
-		sigc := dockerCli.ForwardAllSignals(ctx, opts.container)
-		defer signal.StopCatch(sigc)
-	}
-
-	resp, errAttach := dockerCli.Client().ContainerAttach(ctx, opts.container, options)
-	if errAttach != nil && errAttach != httputil.ErrPersistEOF {
-		// ContainerAttach returns an ErrPersistEOF (connection closed)
-		// means server met an error and put it in Hijacked connection
-		// keep the error and read detailed error message from hijacked connection later
-		return errAttach
-	}
-	defer resp.Close()
-
-	if c.Config.Tty && dockerCli.IsTerminalOut() {
-		height, width := dockerCli.GetTtySize()
-		// To handle the case where a user repeatedly attaches/detaches without resizing their
-		// terminal, the only way to get the shell prompt to display for attaches 2+ is to artificially
-		// resize it, then go back to normal. Without this, every attach after the first will
-		// require the user to manually resize or hit enter.
-		dockerCli.ResizeTtyTo(ctx, opts.container, height+1, width+1, false)
-
-		// After the above resizing occurs, the call to MonitorTtySize below will handle resetting back
-		// to the actual size.
-		if err := dockerCli.MonitorTtySize(ctx, opts.container, false); err != nil {
-			logrus.Debugf("Error monitoring TTY size: %s", err)
-		}
-	}
-	if err := dockerCli.HoldHijackedConnection(ctx, c.Config.Tty, in, dockerCli.Out(), dockerCli.Err(), resp); err != nil {
-		return err
-	}
-
-	if errAttach != nil {
-		return errAttach
-	}
-
-	_, status, err := getExitCode(dockerCli, ctx, opts.container)
-	if err != nil {
-		return err
-	}
-	if status != 0 {
-		return cli.StatusError{StatusCode: status}
-	}
-
-	return nil
-}
--- a/api/client/container/commit.go
+++ b/api/client/container/commit.go
@@ -1,92 +0,0 @@
-package container
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	dockeropts "github.com/docker/docker/opts"
-	"github.com/docker/engine-api/types"
-	containertypes "github.com/docker/engine-api/types/container"
-	"github.com/spf13/cobra"
-)
-
-type commitOptions struct {
-	container string
-	reference string
-
-	pause   bool
-	comment string
-	author  string
-	changes dockeropts.ListOpts
-	config  string
-}
-
-// NewCommitCommand creats a new cobra.Command for `docker commit`
-func NewCommitCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts commitOptions
-
-	cmd := &cobra.Command{
-		Use:   "commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]",
-		Short: "Create a new image from a container's changes",
-		Args:  cli.RequiresRangeArgs(1, 2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.container = args[0]
-			if len(args) > 1 {
-				opts.reference = args[1]
-			}
-			return runCommit(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.SetInterspersed(false)
-
-	flags.BoolVarP(&opts.pause, "pause", "p", true, "Pause container during commit")
-	flags.StringVarP(&opts.comment, "message", "m", "", "Commit message")
-	flags.StringVarP(&opts.author, "author", "a", "", "Author (e.g., \"John Hannibal Smith <hannibal@a-team.com>\")")
-
-	opts.changes = dockeropts.NewListOpts(nil)
-	flags.VarP(&opts.changes, "change", "c", "Apply Dockerfile instruction to the created image")
-
-	// FIXME: --run is deprecated, it will be replaced with inline Dockerfile commands.
-	flags.StringVar(&opts.config, "run", "", "This option is deprecated and will be removed in a future version in favor of inline Dockerfile-compatible commands")
-	flags.MarkDeprecated("run", "it will be replaced with inline Dockerfile commands.")
-
-	return cmd
-}
-
-func runCommit(dockerCli *client.DockerCli, opts *commitOptions) error {
-	ctx := context.Background()
-
-	name := opts.container
-	reference := opts.reference
-
-	var config *containertypes.Config
-	if opts.config != "" {
-		config = &containertypes.Config{}
-		if err := json.Unmarshal([]byte(opts.config), config); err != nil {
-			return err
-		}
-	}
-
-	options := types.ContainerCommitOptions{
-		Reference: reference,
-		Comment:   opts.comment,
-		Author:    opts.author,
-		Changes:   opts.changes.GetAll(),
-		Pause:     opts.pause,
-		Config:    config,
-	}
-
-	response, err := dockerCli.Client().ContainerCommit(ctx, name, options)
-	if err != nil {
-		return err
-	}
-
-	fmt.Fprintln(dockerCli.Out(), response.ID)
-	return nil
-}
--- a/api/client/container/cp.go
+++ b/api/client/container/cp.go
@@ -1,303 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/archive"
-	"github.com/docker/docker/pkg/system"
-	"github.com/docker/engine-api/types"
-	"github.com/spf13/cobra"
-)
-
-type copyOptions struct {
-	source      string
-	destination string
-	followLink  bool
-}
-
-type copyDirection int
-
-const (
-	fromContainer copyDirection = (1 << iota)
-	toContainer
-	acrossContainers = fromContainer | toContainer
-)
-
-type cpConfig struct {
-	followLink bool
-}
-
-// NewCopyCommand creates a new `docker cp` command
-func NewCopyCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts copyOptions
-
-	cmd := &cobra.Command{
-		Use: `cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH|-
-	docker cp [OPTIONS] SRC_PATH|- CONTAINER:DEST_PATH`,
-		Short: "Copy files/folders between a container and the local filesystem",
-		Long: strings.Join([]string{
-			"Copy files/folders between a container and the local filesystem\n",
-			"\nUse '-' as the source to read a tar archive from stdin\n",
-			"and extract it to a directory destination in a container.\n",
-			"Use '-' as the destination to stream a tar archive of a\n",
-			"container source to stdout.",
-		}, ""),
-		Args: cli.ExactArgs(2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			if args[0] == "" {
-				return fmt.Errorf("source can not be empty")
-			}
-			if args[1] == "" {
-				return fmt.Errorf("destination can not be empty")
-			}
-			opts.source = args[0]
-			opts.destination = args[1]
-			return runCopy(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.BoolVarP(&opts.followLink, "follow-link", "L", false, "Always follow symbol link in SRC_PATH")
-
-	return cmd
-}
-
-func runCopy(dockerCli *client.DockerCli, opts copyOptions) error {
-	srcContainer, srcPath := splitCpArg(opts.source)
-	dstContainer, dstPath := splitCpArg(opts.destination)
-
-	var direction copyDirection
-	if srcContainer != "" {
-		direction |= fromContainer
-	}
-	if dstContainer != "" {
-		direction |= toContainer
-	}
-
-	cpParam := &cpConfig{
-		followLink: opts.followLink,
-	}
-
-	ctx := context.Background()
-
-	switch direction {
-	case fromContainer:
-		return copyFromContainer(ctx, dockerCli, srcContainer, srcPath, dstPath, cpParam)
-	case toContainer:
-		return copyToContainer(ctx, dockerCli, srcPath, dstContainer, dstPath, cpParam)
-	case acrossContainers:
-		// Copying between containers isn't supported.
-		return fmt.Errorf("copying between containers is not supported")
-	default:
-		// User didn't specify any container.
-		return fmt.Errorf("must specify at least one container source")
-	}
-}
-
-func statContainerPath(ctx context.Context, dockerCli *client.DockerCli, containerName, path string) (types.ContainerPathStat, error) {
-	return dockerCli.Client().ContainerStatPath(ctx, containerName, path)
-}
-
-func resolveLocalPath(localPath string) (absPath string, err error) {
-	if absPath, err = filepath.Abs(localPath); err != nil {
-		return
-	}
-
-	return archive.PreserveTrailingDotOrSeparator(absPath, localPath), nil
-}
-
-func copyFromContainer(ctx context.Context, dockerCli *client.DockerCli, srcContainer, srcPath, dstPath string, cpParam *cpConfig) (err error) {
-	if dstPath != "-" {
-		// Get an absolute destination path.
-		dstPath, err = resolveLocalPath(dstPath)
-		if err != nil {
-			return err
-		}
-	}
-
-	// if client requests to follow symbol link, then must decide target file to be copied
-	var rebaseName string
-	if cpParam.followLink {
-		srcStat, err := statContainerPath(ctx, dockerCli, srcContainer, srcPath)
-
-		// If the destination is a symbolic link, we should follow it.
-		if err == nil && srcStat.Mode&os.ModeSymlink != 0 {
-			linkTarget := srcStat.LinkTarget
-			if !system.IsAbs(linkTarget) {
-				// Join with the parent directory.
-				srcParent, _ := archive.SplitPathDirEntry(srcPath)
-				linkTarget = filepath.Join(srcParent, linkTarget)
-			}
-
-			linkTarget, rebaseName = archive.GetRebaseName(srcPath, linkTarget)
-			srcPath = linkTarget
-		}
-
-	}
-
-	content, stat, err := dockerCli.Client().CopyFromContainer(ctx, srcContainer, srcPath)
-	if err != nil {
-		return err
-	}
-	defer content.Close()
-
-	if dstPath == "-" {
-		// Send the response to STDOUT.
-		_, err = io.Copy(os.Stdout, content)
-
-		return err
-	}
-
-	// Prepare source copy info.
-	srcInfo := archive.CopyInfo{
-		Path:       srcPath,
-		Exists:     true,
-		IsDir:      stat.Mode.IsDir(),
-		RebaseName: rebaseName,
-	}
-
-	preArchive := content
-	if len(srcInfo.RebaseName) != 0 {
-		_, srcBase := archive.SplitPathDirEntry(srcInfo.Path)
-		preArchive = archive.RebaseArchiveEntries(content, srcBase, srcInfo.RebaseName)
-	}
-	// See comments in the implementation of `archive.CopyTo` for exactly what
-	// goes into deciding how and whether the source archive needs to be
-	// altered for the correct copy behavior.
-	return archive.CopyTo(preArchive, srcInfo, dstPath)
-}
-
-func copyToContainer(ctx context.Context, dockerCli *client.DockerCli, srcPath, dstContainer, dstPath string, cpParam *cpConfig) (err error) {
-	if srcPath != "-" {
-		// Get an absolute source path.
-		srcPath, err = resolveLocalPath(srcPath)
-		if err != nil {
-			return err
-		}
-	}
-
-	// In order to get the copy behavior right, we need to know information
-	// about both the source and destination. The API is a simple tar
-	// archive/extract API but we can use the stat info header about the
-	// destination to be more informed about exactly what the destination is.
-
-	// Prepare destination copy info by stat-ing the container path.
-	dstInfo := archive.CopyInfo{Path: dstPath}
-	dstStat, err := statContainerPath(ctx, dockerCli, dstContainer, dstPath)
-
-	// If the destination is a symbolic link, we should evaluate it.
-	if err == nil && dstStat.Mode&os.ModeSymlink != 0 {
-		linkTarget := dstStat.LinkTarget
-		if !system.IsAbs(linkTarget) {
-			// Join with the parent directory.
-			dstParent, _ := archive.SplitPathDirEntry(dstPath)
-			linkTarget = filepath.Join(dstParent, linkTarget)
-		}
-
-		dstInfo.Path = linkTarget
-		dstStat, err = statContainerPath(ctx, dockerCli, dstContainer, linkTarget)
-	}
-
-	// Ignore any error and assume that the parent directory of the destination
-	// path exists, in which case the copy may still succeed. If there is any
-	// type of conflict (e.g., non-directory overwriting an existing directory
-	// or vice versa) the extraction will fail. If the destination simply did
-	// not exist, but the parent directory does, the extraction will still
-	// succeed.
-	if err == nil {
-		dstInfo.Exists, dstInfo.IsDir = true, dstStat.Mode.IsDir()
-	}
-
-	var (
-		content         io.Reader
-		resolvedDstPath string
-	)
-
-	if srcPath == "-" {
-		// Use STDIN.
-		content = os.Stdin
-		resolvedDstPath = dstInfo.Path
-		if !dstInfo.IsDir {
-			return fmt.Errorf("destination %q must be a directory", fmt.Sprintf("%s:%s", dstContainer, dstPath))
-		}
-	} else {
-		// Prepare source copy info.
-		srcInfo, err := archive.CopyInfoSourcePath(srcPath, cpParam.followLink)
-		if err != nil {
-			return err
-		}
-
-		srcArchive, err := archive.TarResource(srcInfo)
-		if err != nil {
-			return err
-		}
-		defer srcArchive.Close()
-
-		// With the stat info about the local source as well as the
-		// destination, we have enough information to know whether we need to
-		// alter the archive that we upload so that when the server extracts
-		// it to the specified directory in the container we get the desired
-		// copy behavior.
-
-		// See comments in the implementation of `archive.PrepareArchiveCopy`
-		// for exactly what goes into deciding how and whether the source
-		// archive needs to be altered for the correct copy behavior when it is
-		// extracted. This function also infers from the source and destination
-		// info which directory to extract to, which may be the parent of the
-		// destination that the user specified.
-		dstDir, preparedArchive, err := archive.PrepareArchiveCopy(srcArchive, srcInfo, dstInfo)
-		if err != nil {
-			return err
-		}
-		defer preparedArchive.Close()
-
-		resolvedDstPath = dstDir
-		content = preparedArchive
-	}
-
-	options := types.CopyToContainerOptions{
-		AllowOverwriteDirWithFile: false,
-	}
-
-	return dockerCli.Client().CopyToContainer(ctx, dstContainer, resolvedDstPath, content, options)
-}
-
-// We use `:` as a delimiter between CONTAINER and PATH, but `:` could also be
-// in a valid LOCALPATH, like `file:name.txt`. We can resolve this ambiguity by
-// requiring a LOCALPATH with a `:` to be made explicit with a relative or
-// absolute path:
-// 	`/path/to/file:name.txt` or `./file:name.txt`
-//
-// This is apparently how `scp` handles this as well:
-// 	http://www.cyberciti.biz/faq/rsync-scp-file-name-with-colon-punctuation-in-it/
-//
-// We can't simply check for a filepath separator because container names may
-// have a separator, e.g., "host0/cname1" if container is in a Docker cluster,
-// so we have to check for a `/` or `.` prefix. Also, in the case of a Windows
-// client, a `:` could be part of an absolute Windows path, in which case it
-// is immediately proceeded by a backslash.
-func splitCpArg(arg string) (container, path string) {
-	if system.IsAbs(arg) {
-		// Explicit local absolute path, e.g., `C:\foo` or `/foo`.
-		return "", arg
-	}
-
-	parts := strings.SplitN(arg, ":", 2)
-
-	if len(parts) == 1 || strings.HasPrefix(parts[0], ".") {
-		// Either there's no `:` in the arg
-		// OR it's an explicit local relative path like `./file:name.txt`.
-		return "", arg
-	}
-
-	return parts[0], parts[1]
-}
--- a/api/client/container/create.go
+++ b/api/client/container/create.go
@@ -1,217 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"io"
-	"os"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/jsonmessage"
-	// FIXME migrate to docker/distribution/reference
-	"github.com/docker/docker/reference"
-	"github.com/docker/docker/registry"
-	runconfigopts "github.com/docker/docker/runconfig/opts"
-	apiclient "github.com/docker/engine-api/client"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/container"
-	networktypes "github.com/docker/engine-api/types/network"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-type createOptions struct {
-	name string
-}
-
-// NewCreateCommand creats a new cobra.Command for `docker create`
-func NewCreateCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts createOptions
-	var copts *runconfigopts.ContainerOptions
-
-	cmd := &cobra.Command{
-		Use:   "create [OPTIONS] IMAGE [COMMAND] [ARG...]",
-		Short: "Create a new container",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			copts.Image = args[0]
-			if len(args) > 1 {
-				copts.Args = args[1:]
-			}
-			return runCreate(dockerCli, cmd.Flags(), &opts, copts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.SetInterspersed(false)
-
-	flags.StringVar(&opts.name, "name", "", "Assign a name to the container")
-
-	// Add an explicit help that doesn't have a `-h` to prevent the conflict
-	// with hostname
-	flags.Bool("help", false, "Print usage")
-
-	client.AddTrustedFlags(flags, true)
-	copts = runconfigopts.AddFlags(flags)
-	return cmd
-}
-
-func runCreate(dockerCli *client.DockerCli, flags *pflag.FlagSet, opts *createOptions, copts *runconfigopts.ContainerOptions) error {
-	config, hostConfig, networkingConfig, err := runconfigopts.Parse(flags, copts)
-	if err != nil {
-		reportError(dockerCli.Err(), "create", err.Error(), true)
-		return cli.StatusError{StatusCode: 125}
-	}
-	response, err := createContainer(context.Background(), dockerCli, config, hostConfig, networkingConfig, hostConfig.ContainerIDFile, opts.name)
-	if err != nil {
-		return err
-	}
-	fmt.Fprintf(dockerCli.Out(), "%s\n", response.ID)
-	return nil
-}
-
-func pullImage(ctx context.Context, dockerCli *client.DockerCli, image string, out io.Writer) error {
-	ref, err := reference.ParseNamed(image)
-	if err != nil {
-		return err
-	}
-
-	// Resolve the Repository name from fqn to RepositoryInfo
-	repoInfo, err := registry.ParseRepositoryInfo(ref)
-	if err != nil {
-		return err
-	}
-
-	authConfig := dockerCli.ResolveAuthConfig(ctx, repoInfo.Index)
-	encodedAuth, err := client.EncodeAuthToBase64(authConfig)
-	if err != nil {
-		return err
-	}
-
-	options := types.ImageCreateOptions{
-		RegistryAuth: encodedAuth,
-	}
-
-	responseBody, err := dockerCli.Client().ImageCreate(ctx, image, options)
-	if err != nil {
-		return err
-	}
-	defer responseBody.Close()
-
-	return jsonmessage.DisplayJSONMessagesStream(
-		responseBody,
-		out,
-		dockerCli.OutFd(),
-		dockerCli.IsTerminalOut(),
-		nil)
-}
-
-type cidFile struct {
-	path    string
-	file    *os.File
-	written bool
-}
-
-func (cid *cidFile) Close() error {
-	cid.file.Close()
-
-	if !cid.written {
-		if err := os.Remove(cid.path); err != nil {
-			return fmt.Errorf("failed to remove the CID file '%s': %s \n", cid.path, err)
-		}
-	}
-
-	return nil
-}
-
-func (cid *cidFile) Write(id string) error {
-	if _, err := cid.file.Write([]byte(id)); err != nil {
-		return fmt.Errorf("Failed to write the container ID to the file: %s", err)
-	}
-	cid.written = true
-	return nil
-}
-
-func newCIDFile(path string) (*cidFile, error) {
-	if _, err := os.Stat(path); err == nil {
-		return nil, fmt.Errorf("Container ID file found, make sure the other container isn't running or delete %s", path)
-	}
-
-	f, err := os.Create(path)
-	if err != nil {
-		return nil, fmt.Errorf("Failed to create the container ID file: %s", err)
-	}
-
-	return &cidFile{path: path, file: f}, nil
-}
-
-func createContainer(ctx context.Context, dockerCli *client.DockerCli, config *container.Config, hostConfig *container.HostConfig, networkingConfig *networktypes.NetworkingConfig, cidfile, name string) (*types.ContainerCreateResponse, error) {
-	stderr := dockerCli.Err()
-
-	var containerIDFile *cidFile
-	if cidfile != "" {
-		var err error
-		if containerIDFile, err = newCIDFile(cidfile); err != nil {
-			return nil, err
-		}
-		defer containerIDFile.Close()
-	}
-
-	var trustedRef reference.Canonical
-	_, ref, err := reference.ParseIDOrReference(config.Image)
-	if err != nil {
-		return nil, err
-	}
-	if ref != nil {
-		ref = reference.WithDefaultTag(ref)
-
-		if ref, ok := ref.(reference.NamedTagged); ok && client.IsTrusted() {
-			var err error
-			trustedRef, err = dockerCli.TrustedReference(ctx, ref)
-			if err != nil {
-				return nil, err
-			}
-			config.Image = trustedRef.String()
-		}
-	}
-
-	//create the container
-	response, err := dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, name)
-
-	//if image not found try to pull it
-	if err != nil {
-		if apiclient.IsErrImageNotFound(err) && ref != nil {
-			fmt.Fprintf(stderr, "Unable to find image '%s' locally\n", ref.String())
-
-			// we don't want to write to stdout anything apart from container.ID
-			if err = pullImage(ctx, dockerCli, config.Image, stderr); err != nil {
-				return nil, err
-			}
-			if ref, ok := ref.(reference.NamedTagged); ok && trustedRef != nil {
-				if err := dockerCli.TagTrusted(ctx, trustedRef, ref); err != nil {
-					return nil, err
-				}
-			}
-			// Retry
-			var retryErr error
-			response, retryErr = dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, name)
-			if retryErr != nil {
-				return nil, retryErr
-			}
-		} else {
-			return nil, err
-		}
-	}
-
-	for _, warning := range response.Warnings {
-		fmt.Fprintf(stderr, "WARNING: %s\n", warning)
-	}
-	if containerIDFile != nil {
-		if err = containerIDFile.Write(response.ID); err != nil {
-			return nil, err
-		}
-	}
-	return &response, nil
-}
--- a/api/client/container/diff.go
+++ b/api/client/container/diff.go
@@ -1,60 +0,0 @@
-package container
-
-import (
-	"fmt"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/archive"
-	"github.com/spf13/cobra"
-)
-
-type diffOptions struct {
-	container string
-}
-
-// NewDiffCommand creates a new cobra.Command for `docker diff`
-func NewDiffCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts diffOptions
-
-	cmd := &cobra.Command{
-		Use:   "diff CONTAINER",
-		Short: "Inspect changes on a container's filesystem",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.container = args[0]
-			return runDiff(dockerCli, &opts)
-		},
-	}
-
-	return cmd
-}
-
-func runDiff(dockerCli *client.DockerCli, opts *diffOptions) error {
-	if opts.container == "" {
-		return fmt.Errorf("Container name cannot be empty")
-	}
-	ctx := context.Background()
-
-	changes, err := dockerCli.Client().ContainerDiff(ctx, opts.container)
-	if err != nil {
-		return err
-	}
-
-	for _, change := range changes {
-		var kind string
-		switch change.Kind {
-		case archive.ChangeModify:
-			kind = "C"
-		case archive.ChangeAdd:
-			kind = "A"
-		case archive.ChangeDelete:
-			kind = "D"
-		}
-		fmt.Fprintf(dockerCli.Out(), "%s %s\n", kind, change.Path)
-	}
-
-	return nil
-}
--- a/api/client/container/export.go
+++ b/api/client/container/export.go
@@ -1,59 +0,0 @@
-package container
-
-import (
-	"errors"
-	"io"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type exportOptions struct {
-	container string
-	output    string
-}
-
-// NewExportCommand creates a new `docker export` command
-func NewExportCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts exportOptions
-
-	cmd := &cobra.Command{
-		Use:   "export [OPTIONS] CONTAINER",
-		Short: "Export a container's filesystem as a tar archive",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.container = args[0]
-			return runExport(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.StringVarP(&opts.output, "output", "o", "", "Write to a file, instead of STDOUT")
-
-	return cmd
-}
-
-func runExport(dockerCli *client.DockerCli, opts exportOptions) error {
-	if opts.output == "" && dockerCli.IsTerminalOut() {
-		return errors.New("Cowardly refusing to save to a terminal. Use the -o flag or redirect.")
-	}
-
-	clnt := dockerCli.Client()
-
-	responseBody, err := clnt.ContainerExport(context.Background(), opts.container)
-	if err != nil {
-		return err
-	}
-	defer responseBody.Close()
-
-	if opts.output == "" {
-		_, err := io.Copy(dockerCli.Out(), responseBody)
-		return err
-	}
-
-	return client.CopyToFile(opts.output, responseBody)
-}
--- a/api/client/container/kill.go
+++ b/api/client/container/kill.go
@@ -1,53 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type killOptions struct {
-	signal string
-
-	containers []string
-}
-
-// NewKillCommand creats a new cobra.Command for `docker kill`
-func NewKillCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts killOptions
-
-	cmd := &cobra.Command{
-		Use:   "kill [OPTIONS] CONTAINER [CONTAINER...]",
-		Short: "Kill one or more running containers",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.containers = args
-			return runKill(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.StringVarP(&opts.signal, "signal", "s", "KILL", "Signal to send to the container")
-	return cmd
-}
-
-func runKill(dockerCli *client.DockerCli, opts *killOptions) error {
-	var errs []string
-	ctx := context.Background()
-	for _, name := range opts.containers {
-		if err := dockerCli.Client().ContainerKill(ctx, name, opts.signal); err != nil {
-			errs = append(errs, err.Error())
-		} else {
-			fmt.Fprintf(dockerCli.Out(), "%s\n", name)
-		}
-	}
-	if len(errs) > 0 {
-		return fmt.Errorf("%s", strings.Join(errs, "\n"))
-	}
-	return nil
-}
--- a/api/client/container/logs.go
+++ b/api/client/container/logs.go
@@ -1,87 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"io"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/stdcopy"
-	"github.com/docker/engine-api/types"
-	"github.com/spf13/cobra"
-)
-
-var validDrivers = map[string]bool{
-	"json-file": true,
-	"journald":  true,
-}
-
-type logsOptions struct {
-	follow     bool
-	since      string
-	timestamps bool
-	details    bool
-	tail       string
-
-	container string
-}
-
-// NewLogsCommand creats a new cobra.Command for `docker logs`
-func NewLogsCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts logsOptions
-
-	cmd := &cobra.Command{
-		Use:   "logs [OPTIONS] CONTAINER",
-		Short: "Fetch the logs of a container",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.container = args[0]
-			return runLogs(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.BoolVarP(&opts.follow, "follow", "f", false, "Follow log output")
-	flags.StringVar(&opts.since, "since", "", "Show logs since timestamp")
-	flags.BoolVarP(&opts.timestamps, "timestamps", "t", false, "Show timestamps")
-	flags.BoolVar(&opts.details, "details", false, "Show extra details provided to logs")
-	flags.StringVar(&opts.tail, "tail", "all", "Number of lines to show from the end of the logs")
-	return cmd
-}
-
-func runLogs(dockerCli *client.DockerCli, opts *logsOptions) error {
-	ctx := context.Background()
-
-	c, err := dockerCli.Client().ContainerInspect(ctx, opts.container)
-	if err != nil {
-		return err
-	}
-
-	if !validDrivers[c.HostConfig.LogConfig.Type] {
-		return fmt.Errorf("\"logs\" command is supported only for \"json-file\" and \"journald\" logging drivers (got: %s)", c.HostConfig.LogConfig.Type)
-	}
-
-	options := types.ContainerLogsOptions{
-		ShowStdout: true,
-		ShowStderr: true,
-		Since:      opts.since,
-		Timestamps: opts.timestamps,
-		Follow:     opts.follow,
-		Tail:       opts.tail,
-		Details:    opts.details,
-	}
-	responseBody, err := dockerCli.Client().ContainerLogs(ctx, opts.container, options)
-	if err != nil {
-		return err
-	}
-	defer responseBody.Close()
-
-	if c.Config.Tty {
-		_, err = io.Copy(dockerCli.Out(), responseBody)
-	} else {
-		_, err = stdcopy.StdCopy(dockerCli.Out(), dockerCli.Err(), responseBody)
-	}
-	return err
-}
--- a/api/client/container/pause.go
+++ b/api/client/container/pause.go
@@ -1,50 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type pauseOptions struct {
-	containers []string
-}
-
-// NewPauseCommand creats a new cobra.Command for `docker pause`
-func NewPauseCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts pauseOptions
-
-	cmd := &cobra.Command{
-		Use:   "pause CONTAINER [CONTAINER...]",
-		Short: "Pause all processes within one or more containers",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.containers = args
-			return runPause(dockerCli, &opts)
-		},
-	}
-
-	return cmd
-}
-
-func runPause(dockerCli *client.DockerCli, opts *pauseOptions) error {
-	ctx := context.Background()
-
-	var errs []string
-	for _, container := range opts.containers {
-		if err := dockerCli.Client().ContainerPause(ctx, container); err != nil {
-			errs = append(errs, err.Error())
-		} else {
-			fmt.Fprintf(dockerCli.Out(), "%s\n", container)
-		}
-	}
-	if len(errs) > 0 {
-		return fmt.Errorf("%s", strings.Join(errs, "\n"))
-	}
-	return nil
-}
--- a/api/client/container/port.go
+++ b/api/client/container/port.go
@@ -1,79 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/go-connections/nat"
-	"github.com/spf13/cobra"
-)
-
-type portOptions struct {
-	container string
-
-	port string
-}
-
-// NewPortCommand creats a new cobra.Command for `docker port`
-func NewPortCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts portOptions
-
-	cmd := &cobra.Command{
-		Use:   "port CONTAINER [PRIVATE_PORT[/PROTO]]",
-		Short: "List port mappings or a specific mapping for the container",
-		Args:  cli.RequiresRangeArgs(1, 2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.container = args[0]
-			if len(args) > 1 {
-				opts.port = args[1]
-			}
-			return runPort(dockerCli, &opts)
-		},
-	}
-
-	return cmd
-}
-
-func runPort(dockerCli *client.DockerCli, opts *portOptions) error {
-	ctx := context.Background()
-
-	c, err := dockerCli.Client().ContainerInspect(ctx, opts.container)
-	if err != nil {
-		return err
-	}
-
-	if opts.port != "" {
-		port := opts.port
-		proto := "tcp"
-		parts := strings.SplitN(port, "/", 2)
-
-		if len(parts) == 2 && len(parts[1]) != 0 {
-			port = parts[0]
-			proto = parts[1]
-		}
-		natPort := port + "/" + proto
-		newP, err := nat.NewPort(proto, port)
-		if err != nil {
-			return err
-		}
-		if frontends, exists := c.NetworkSettings.Ports[newP]; exists && frontends != nil {
-			for _, frontend := range frontends {
-				fmt.Fprintf(dockerCli.Out(), "%s:%s\n", frontend.HostIP, frontend.HostPort)
-			}
-			return nil
-		}
-		return fmt.Errorf("Error: No public port '%s' published for %s", natPort, opts.container)
-	}
-
-	for from, frontends := range c.NetworkSettings.Ports {
-		for _, frontend := range frontends {
-			fmt.Fprintf(dockerCli.Out(), "%s -> %s:%s\n", from, frontend.HostIP, frontend.HostPort)
-		}
-	}
-
-	return nil
-}
--- a/api/client/container/ps.go
+++ b/api/client/container/ps.go
@@ -1,125 +0,0 @@
-package container
-
-import (
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/api/client/formatter"
-	"github.com/docker/docker/cli"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-
-	"github.com/docker/docker/utils/templates"
-	"github.com/spf13/cobra"
-	"io/ioutil"
-)
-
-type psOptions struct {
-	quiet   bool
-	size    bool
-	all     bool
-	noTrunc bool
-	nLatest bool
-	last    int
-	format  string
-	filter  []string
-}
-
-type preProcessor struct {
-	opts *types.ContainerListOptions
-}
-
-// Size sets the size option when called by a template execution.
-func (p *preProcessor) Size() bool {
-	p.opts.Size = true
-	return true
-}
-
-// NewPsCommand creates a new cobra.Command for `docker ps`
-func NewPsCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts psOptions
-
-	cmd := &cobra.Command{
-		Use:   "ps [OPTIONS]",
-		Short: "List containers",
-		Args:  cli.NoArgs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runPs(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Only display numeric IDs")
-	flags.BoolVarP(&opts.size, "size", "s", false, "Display total file sizes")
-	flags.BoolVarP(&opts.all, "all", "a", false, "Show all containers (default shows just running)")
-	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Don't truncate output")
-	flags.BoolVarP(&opts.nLatest, "latest", "l", false, "Show the latest created container (includes all states)")
-	flags.IntVarP(&opts.last, "last", "n", -1, "Show n last created containers (includes all states)")
-	flags.StringVarP(&opts.format, "format", "", "", "Pretty-print containers using a Go template")
-	flags.StringSliceVarP(&opts.filter, "filter", "f", []string{}, "Filter output based on conditions provided")
-
-	return cmd
-}
-
-func runPs(dockerCli *client.DockerCli, opts *psOptions) error {
-	ctx := context.Background()
-
-	if opts.nLatest && opts.last == -1 {
-		opts.last = 1
-	}
-
-	containerFilterArgs := filters.NewArgs()
-	for _, f := range opts.filter {
-		var err error
-		containerFilterArgs, err = filters.ParseFlag(f, containerFilterArgs)
-		if err != nil {
-			return err
-		}
-	}
-
-	options := types.ContainerListOptions{
-		All:    opts.all,
-		Limit:  opts.last,
-		Size:   opts.size,
-		Filter: containerFilterArgs,
-	}
-
-	pre := &preProcessor{opts: &options}
-	tmpl, err := templates.Parse(opts.format)
-
-	if err != nil {
-		return err
-	}
-
-	_ = tmpl.Execute(ioutil.Discard, pre)
-
-	containers, err := dockerCli.Client().ContainerList(ctx, options)
-	if err != nil {
-		return err
-	}
-
-	f := opts.format
-	if len(f) == 0 {
-		if len(dockerCli.PsFormat()) > 0 && !opts.quiet {
-			f = dockerCli.PsFormat()
-		} else {
-			f = "table"
-		}
-	}
-
-	psCtx := formatter.ContainerContext{
-		Context: formatter.Context{
-			Output: dockerCli.Out(),
-			Format: f,
-			Quiet:  opts.quiet,
-			Trunc:  !opts.noTrunc,
-		},
-		Size:       opts.size,
-		Containers: containers,
-	}
-
-	psCtx.Write()
-
-	return nil
-}
--- a/api/client/container/rename.go
+++ b/api/client/container/rename.go
@@ -1,52 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type renameOptions struct {
-	oldName string
-	newName string
-}
-
-// NewRenameCommand creats a new cobra.Command for `docker rename`
-func NewRenameCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts renameOptions
-
-	cmd := &cobra.Command{
-		Use:   "rename CONTAINER NEW_NAME",
-		Short: "Rename a container",
-		Args:  cli.ExactArgs(2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.oldName = args[0]
-			opts.newName = args[1]
-			return runRename(dockerCli, &opts)
-		},
-	}
-
-	return cmd
-}
-
-func runRename(dockerCli *client.DockerCli, opts *renameOptions) error {
-	ctx := context.Background()
-
-	oldName := strings.TrimSpace(opts.oldName)
-	newName := strings.TrimSpace(opts.newName)
-
-	if oldName == "" || newName == "" {
-		return fmt.Errorf("Error: Neither old nor new names may be empty")
-	}
-
-	if err := dockerCli.Client().ContainerRename(ctx, oldName, newName); err != nil {
-		fmt.Fprintf(dockerCli.Err(), "%s\n", err)
-		return fmt.Errorf("Error: failed to rename container named %s", oldName)
-	}
-	return nil
-}
--- a/api/client/container/restart.go
+++ b/api/client/container/restart.go
@@ -1,55 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type restartOptions struct {
-	nSeconds int
-
-	containers []string
-}
-
-// NewRestartCommand creates a new cobra.Command for `docker restart`
-func NewRestartCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts restartOptions
-
-	cmd := &cobra.Command{
-		Use:   "restart [OPTIONS] CONTAINER [CONTAINER...]",
-		Short: "Restart a container",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.containers = args
-			return runRestart(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.IntVarP(&opts.nSeconds, "time", "t", 10, "Seconds to wait for stop before killing the container")
-	return cmd
-}
-
-func runRestart(dockerCli *client.DockerCli, opts *restartOptions) error {
-	ctx := context.Background()
-	var errs []string
-	for _, name := range opts.containers {
-		timeout := time.Duration(opts.nSeconds) * time.Second
-		if err := dockerCli.Client().ContainerRestart(ctx, name, &timeout); err != nil {
-			errs = append(errs, err.Error())
-		} else {
-			fmt.Fprintf(dockerCli.Out(), "%s\n", name)
-		}
-	}
-	if len(errs) > 0 {
-		return fmt.Errorf("%s", strings.Join(errs, "\n"))
-	}
-	return nil
-}
--- a/api/client/container/rm.go
+++ b/api/client/container/rm.go
@@ -1,76 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/engine-api/types"
-	"github.com/spf13/cobra"
-)
-
-type rmOptions struct {
-	rmVolumes bool
-	rmLink    bool
-	force     bool
-
-	containers []string
-}
-
-// NewRmCommand creates a new cobra.Command for `docker rm`
-func NewRmCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts rmOptions
-
-	cmd := &cobra.Command{
-		Use:   "rm [OPTIONS] CONTAINER [CONTAINER...]",
-		Short: "Remove one or more containers",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.containers = args
-			return runRm(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.BoolVarP(&opts.rmVolumes, "volumes", "v", false, "Remove the volumes associated with the container")
-	flags.BoolVarP(&opts.rmLink, "link", "l", false, "Remove the specified link")
-	flags.BoolVarP(&opts.force, "force", "f", false, "Force the removal of a running container (uses SIGKILL)")
-	return cmd
-}
-
-func runRm(dockerCli *client.DockerCli, opts *rmOptions) error {
-	ctx := context.Background()
-
-	var errs []string
-	for _, name := range opts.containers {
-		if name == "" {
-			return fmt.Errorf("Container name cannot be empty")
-		}
-		name = strings.Trim(name, "/")
-
-		if err := removeContainer(dockerCli, ctx, name, opts.rmVolumes, opts.rmLink, opts.force); err != nil {
-			errs = append(errs, err.Error())
-		} else {
-			fmt.Fprintf(dockerCli.Out(), "%s\n", name)
-		}
-	}
-	if len(errs) > 0 {
-		return fmt.Errorf("%s", strings.Join(errs, "\n"))
-	}
-	return nil
-}
-
-func removeContainer(dockerCli *client.DockerCli, ctx context.Context, container string, removeVolumes, removeLinks, force bool) error {
-	options := types.ContainerRemoveOptions{
-		RemoveVolumes: removeVolumes,
-		RemoveLinks:   removeLinks,
-		Force:         force,
-	}
-	if err := dockerCli.Client().ContainerRemove(ctx, container, options); err != nil {
-		return err
-	}
-	return nil
-}
--- a/api/client/container/run.go
+++ b/api/client/container/run.go
@@ -1,326 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"io"
-	"net/http/httputil"
-	"os"
-	"runtime"
-	"strings"
-	"syscall"
-
-	"golang.org/x/net/context"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	opttypes "github.com/docker/docker/opts"
-	"github.com/docker/docker/pkg/promise"
-	"github.com/docker/docker/pkg/signal"
-	runconfigopts "github.com/docker/docker/runconfig/opts"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/libnetwork/resolvconf/dns"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-const (
-	errCmdNotFound          = "not found or does not exist"
-	errCmdCouldNotBeInvoked = "could not be invoked"
-)
-
-type runOptions struct {
-	autoRemove bool
-	detach     bool
-	sigProxy   bool
-	name       string
-	detachKeys string
-}
-
-// NewRunCommand create a new `docker run` command
-func NewRunCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts runOptions
-	var copts *runconfigopts.ContainerOptions
-
-	cmd := &cobra.Command{
-		Use:   "run [OPTIONS] IMAGE [COMMAND] [ARG...]",
-		Short: "Run a command in a new container",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			copts.Image = args[0]
-			if len(args) > 1 {
-				copts.Args = args[1:]
-			}
-			return runRun(dockerCli, cmd.Flags(), &opts, copts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.SetInterspersed(false)
-
-	// These are flags not stored in Config/HostConfig
-	flags.BoolVar(&opts.autoRemove, "rm", false, "Automatically remove the container when it exits")
-	flags.BoolVarP(&opts.detach, "detach", "d", false, "Run container in background and print container ID")
-	flags.BoolVar(&opts.sigProxy, "sig-proxy", true, "Proxy received signals to the process")
-	flags.StringVar(&opts.name, "name", "", "Assign a name to the container")
-	flags.StringVar(&opts.detachKeys, "detach-keys", "", "Override the key sequence for detaching a container")
-
-	// Add an explicit help that doesn't have a `-h` to prevent the conflict
-	// with hostname
-	flags.Bool("help", false, "Print usage")
-
-	client.AddTrustedFlags(flags, true)
-	copts = runconfigopts.AddFlags(flags)
-	return cmd
-}
-
-func runRun(dockerCli *client.DockerCli, flags *pflag.FlagSet, opts *runOptions, copts *runconfigopts.ContainerOptions) error {
-	stdout, stderr, stdin := dockerCli.Out(), dockerCli.Err(), dockerCli.In()
-	client := dockerCli.Client()
-	// TODO: pass this as an argument
-	cmdPath := "run"
-
-	var (
-		flAttach                              *opttypes.ListOpts
-		ErrConflictAttachDetach               = fmt.Errorf("Conflicting options: -a and -d")
-		ErrConflictRestartPolicyAndAutoRemove = fmt.Errorf("Conflicting options: --restart and --rm")
-		ErrConflictDetachAutoRemove           = fmt.Errorf("Conflicting options: --rm and -d")
-	)
-
-	config, hostConfig, networkingConfig, err := runconfigopts.Parse(flags, copts)
-
-	// just in case the Parse does not exit
-	if err != nil {
-		reportError(stderr, cmdPath, err.Error(), true)
-		return cli.StatusError{StatusCode: 125}
-	}
-
-	if hostConfig.OomKillDisable != nil && *hostConfig.OomKillDisable && hostConfig.Memory == 0 {
-		fmt.Fprintf(stderr, "WARNING: Disabling the OOM killer on containers without setting a '-m/--memory' limit may be dangerous.\n")
-	}
-
-	if len(hostConfig.DNS) > 0 {
-		// check the DNS settings passed via --dns against
-		// localhost regexp to warn if they are trying to
-		// set a DNS to a localhost address
-		for _, dnsIP := range hostConfig.DNS {
-			if dns.IsLocalhost(dnsIP) {
-				fmt.Fprintf(stderr, "WARNING: Localhost DNS setting (--dns=%s) may fail in containers.\n", dnsIP)
-				break
-			}
-		}
-	}
-
-	config.ArgsEscaped = false
-
-	if !opts.detach {
-		if err := dockerCli.CheckTtyInput(config.AttachStdin, config.Tty); err != nil {
-			return err
-		}
-	} else {
-		if fl := flags.Lookup("attach"); fl != nil {
-			flAttach = fl.Value.(*opttypes.ListOpts)
-			if flAttach.Len() != 0 {
-				return ErrConflictAttachDetach
-			}
-		}
-		if opts.autoRemove {
-			return ErrConflictDetachAutoRemove
-		}
-
-		config.AttachStdin = false
-		config.AttachStdout = false
-		config.AttachStderr = false
-		config.StdinOnce = false
-	}
-
-	// Disable sigProxy when in TTY mode
-	if config.Tty {
-		opts.sigProxy = false
-	}
-
-	// Telling the Windows daemon the initial size of the tty during start makes
-	// a far better user experience rather than relying on subsequent resizes
-	// to cause things to catch up.
-	if runtime.GOOS == "windows" {
-		hostConfig.ConsoleSize[0], hostConfig.ConsoleSize[1] = dockerCli.GetTtySize()
-	}
-
-	ctx, cancelFun := context.WithCancel(context.Background())
-
-	createResponse, err := createContainer(ctx, dockerCli, config, hostConfig, networkingConfig, hostConfig.ContainerIDFile, opts.name)
-	if err != nil {
-		reportError(stderr, cmdPath, err.Error(), true)
-		return runStartContainerErr(err)
-	}
-	if opts.sigProxy {
-		sigc := dockerCli.ForwardAllSignals(ctx, createResponse.ID)
-		defer signal.StopCatch(sigc)
-	}
-	var (
-		waitDisplayID chan struct{}
-		errCh         chan error
-	)
-	if !config.AttachStdout && !config.AttachStderr {
-		// Make this asynchronous to allow the client to write to stdin before having to read the ID
-		waitDisplayID = make(chan struct{})
-		go func() {
-			defer close(waitDisplayID)
-			fmt.Fprintf(stdout, "%s\n", createResponse.ID)
-		}()
-	}
-	if opts.autoRemove && (hostConfig.RestartPolicy.IsAlways() || hostConfig.RestartPolicy.IsOnFailure()) {
-		return ErrConflictRestartPolicyAndAutoRemove
-	}
-	attach := config.AttachStdin || config.AttachStdout || config.AttachStderr
-	if attach {
-		var (
-			out, cerr io.Writer
-			in        io.ReadCloser
-		)
-		if config.AttachStdin {
-			in = stdin
-		}
-		if config.AttachStdout {
-			out = stdout
-		}
-		if config.AttachStderr {
-			if config.Tty {
-				cerr = stdout
-			} else {
-				cerr = stderr
-			}
-		}
-
-		if opts.detachKeys != "" {
-			dockerCli.ConfigFile().DetachKeys = opts.detachKeys
-		}
-
-		options := types.ContainerAttachOptions{
-			Stream:     true,
-			Stdin:      config.AttachStdin,
-			Stdout:     config.AttachStdout,
-			Stderr:     config.AttachStderr,
-			DetachKeys: dockerCli.ConfigFile().DetachKeys,
-		}
-
-		resp, errAttach := client.ContainerAttach(ctx, createResponse.ID, options)
-		if errAttach != nil && errAttach != httputil.ErrPersistEOF {
-			// ContainerAttach returns an ErrPersistEOF (connection closed)
-			// means server met an error and put it in Hijacked connection
-			// keep the error and read detailed error message from hijacked connection later
-			return errAttach
-		}
-		defer resp.Close()
-
-		errCh = promise.Go(func() error {
-			errHijack := dockerCli.HoldHijackedConnection(ctx, config.Tty, in, out, cerr, resp)
-			if errHijack == nil {
-				return errAttach
-			}
-			return errHijack
-		})
-	}
-
-	if opts.autoRemove {
-		defer func() {
-			// Explicitly not sharing the context as it could be "Done" (by calling cancelFun)
-			// and thus the container would not be removed.
-			if err := removeContainer(dockerCli, context.Background(), createResponse.ID, true, false, true); err != nil {
-				fmt.Fprintf(stderr, "%v\n", err)
-			}
-		}()
-	}
-
-	//start the container
-	if err := client.ContainerStart(ctx, createResponse.ID, types.ContainerStartOptions{}); err != nil {
-		// If we have holdHijackedConnection, we should notify
-		// holdHijackedConnection we are going to exit and wait
-		// to avoid the terminal are not restored.
-		if attach {
-			cancelFun()
-			<-errCh
-		}
-
-		reportError(stderr, cmdPath, err.Error(), false)
-		return runStartContainerErr(err)
-	}
-
-	if (config.AttachStdin || config.AttachStdout || config.AttachStderr) && config.Tty && dockerCli.IsTerminalOut() {
-		if err := dockerCli.MonitorTtySize(ctx, createResponse.ID, false); err != nil {
-			fmt.Fprintf(stderr, "Error monitoring TTY size: %s\n", err)
-		}
-	}
-
-	if errCh != nil {
-		if err := <-errCh; err != nil {
-			logrus.Debugf("Error hijack: %s", err)
-			return err
-		}
-	}
-
-	// Detached mode: wait for the id to be displayed and return.
-	if !config.AttachStdout && !config.AttachStderr {
-		// Detached mode
-		<-waitDisplayID
-		return nil
-	}
-
-	var status int
-
-	// Attached mode
-	if opts.autoRemove {
-		// Autoremove: wait for the container to finish, retrieve
-		// the exit code and remove the container
-		if status, err = client.ContainerWait(ctx, createResponse.ID); err != nil {
-			return runStartContainerErr(err)
-		}
-		if _, status, err = getExitCode(dockerCli, ctx, createResponse.ID); err != nil {
-			return err
-		}
-	} else {
-		// No Autoremove: Simply retrieve the exit code
-		if !config.Tty && hostConfig.RestartPolicy.IsNone() {
-			// In non-TTY mode, we can't detach, so we must wait for container exit
-			if status, err = client.ContainerWait(ctx, createResponse.ID); err != nil {
-				return err
-			}
-		} else {
-			// In TTY mode, there is a race: if the process dies too slowly, the state could
-			// be updated after the getExitCode call and result in the wrong exit code being reported
-			if _, status, err = getExitCode(dockerCli, ctx, createResponse.ID); err != nil {
-				return err
-			}
-		}
-	}
-	if status != 0 {
-		return cli.StatusError{StatusCode: status}
-	}
-	return nil
-}
-
-// reportError is a utility method that prints a user-friendly message
-// containing the error that occurred during parsing and a suggestion to get help
-func reportError(stderr io.Writer, name string, str string, withHelp bool) {
-	if withHelp {
-		str += ".\nSee '" + os.Args[0] + " " + name + " --help'"
-	}
-	fmt.Fprintf(stderr, "%s: %s.\n", os.Args[0], str)
-}
-
-// if container start fails with 'not found'/'no such' error, return 127
-// if container start fails with 'permission denied' error, return 126
-// return 125 for generic docker daemon failures
-func runStartContainerErr(err error) error {
-	trimmedErr := strings.TrimPrefix(err.Error(), "Error response from daemon: ")
-	statusError := cli.StatusError{StatusCode: 125}
-	if strings.Contains(trimmedErr, "executable file not found") ||
-		strings.Contains(trimmedErr, "no such file or directory") ||
-		strings.Contains(trimmedErr, "system cannot find the file specified") {
-		statusError = cli.StatusError{StatusCode: 127}
-	} else if strings.Contains(trimmedErr, syscall.EACCES.Error()) {
-		statusError = cli.StatusError{StatusCode: 126}
-	}
-
-	return statusError
-}
--- a/api/client/container/start.go
+++ b/api/client/container/start.go
@@ -1,152 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"io"
-	"net/http/httputil"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/promise"
-	"github.com/docker/docker/pkg/signal"
-	"github.com/docker/engine-api/types"
-	"github.com/spf13/cobra"
-)
-
-type startOptions struct {
-	attach     bool
-	openStdin  bool
-	detachKeys string
-
-	containers []string
-}
-
-// NewStartCommand creats a new cobra.Command for `docker start`
-func NewStartCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts startOptions
-
-	cmd := &cobra.Command{
-		Use:   "start [OPTIONS] CONTAINER [CONTAINER...]",
-		Short: "Start one or more stopped containers",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.containers = args
-			return runStart(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.BoolVarP(&opts.attach, "attach", "a", false, "Attach STDOUT/STDERR and forward signals")
-	flags.BoolVarP(&opts.openStdin, "interactive", "i", false, "Attach container's STDIN")
-	flags.StringVar(&opts.detachKeys, "detach-keys", "", "Override the key sequence for detaching a container")
-	return cmd
-}
-
-func runStart(dockerCli *client.DockerCli, opts *startOptions) error {
-	ctx, cancelFun := context.WithCancel(context.Background())
-
-	if opts.attach || opts.openStdin {
-		// We're going to attach to a container.
-		// 1. Ensure we only have one container.
-		if len(opts.containers) > 1 {
-			return fmt.Errorf("You cannot start and attach multiple containers at once.")
-		}
-
-		// 2. Attach to the container.
-		container := opts.containers[0]
-		c, err := dockerCli.Client().ContainerInspect(ctx, container)
-		if err != nil {
-			return err
-		}
-
-		// We always use c.ID instead of container to maintain consistency during `docker start`
-		if !c.Config.Tty {
-			sigc := dockerCli.ForwardAllSignals(ctx, c.ID)
-			defer signal.StopCatch(sigc)
-		}
-
-		if opts.detachKeys != "" {
-			dockerCli.ConfigFile().DetachKeys = opts.detachKeys
-		}
-
-		options := types.ContainerAttachOptions{
-			Stream:     true,
-			Stdin:      opts.openStdin && c.Config.OpenStdin,
-			Stdout:     true,
-			Stderr:     true,
-			DetachKeys: dockerCli.ConfigFile().DetachKeys,
-		}
-
-		var in io.ReadCloser
-
-		if options.Stdin {
-			in = dockerCli.In()
-		}
-
-		resp, errAttach := dockerCli.Client().ContainerAttach(ctx, c.ID, options)
-		if errAttach != nil && errAttach != httputil.ErrPersistEOF {
-			// ContainerAttach return an ErrPersistEOF (connection closed)
-			// means server met an error and put it in Hijacked connection
-			// keep the error and read detailed error message from hijacked connection
-			return errAttach
-		}
-		defer resp.Close()
-		cErr := promise.Go(func() error {
-			errHijack := dockerCli.HoldHijackedConnection(ctx, c.Config.Tty, in, dockerCli.Out(), dockerCli.Err(), resp)
-			if errHijack == nil {
-				return errAttach
-			}
-			return errHijack
-		})
-
-		// 3. Start the container.
-		if err := dockerCli.Client().ContainerStart(ctx, c.ID, types.ContainerStartOptions{}); err != nil {
-			cancelFun()
-			<-cErr
-			return err
-		}
-
-		// 4. Wait for attachment to break.
-		if c.Config.Tty && dockerCli.IsTerminalOut() {
-			if err := dockerCli.MonitorTtySize(ctx, c.ID, false); err != nil {
-				fmt.Fprintf(dockerCli.Err(), "Error monitoring TTY size: %s\n", err)
-			}
-		}
-		if attchErr := <-cErr; attchErr != nil {
-			return attchErr
-		}
-		_, status, err := getExitCode(dockerCli, ctx, c.ID)
-		if err != nil {
-			return err
-		}
-		if status != 0 {
-			return cli.StatusError{StatusCode: status}
-		}
-	} else {
-		// We're not going to attach to anything.
-		// Start as many containers as we want.
-		return startContainersWithoutAttachments(dockerCli, ctx, opts.containers)
-	}
-
-	return nil
-}
-
-func startContainersWithoutAttachments(dockerCli *client.DockerCli, ctx context.Context, containers []string) error {
-	var failedContainers []string
-	for _, container := range containers {
-		if err := dockerCli.Client().ContainerStart(ctx, container, types.ContainerStartOptions{}); err != nil {
-			fmt.Fprintf(dockerCli.Err(), "%s\n", err)
-			failedContainers = append(failedContainers, container)
-		} else {
-			fmt.Fprintf(dockerCli.Out(), "%s\n", container)
-		}
-	}
-
-	if len(failedContainers) > 0 {
-		return fmt.Errorf("Error: failed to start containers: %v", strings.Join(failedContainers, ", "))
-	}
-	return nil
-}
--- a/api/client/container/stats.go
+++ b/api/client/container/stats.go
@@ -1,233 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"io"
-	"strings"
-	"sync"
-	"text/tabwriter"
-	"time"
-
-	"golang.org/x/net/context"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/api/client/system"
-	"github.com/docker/docker/cli"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/events"
-	"github.com/docker/engine-api/types/filters"
-	"github.com/spf13/cobra"
-)
-
-type statsOptions struct {
-	all      bool
-	noStream bool
-
-	containers []string
-}
-
-// NewStatsCommand creats a new cobra.Command for `docker stats`
-func NewStatsCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts statsOptions
-
-	cmd := &cobra.Command{
-		Use:   "stats [OPTIONS] [CONTAINER...]",
-		Short: "Display a live stream of container(s) resource usage statistics",
-		Args:  cli.RequiresMinArgs(0),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.containers = args
-			return runStats(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.BoolVarP(&opts.all, "all", "a", false, "Show all containers (default shows just running)")
-	flags.BoolVar(&opts.noStream, "no-stream", false, "Disable streaming stats and only pull the first result")
-	return cmd
-}
-
-// runStats displays a live stream of resource usage statistics for one or more containers.
-// This shows real-time information on CPU usage, memory usage, and network I/O.
-func runStats(dockerCli *client.DockerCli, opts *statsOptions) error {
-	showAll := len(opts.containers) == 0
-	closeChan := make(chan error)
-
-	ctx := context.Background()
-
-	// monitorContainerEvents watches for container creation and removal (only
-	// used when calling `docker stats` without arguments).
-	monitorContainerEvents := func(started chan<- struct{}, c chan events.Message) {
-		f := filters.NewArgs()
-		f.Add("type", "container")
-		options := types.EventsOptions{
-			Filters: f,
-		}
-		resBody, err := dockerCli.Client().Events(ctx, options)
-		// Whether we successfully subscribed to events or not, we can now
-		// unblock the main goroutine.
-		close(started)
-		if err != nil {
-			closeChan <- err
-			return
-		}
-		defer resBody.Close()
-
-		system.DecodeEvents(resBody, func(event events.Message, err error) error {
-			if err != nil {
-				closeChan <- err
-				return nil
-			}
-			c <- event
-			return nil
-		})
-	}
-
-	// waitFirst is a WaitGroup to wait first stat data's reach for each container
-	waitFirst := &sync.WaitGroup{}
-
-	cStats := stats{}
-	// getContainerList simulates creation event for all previously existing
-	// containers (only used when calling `docker stats` without arguments).
-	getContainerList := func() {
-		options := types.ContainerListOptions{
-			All: opts.all,
-		}
-		cs, err := dockerCli.Client().ContainerList(ctx, options)
-		if err != nil {
-			closeChan <- err
-		}
-		for _, container := range cs {
-			s := &containerStats{Name: container.ID[:12]}
-			if cStats.add(s) {
-				waitFirst.Add(1)
-				go s.Collect(ctx, dockerCli.Client(), !opts.noStream, waitFirst)
-			}
-		}
-	}
-
-	if showAll {
-		// If no names were specified, start a long running goroutine which
-		// monitors container events. We make sure we're subscribed before
-		// retrieving the list of running containers to avoid a race where we
-		// would "miss" a creation.
-		started := make(chan struct{})
-		eh := system.InitEventHandler()
-		eh.Handle("create", func(e events.Message) {
-			if opts.all {
-				s := &containerStats{Name: e.ID[:12]}
-				if cStats.add(s) {
-					waitFirst.Add(1)
-					go s.Collect(ctx, dockerCli.Client(), !opts.noStream, waitFirst)
-				}
-			}
-		})
-
-		eh.Handle("start", func(e events.Message) {
-			s := &containerStats{Name: e.ID[:12]}
-			if cStats.add(s) {
-				waitFirst.Add(1)
-				go s.Collect(ctx, dockerCli.Client(), !opts.noStream, waitFirst)
-			}
-		})
-
-		eh.Handle("die", func(e events.Message) {
-			if !opts.all {
-				cStats.remove(e.ID[:12])
-			}
-		})
-
-		eventChan := make(chan events.Message)
-		go eh.Watch(eventChan)
-		go monitorContainerEvents(started, eventChan)
-		defer close(eventChan)
-		<-started
-
-		// Start a short-lived goroutine to retrieve the initial list of
-		// containers.
-		getContainerList()
-	} else {
-		// Artificially send creation events for the containers we were asked to
-		// monitor (same code path than we use when monitoring all containers).
-		for _, name := range opts.containers {
-			s := &containerStats{Name: name}
-			if cStats.add(s) {
-				waitFirst.Add(1)
-				go s.Collect(ctx, dockerCli.Client(), !opts.noStream, waitFirst)
-			}
-		}
-
-		// We don't expect any asynchronous errors: closeChan can be closed.
-		close(closeChan)
-
-		// Do a quick pause to detect any error with the provided list of
-		// container names.
-		time.Sleep(1500 * time.Millisecond)
-		var errs []string
-		cStats.mu.Lock()
-		for _, c := range cStats.cs {
-			c.mu.Lock()
-			if c.err != nil {
-				errs = append(errs, fmt.Sprintf("%s: %v", c.Name, c.err))
-			}
-			c.mu.Unlock()
-		}
-		cStats.mu.Unlock()
-		if len(errs) > 0 {
-			return fmt.Errorf("%s", strings.Join(errs, ", "))
-		}
-	}
-
-	// before print to screen, make sure each container get at least one valid stat data
-	waitFirst.Wait()
-
-	w := tabwriter.NewWriter(dockerCli.Out(), 20, 1, 3, ' ', 0)
-	printHeader := func() {
-		if !opts.noStream {
-			fmt.Fprint(dockerCli.Out(), "\033[2J")
-			fmt.Fprint(dockerCli.Out(), "\033[H")
-		}
-		io.WriteString(w, "CONTAINER\tCPU %\tMEM USAGE / LIMIT\tMEM %\tNET I/O\tBLOCK I/O\tPIDS\n")
-	}
-
-	for range time.Tick(500 * time.Millisecond) {
-		printHeader()
-		toRemove := []string{}
-		cStats.mu.Lock()
-		for _, s := range cStats.cs {
-			if err := s.Display(w); err != nil && !opts.noStream {
-				logrus.Debugf("stats: got error for %s: %v", s.Name, err)
-				if err == io.EOF {
-					toRemove = append(toRemove, s.Name)
-				}
-			}
-		}
-		cStats.mu.Unlock()
-		for _, name := range toRemove {
-			cStats.remove(name)
-		}
-		if len(cStats.cs) == 0 && !showAll {
-			return nil
-		}
-		w.Flush()
-		if opts.noStream {
-			break
-		}
-		select {
-		case err, ok := <-closeChan:
-			if ok {
-				if err != nil {
-					// this is suppressing "unexpected EOF" in the cli when the
-					// daemon restarts so it shutdowns cleanly
-					if err == io.ErrUnexpectedEOF {
-						return nil
-					}
-					return err
-				}
-			}
-		default:
-			// just skip
-		}
-	}
-	return nil
-}
--- a/api/client/container/stats_helpers.go
+++ b/api/client/container/stats_helpers.go
@@ -1,238 +0,0 @@
-package container
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/engine-api/client"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/go-units"
-	"golang.org/x/net/context"
-)
-
-type containerStats struct {
-	Name             string
-	CPUPercentage    float64
-	Memory           float64
-	MemoryLimit      float64
-	MemoryPercentage float64
-	NetworkRx        float64
-	NetworkTx        float64
-	BlockRead        float64
-	BlockWrite       float64
-	PidsCurrent      uint64
-	mu               sync.Mutex
-	err              error
-}
-
-type stats struct {
-	mu sync.Mutex
-	cs []*containerStats
-}
-
-func (s *stats) add(cs *containerStats) bool {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if _, exists := s.isKnownContainer(cs.Name); !exists {
-		s.cs = append(s.cs, cs)
-		return true
-	}
-	return false
-}
-
-func (s *stats) remove(id string) {
-	s.mu.Lock()
-	if i, exists := s.isKnownContainer(id); exists {
-		s.cs = append(s.cs[:i], s.cs[i+1:]...)
-	}
-	s.mu.Unlock()
-}
-
-func (s *stats) isKnownContainer(cid string) (int, bool) {
-	for i, c := range s.cs {
-		if c.Name == cid {
-			return i, true
-		}
-	}
-	return -1, false
-}
-
-func (s *containerStats) Collect(ctx context.Context, cli client.APIClient, streamStats bool, waitFirst *sync.WaitGroup) {
-	logrus.Debugf("collecting stats for %s", s.Name)
-	var (
-		getFirst       bool
-		previousCPU    uint64
-		previousSystem uint64
-		u              = make(chan error, 1)
-	)
-
-	defer func() {
-		// if error happens and we get nothing of stats, release wait group whatever
-		if !getFirst {
-			getFirst = true
-			waitFirst.Done()
-		}
-	}()
-
-	responseBody, err := cli.ContainerStats(ctx, s.Name, streamStats)
-	if err != nil {
-		s.mu.Lock()
-		s.err = err
-		s.mu.Unlock()
-		return
-	}
-	defer responseBody.Close()
-
-	dec := json.NewDecoder(responseBody)
-	go func() {
-		for {
-			var v *types.StatsJSON
-
-			if err := dec.Decode(&v); err != nil {
-				dec = json.NewDecoder(io.MultiReader(dec.Buffered(), responseBody))
-				u <- err
-				if err == io.EOF {
-					break
-				}
-				time.Sleep(100 * time.Millisecond)
-				continue
-			}
-
-			var memPercent = 0.0
-			var cpuPercent = 0.0
-
-			// MemoryStats.Limit will never be 0 unless the container is not running and we haven't
-			// got any data from cgroup
-			if v.MemoryStats.Limit != 0 {
-				memPercent = float64(v.MemoryStats.Usage) / float64(v.MemoryStats.Limit) * 100.0
-			}
-
-			previousCPU = v.PreCPUStats.CPUUsage.TotalUsage
-			previousSystem = v.PreCPUStats.SystemUsage
-			cpuPercent = calculateCPUPercent(previousCPU, previousSystem, v)
-			blkRead, blkWrite := calculateBlockIO(v.BlkioStats)
-			s.mu.Lock()
-			s.CPUPercentage = cpuPercent
-			s.Memory = float64(v.MemoryStats.Usage)
-			s.MemoryLimit = float64(v.MemoryStats.Limit)
-			s.MemoryPercentage = memPercent
-			s.NetworkRx, s.NetworkTx = calculateNetwork(v.Networks)
-			s.BlockRead = float64(blkRead)
-			s.BlockWrite = float64(blkWrite)
-			s.PidsCurrent = v.PidsStats.Current
-			s.mu.Unlock()
-			u <- nil
-			if !streamStats {
-				return
-			}
-		}
-	}()
-	for {
-		select {
-		case <-time.After(2 * time.Second):
-			// zero out the values if we have not received an update within
-			// the specified duration.
-			s.mu.Lock()
-			s.CPUPercentage = 0
-			s.Memory = 0
-			s.MemoryPercentage = 0
-			s.MemoryLimit = 0
-			s.NetworkRx = 0
-			s.NetworkTx = 0
-			s.BlockRead = 0
-			s.BlockWrite = 0
-			s.PidsCurrent = 0
-			s.err = errors.New("timeout waiting for stats")
-			s.mu.Unlock()
-			// if this is the first stat you get, release WaitGroup
-			if !getFirst {
-				getFirst = true
-				waitFirst.Done()
-			}
-		case err := <-u:
-			if err != nil {
-				s.mu.Lock()
-				s.err = err
-				s.mu.Unlock()
-				continue
-			}
-			s.err = nil
-			// if this is the first stat you get, release WaitGroup
-			if !getFirst {
-				getFirst = true
-				waitFirst.Done()
-			}
-		}
-		if !streamStats {
-			return
-		}
-	}
-}
-
-func (s *containerStats) Display(w io.Writer) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	// NOTE: if you change this format, you must also change the err format below!
-	format := "%s\t%.2f%%\t%s / %s\t%.2f%%\t%s / %s\t%s / %s\t%d\n"
-	if s.err != nil {
-		format = "%s\t%s\t%s / %s\t%s\t%s / %s\t%s / %s\t%s\n"
-		errStr := "--"
-		fmt.Fprintf(w, format,
-			s.Name, errStr, errStr, errStr, errStr, errStr, errStr, errStr, errStr, errStr,
-		)
-		err := s.err
-		return err
-	}
-	fmt.Fprintf(w, format,
-		s.Name,
-		s.CPUPercentage,
-		units.BytesSize(s.Memory), units.BytesSize(s.MemoryLimit),
-		s.MemoryPercentage,
-		units.HumanSize(s.NetworkRx), units.HumanSize(s.NetworkTx),
-		units.HumanSize(s.BlockRead), units.HumanSize(s.BlockWrite),
-		s.PidsCurrent)
-	return nil
-}
-
-func calculateCPUPercent(previousCPU, previousSystem uint64, v *types.StatsJSON) float64 {
-	var (
-		cpuPercent = 0.0
-		// calculate the change for the cpu usage of the container in between readings
-		cpuDelta = float64(v.CPUStats.CPUUsage.TotalUsage) - float64(previousCPU)
-		// calculate the change for the entire system between readings
-		systemDelta = float64(v.CPUStats.SystemUsage) - float64(previousSystem)
-	)
-
-	if systemDelta > 0.0 && cpuDelta > 0.0 {
-		cpuPercent = (cpuDelta / systemDelta) * float64(len(v.CPUStats.CPUUsage.PercpuUsage)) * 100.0
-	}
-	return cpuPercent
-}
-
-func calculateBlockIO(blkio types.BlkioStats) (blkRead uint64, blkWrite uint64) {
-	for _, bioEntry := range blkio.IoServiceBytesRecursive {
-		switch strings.ToLower(bioEntry.Op) {
-		case "read":
-			blkRead = blkRead + bioEntry.Value
-		case "write":
-			blkWrite = blkWrite + bioEntry.Value
-		}
-	}
-	return
-}
-
-func calculateNetwork(network map[string]types.NetworkStats) (float64, float64) {
-	var rx, tx float64
-
-	for _, v := range network {
-		rx += float64(v.RxBytes)
-		tx += float64(v.TxBytes)
-	}
-	return rx, tx
-}
--- a/api/client/container/stats_unit_test.go
+++ b/api/client/container/stats_unit_test.go
@@ -1,45 +0,0 @@
-package container
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/docker/engine-api/types"
-)
-
-func TestDisplay(t *testing.T) {
-	c := &containerStats{
-		Name:             "app",
-		CPUPercentage:    30.0,
-		Memory:           100 * 1024 * 1024.0,
-		MemoryLimit:      2048 * 1024 * 1024.0,
-		MemoryPercentage: 100.0 / 2048.0 * 100.0,
-		NetworkRx:        100 * 1024 * 1024,
-		NetworkTx:        800 * 1024 * 1024,
-		BlockRead:        100 * 1024 * 1024,
-		BlockWrite:       800 * 1024 * 1024,
-		PidsCurrent:      1,
-	}
-	var b bytes.Buffer
-	if err := c.Display(&b); err != nil {
-		t.Fatalf("c.Display() gave error: %s", err)
-	}
-	got := b.String()
-	want := "app\t30.00%\t100 MiB / 2 GiB\t4.88%\t104.9 MB / 838.9 MB\t104.9 MB / 838.9 MB\t1\n"
-	if got != want {
-		t.Fatalf("c.Display() = %q, want %q", got, want)
-	}
-}
-
-func TestCalculBlockIO(t *testing.T) {
-	blkio := types.BlkioStats{
-		IoServiceBytesRecursive: []types.BlkioStatEntry{{8, 0, "read", 1234}, {8, 1, "read", 4567}, {8, 0, "write", 123}, {8, 1, "write", 456}},
-	}
-	blkRead, blkWrite := calculateBlockIO(blkio)
-	if blkRead != 5801 {
-		t.Fatalf("blkRead = %d, want 5801", blkRead)
-	}
-	if blkWrite != 579 {
-		t.Fatalf("blkWrite = %d, want 579", blkWrite)
-	}
-}
--- a/api/client/container/stop.go
+++ b/api/client/container/stop.go
@@ -1,56 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type stopOptions struct {
-	time int
-
-	containers []string
-}
-
-// NewStopCommand creats a new cobra.Command for `docker stop`
-func NewStopCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts stopOptions
-
-	cmd := &cobra.Command{
-		Use:   "stop [OPTIONS] CONTAINER [CONTAINER...]",
-		Short: "Stop one or more running containers",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.containers = args
-			return runStop(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.IntVarP(&opts.time, "time", "t", 10, "Seconds to wait for stop before killing it")
-	return cmd
-}
-
-func runStop(dockerCli *client.DockerCli, opts *stopOptions) error {
-	ctx := context.Background()
-
-	var errs []string
-	for _, container := range opts.containers {
-		timeout := time.Duration(opts.time) * time.Second
-		if err := dockerCli.Client().ContainerStop(ctx, container, &timeout); err != nil {
-			errs = append(errs, err.Error())
-		} else {
-			fmt.Fprintf(dockerCli.Out(), "%s\n", container)
-		}
-	}
-	if len(errs) > 0 {
-		return fmt.Errorf("%s", strings.Join(errs, "\n"))
-	}
-	return nil
-}
--- a/api/client/container/top.go
+++ b/api/client/container/top.go
@@ -1,58 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"strings"
-	"text/tabwriter"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type topOptions struct {
-	container string
-
-	args []string
-}
-
-// NewTopCommand creates a new cobra.Command for `docker top`
-func NewTopCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts topOptions
-
-	cmd := &cobra.Command{
-		Use:   "top CONTAINER [ps OPTIONS]",
-		Short: "Display the running processes of a container",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.container = args[0]
-			opts.args = args[1:]
-			return runTop(dockerCli, &opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.SetInterspersed(false)
-
-	return cmd
-}
-
-func runTop(dockerCli *client.DockerCli, opts *topOptions) error {
-	ctx := context.Background()
-
-	procList, err := dockerCli.Client().ContainerTop(ctx, opts.container, opts.args)
-	if err != nil {
-		return err
-	}
-
-	w := tabwriter.NewWriter(dockerCli.Out(), 20, 1, 3, ' ', 0)
-	fmt.Fprintln(w, strings.Join(procList.Titles, "\t"))
-
-	for _, proc := range procList.Processes {
-		fmt.Fprintln(w, strings.Join(proc, "\t"))
-	}
-	w.Flush()
-	return nil
-}
--- a/api/client/container/unpause.go
+++ b/api/client/container/unpause.go
@@ -1,50 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type unpauseOptions struct {
-	containers []string
-}
-
-// NewUnpauseCommand creats a new cobra.Command for `docker unpause`
-func NewUnpauseCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts unpauseOptions
-
-	cmd := &cobra.Command{
-		Use:   "unpause CONTAINER [CONTAINER...]",
-		Short: "Unpause all processes within one or more containers",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.containers = args
-			return runUnpause(dockerCli, &opts)
-		},
-	}
-
-	return cmd
-}
-
-func runUnpause(dockerCli *client.DockerCli, opts *unpauseOptions) error {
-	ctx := context.Background()
-
-	var errs []string
-	for _, container := range opts.containers {
-		if err := dockerCli.Client().ContainerUnpause(ctx, container); err != nil {
-			errs = append(errs, err.Error())
-		} else {
-			fmt.Fprintf(dockerCli.Out(), "%s\n", container)
-		}
-	}
-	if len(errs) > 0 {
-		return fmt.Errorf("%s", strings.Join(errs, "\n"))
-	}
-	return nil
-}
--- a/api/client/container/utils.go
+++ b/api/client/container/utils.go
@@ -1,22 +0,0 @@
-package container
-
-import (
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	clientapi "github.com/docker/engine-api/client"
-)
-
-// getExitCode performs an inspect on the container. It returns
-// the running state and the exit code.
-func getExitCode(dockerCli *client.DockerCli, ctx context.Context, containerID string) (bool, int, error) {
-	c, err := dockerCli.Client().ContainerInspect(ctx, containerID)
-	if err != nil {
-		// If we can't connect, then the daemon probably died.
-		if err != clientapi.ErrConnectionFailed {
-			return false, -1, err
-		}
-		return false, -1, nil
-	}
-	return c.State.Running, c.State.ExitCode, nil
-}
--- a/api/client/container/wait.go
+++ b/api/client/container/wait.go
@@ -1,51 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type waitOptions struct {
-	containers []string
-}
-
-// NewWaitCommand creates a new cobra.Command for `docker wait`
-func NewWaitCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts waitOptions
-
-	cmd := &cobra.Command{
-		Use:   "wait CONTAINER [CONTAINER...]",
-		Short: "Block until a container stops, then print its exit code",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.containers = args
-			return runWait(dockerCli, &opts)
-		},
-	}
-
-	return cmd
-}
-
-func runWait(dockerCli *client.DockerCli, opts *waitOptions) error {
-	ctx := context.Background()
-
-	var errs []string
-	for _, container := range opts.containers {
-		status, err := dockerCli.Client().ContainerWait(ctx, container)
-		if err != nil {
-			errs = append(errs, err.Error())
-		} else {
-			fmt.Fprintf(dockerCli.Out(), "%d\n", status)
-		}
-	}
-	if len(errs) > 0 {
-		return fmt.Errorf("%s", strings.Join(errs, "\n"))
-	}
-	return nil
-}
--- a/api/client/credentials.go
+++ b/api/client/credentials.go
@@ -1,44 +0,0 @@
-package client
-
-import (
-	"github.com/docker/docker/cliconfig/configfile"
-	"github.com/docker/docker/cliconfig/credentials"
-	"github.com/docker/engine-api/types"
-)
-
-// GetCredentials loads the user credentials from a credentials store.
-// The store is determined by the config file settings.
-func GetCredentials(c *configfile.ConfigFile, serverAddress string) (types.AuthConfig, error) {
-	s := LoadCredentialsStore(c)
-	return s.Get(serverAddress)
-}
-
-// GetAllCredentials loads all credentials from a credentials store.
-// The store is determined by the config file settings.
-func GetAllCredentials(c *configfile.ConfigFile) (map[string]types.AuthConfig, error) {
-	s := LoadCredentialsStore(c)
-	return s.GetAll()
-}
-
-// StoreCredentials saves the user credentials in a credentials store.
-// The store is determined by the config file settings.
-func StoreCredentials(c *configfile.ConfigFile, auth types.AuthConfig) error {
-	s := LoadCredentialsStore(c)
-	return s.Store(auth)
-}
-
-// EraseCredentials removes the user credentials from a credentials store.
-// The store is determined by the config file settings.
-func EraseCredentials(c *configfile.ConfigFile, serverAddress string) error {
-	s := LoadCredentialsStore(c)
-	return s.Erase(serverAddress)
-}
-
-// LoadCredentialsStore initializes a new credentials store based
-// in the settings provided in the configuration file.
-func LoadCredentialsStore(c *configfile.ConfigFile) credentials.Store {
-	if c.CredentialsStore != "" {
-		return credentials.NewNativeStore(c)
-	}
-	return credentials.NewFileStore(c)
-}
--- a/api/client/exec.go
+++ b/api/client/exec.go
@@ -1,160 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"io"
-
-	"golang.org/x/net/context"
-
-	"github.com/Sirupsen/logrus"
-	Cli "github.com/docker/docker/cli"
-	flag "github.com/docker/docker/pkg/mflag"
-	"github.com/docker/docker/pkg/promise"
-	"github.com/docker/engine-api/types"
-)
-
-// CmdExec runs a command in a running container.
-//
-// Usage: docker exec [OPTIONS] CONTAINER COMMAND [ARG...]
-func (cli *DockerCli) CmdExec(args ...string) error {
-	cmd := Cli.Subcmd("exec", []string{"[OPTIONS] CONTAINER COMMAND [ARG...]"}, Cli.DockerCommands["exec"].Description, true)
-	detachKeys := cmd.String([]string{"-detach-keys"}, "", "Override the key sequence for detaching a container")
-
-	execConfig, err := ParseExec(cmd, args)
-	container := cmd.Arg(0)
-	// just in case the ParseExec does not exit
-	if container == "" || err != nil {
-		return Cli.StatusError{StatusCode: 1}
-	}
-
-	if *detachKeys != "" {
-		cli.configFile.DetachKeys = *detachKeys
-	}
-
-	// Send client escape keys
-	execConfig.DetachKeys = cli.configFile.DetachKeys
-
-	ctx := context.Background()
-
-	response, err := cli.client.ContainerExecCreate(ctx, container, *execConfig)
-	if err != nil {
-		return err
-	}
-
-	execID := response.ID
-	if execID == "" {
-		fmt.Fprintf(cli.out, "exec ID empty")
-		return nil
-	}
-
-	//Temp struct for execStart so that we don't need to transfer all the execConfig
-	if !execConfig.Detach {
-		if err := cli.CheckTtyInput(execConfig.AttachStdin, execConfig.Tty); err != nil {
-			return err
-		}
-	} else {
-		execStartCheck := types.ExecStartCheck{
-			Detach: execConfig.Detach,
-			Tty:    execConfig.Tty,
-		}
-
-		if err := cli.client.ContainerExecStart(ctx, execID, execStartCheck); err != nil {
-			return err
-		}
-		// For now don't print this - wait for when we support exec wait()
-		// fmt.Fprintf(cli.out, "%s\n", execID)
-		return nil
-	}
-
-	// Interactive exec requested.
-	var (
-		out, stderr io.Writer
-		in          io.ReadCloser
-		errCh       chan error
-	)
-
-	if execConfig.AttachStdin {
-		in = cli.in
-	}
-	if execConfig.AttachStdout {
-		out = cli.out
-	}
-	if execConfig.AttachStderr {
-		if execConfig.Tty {
-			stderr = cli.out
-		} else {
-			stderr = cli.err
-		}
-	}
-
-	resp, err := cli.client.ContainerExecAttach(ctx, execID, *execConfig)
-	if err != nil {
-		return err
-	}
-	defer resp.Close()
-	errCh = promise.Go(func() error {
-		return cli.HoldHijackedConnection(ctx, execConfig.Tty, in, out, stderr, resp)
-	})
-
-	if execConfig.Tty && cli.isTerminalIn {
-		if err := cli.MonitorTtySize(ctx, execID, true); err != nil {
-			fmt.Fprintf(cli.err, "Error monitoring TTY size: %s\n", err)
-		}
-	}
-
-	if err := <-errCh; err != nil {
-		logrus.Debugf("Error hijack: %s", err)
-		return err
-	}
-
-	var status int
-	if _, status, err = cli.getExecExitCode(ctx, execID); err != nil {
-		return err
-	}
-
-	if status != 0 {
-		return Cli.StatusError{StatusCode: status}
-	}
-
-	return nil
-}
-
-// ParseExec parses the specified args for the specified command and generates
-// an ExecConfig from it.
-// If the minimal number of specified args is not right or if specified args are
-// not valid, it will return an error.
-func ParseExec(cmd *flag.FlagSet, args []string) (*types.ExecConfig, error) {
-	var (
-		flStdin      = cmd.Bool([]string{"i", "-interactive"}, false, "Keep STDIN open even if not attached")
-		flTty        = cmd.Bool([]string{"t", "-tty"}, false, "Allocate a pseudo-TTY")
-		flDetach     = cmd.Bool([]string{"d", "-detach"}, false, "Detached mode: run command in the background")
-		flUser       = cmd.String([]string{"u", "-user"}, "", "Username or UID (format: <name|uid>[:<group|gid>])")
-		flPrivileged = cmd.Bool([]string{"-privileged"}, false, "Give extended privileges to the command")
-		execCmd      []string
-	)
-	cmd.Require(flag.Min, 2)
-	if err := cmd.ParseFlags(args, true); err != nil {
-		return nil, err
-	}
-	parsedArgs := cmd.Args()
-	execCmd = parsedArgs[1:]
-
-	execConfig := &types.ExecConfig{
-		User:       *flUser,
-		Privileged: *flPrivileged,
-		Tty:        *flTty,
-		Cmd:        execCmd,
-		Detach:     *flDetach,
-	}
-
-	// If -d is not set, attach to everything by default
-	if !*flDetach {
-		execConfig.AttachStdout = true
-		execConfig.AttachStderr = true
-		if *flStdin {
-			execConfig.AttachStdin = true
-		}
-	}
-
-	return execConfig, nil
-}
--- a/api/client/exec_test.go
+++ b/api/client/exec_test.go
@@ -1,122 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"io/ioutil"
-	"testing"
-
-	flag "github.com/docker/docker/pkg/mflag"
-	"github.com/docker/engine-api/types"
-)
-
-type arguments struct {
-	args []string
-}
-
-func TestParseExec(t *testing.T) {
-	invalids := map[*arguments]error{
-		&arguments{[]string{"-unknown"}}: fmt.Errorf("flag provided but not defined: -unknown"),
-		&arguments{[]string{"-u"}}:       fmt.Errorf("flag needs an argument: -u"),
-		&arguments{[]string{"--user"}}:   fmt.Errorf("flag needs an argument: --user"),
-	}
-	valids := map[*arguments]*types.ExecConfig{
-		&arguments{
-			[]string{"container", "command"},
-		}: {
-			Cmd:          []string{"command"},
-			AttachStdout: true,
-			AttachStderr: true,
-		},
-		&arguments{
-			[]string{"container", "command1", "command2"},
-		}: {
-			Cmd:          []string{"command1", "command2"},
-			AttachStdout: true,
-			AttachStderr: true,
-		},
-		&arguments{
-			[]string{"-i", "-t", "-u", "uid", "container", "command"},
-		}: {
-			User:         "uid",
-			AttachStdin:  true,
-			AttachStdout: true,
-			AttachStderr: true,
-			Tty:          true,
-			Cmd:          []string{"command"},
-		},
-		&arguments{
-			[]string{"-d", "container", "command"},
-		}: {
-			AttachStdin:  false,
-			AttachStdout: false,
-			AttachStderr: false,
-			Detach:       true,
-			Cmd:          []string{"command"},
-		},
-		&arguments{
-			[]string{"-t", "-i", "-d", "container", "command"},
-		}: {
-			AttachStdin:  false,
-			AttachStdout: false,
-			AttachStderr: false,
-			Detach:       true,
-			Tty:          true,
-			Cmd:          []string{"command"},
-		},
-	}
-	for invalid, expectedError := range invalids {
-		cmd := flag.NewFlagSet("exec", flag.ContinueOnError)
-		cmd.ShortUsage = func() {}
-		cmd.SetOutput(ioutil.Discard)
-		_, err := ParseExec(cmd, invalid.args)
-		if err == nil || err.Error() != expectedError.Error() {
-			t.Fatalf("Expected an error [%v] for %v, got %v", expectedError, invalid, err)
-		}
-
-	}
-	for valid, expectedExecConfig := range valids {
-		cmd := flag.NewFlagSet("exec", flag.ContinueOnError)
-		cmd.ShortUsage = func() {}
-		cmd.SetOutput(ioutil.Discard)
-		execConfig, err := ParseExec(cmd, valid.args)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !compareExecConfig(expectedExecConfig, execConfig) {
-			t.Fatalf("Expected [%v] for %v, got [%v]", expectedExecConfig, valid, execConfig)
-		}
-	}
-}
-
-func compareExecConfig(config1 *types.ExecConfig, config2 *types.ExecConfig) bool {
-	if config1.AttachStderr != config2.AttachStderr {
-		return false
-	}
-	if config1.AttachStdin != config2.AttachStdin {
-		return false
-	}
-	if config1.AttachStdout != config2.AttachStdout {
-		return false
-	}
-	if config1.Detach != config2.Detach {
-		return false
-	}
-	if config1.Privileged != config2.Privileged {
-		return false
-	}
-	if config1.Tty != config2.Tty {
-		return false
-	}
-	if config1.User != config2.User {
-		return false
-	}
-	if len(config1.Cmd) != len(config2.Cmd) {
-		return false
-	}
-	for index, value := range config1.Cmd {
-		if value != config2.Cmd[index] {
-			return false
-		}
-	}
-	return true
-}
--- a/api/client/formatter/custom.go
+++ b/api/client/formatter/custom.go
@@ -1,243 +0,0 @@
-package formatter
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/docker/docker/api"
-	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/docker/pkg/stringutils"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/go-units"
-)
-
-const (
-	tableKey = "table"
-
-	containerIDHeader  = "CONTAINER ID"
-	imageHeader        = "IMAGE"
-	namesHeader        = "NAMES"
-	commandHeader      = "COMMAND"
-	createdSinceHeader = "CREATED"
-	createdAtHeader    = "CREATED AT"
-	runningForHeader   = "CREATED"
-	statusHeader       = "STATUS"
-	portsHeader        = "PORTS"
-	sizeHeader         = "SIZE"
-	labelsHeader       = "LABELS"
-	imageIDHeader      = "IMAGE ID"
-	repositoryHeader   = "REPOSITORY"
-	tagHeader          = "TAG"
-	digestHeader       = "DIGEST"
-	mountsHeader       = "MOUNTS"
-)
-
-type containerContext struct {
-	baseSubContext
-	trunc bool
-	c     types.Container
-}
-
-func (c *containerContext) ID() string {
-	c.addHeader(containerIDHeader)
-	if c.trunc {
-		return stringid.TruncateID(c.c.ID)
-	}
-	return c.c.ID
-}
-
-func (c *containerContext) Names() string {
-	c.addHeader(namesHeader)
-	names := stripNamePrefix(c.c.Names)
-	if c.trunc {
-		for _, name := range names {
-			if len(strings.Split(name, "/")) == 1 {
-				names = []string{name}
-				break
-			}
-		}
-	}
-	return strings.Join(names, ",")
-}
-
-func (c *containerContext) Image() string {
-	c.addHeader(imageHeader)
-	if c.c.Image == "" {
-		return "<no image>"
-	}
-	if c.trunc {
-		if trunc := stringid.TruncateID(c.c.ImageID); trunc == stringid.TruncateID(c.c.Image) {
-			return trunc
-		}
-	}
-	return c.c.Image
-}
-
-func (c *containerContext) Command() string {
-	c.addHeader(commandHeader)
-	command := c.c.Command
-	if c.trunc {
-		command = stringutils.Truncate(command, 20)
-	}
-	return strconv.Quote(command)
-}
-
-func (c *containerContext) CreatedAt() string {
-	c.addHeader(createdAtHeader)
-	return time.Unix(int64(c.c.Created), 0).String()
-}
-
-func (c *containerContext) RunningFor() string {
-	c.addHeader(runningForHeader)
-	createdAt := time.Unix(int64(c.c.Created), 0)
-	return units.HumanDuration(time.Now().UTC().Sub(createdAt))
-}
-
-func (c *containerContext) Ports() string {
-	c.addHeader(portsHeader)
-	return api.DisplayablePorts(c.c.Ports)
-}
-
-func (c *containerContext) Status() string {
-	c.addHeader(statusHeader)
-	return c.c.Status
-}
-
-func (c *containerContext) Size() string {
-	c.addHeader(sizeHeader)
-	srw := units.HumanSize(float64(c.c.SizeRw))
-	sv := units.HumanSize(float64(c.c.SizeRootFs))
-
-	sf := srw
-	if c.c.SizeRootFs > 0 {
-		sf = fmt.Sprintf("%s (virtual %s)", srw, sv)
-	}
-	return sf
-}
-
-func (c *containerContext) Labels() string {
-	c.addHeader(labelsHeader)
-	if c.c.Labels == nil {
-		return ""
-	}
-
-	var joinLabels []string
-	for k, v := range c.c.Labels {
-		joinLabels = append(joinLabels, fmt.Sprintf("%s=%s", k, v))
-	}
-	return strings.Join(joinLabels, ",")
-}
-
-func (c *containerContext) Label(name string) string {
-	n := strings.Split(name, ".")
-	r := strings.NewReplacer("-", " ", "_", " ")
-	h := r.Replace(n[len(n)-1])
-
-	c.addHeader(h)
-
-	if c.c.Labels == nil {
-		return ""
-	}
-	return c.c.Labels[name]
-}
-
-func (c *containerContext) Mounts() string {
-	c.addHeader(mountsHeader)
-
-	var name string
-	var mounts []string
-	for _, m := range c.c.Mounts {
-		if m.Name == "" {
-			name = m.Source
-		} else {
-			name = m.Name
-		}
-		if c.trunc {
-			name = stringutils.Truncate(name, 15)
-		}
-		mounts = append(mounts, name)
-	}
-	return strings.Join(mounts, ",")
-}
-
-type imageContext struct {
-	baseSubContext
-	trunc  bool
-	i      types.Image
-	repo   string
-	tag    string
-	digest string
-}
-
-func (c *imageContext) ID() string {
-	c.addHeader(imageIDHeader)
-	if c.trunc {
-		return stringid.TruncateID(c.i.ID)
-	}
-	return c.i.ID
-}
-
-func (c *imageContext) Repository() string {
-	c.addHeader(repositoryHeader)
-	return c.repo
-}
-
-func (c *imageContext) Tag() string {
-	c.addHeader(tagHeader)
-	return c.tag
-}
-
-func (c *imageContext) Digest() string {
-	c.addHeader(digestHeader)
-	return c.digest
-}
-
-func (c *imageContext) CreatedSince() string {
-	c.addHeader(createdSinceHeader)
-	createdAt := time.Unix(int64(c.i.Created), 0)
-	return units.HumanDuration(time.Now().UTC().Sub(createdAt))
-}
-
-func (c *imageContext) CreatedAt() string {
-	c.addHeader(createdAtHeader)
-	return time.Unix(int64(c.i.Created), 0).String()
-}
-
-func (c *imageContext) Size() string {
-	c.addHeader(sizeHeader)
-	return units.HumanSize(float64(c.i.Size))
-}
-
-type subContext interface {
-	fullHeader() string
-	addHeader(header string)
-}
-
-type baseSubContext struct {
-	header []string
-}
-
-func (c *baseSubContext) fullHeader() string {
-	if c.header == nil {
-		return ""
-	}
-	return strings.Join(c.header, "\t")
-}
-
-func (c *baseSubContext) addHeader(header string) {
-	if c.header == nil {
-		c.header = []string{}
-	}
-	c.header = append(c.header, strings.ToUpper(header))
-}
-
-func stripNamePrefix(ss []string) []string {
-	sss := make([]string, len(ss))
-	for i, s := range ss {
-		sss[i] = s[1:]
-	}
-
-	return sss
-}
--- a/api/client/formatter/custom_test.go
+++ b/api/client/formatter/custom_test.go
@@ -1,192 +0,0 @@
-package formatter
-
-import (
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/engine-api/types"
-)
-
-func TestContainerPsContext(t *testing.T) {
-	containerID := stringid.GenerateRandomID()
-	unix := time.Now().Add(-65 * time.Second).Unix()
-
-	var ctx containerContext
-	cases := []struct {
-		container types.Container
-		trunc     bool
-		expValue  string
-		expHeader string
-		call      func() string
-	}{
-		{types.Container{ID: containerID}, true, stringid.TruncateID(containerID), containerIDHeader, ctx.ID},
-		{types.Container{ID: containerID}, false, containerID, containerIDHeader, ctx.ID},
-		{types.Container{Names: []string{"/foobar_baz"}}, true, "foobar_baz", namesHeader, ctx.Names},
-		{types.Container{Image: "ubuntu"}, true, "ubuntu", imageHeader, ctx.Image},
-		{types.Container{Image: "verylongimagename"}, true, "verylongimagename", imageHeader, ctx.Image},
-		{types.Container{Image: "verylongimagename"}, false, "verylongimagename", imageHeader, ctx.Image},
-		{types.Container{
-			Image:   "a5a665ff33eced1e0803148700880edab4",
-			ImageID: "a5a665ff33eced1e0803148700880edab4269067ed77e27737a708d0d293fbf5",
-		},
-			true,
-			"a5a665ff33ec",
-			imageHeader,
-			ctx.Image,
-		},
-		{types.Container{
-			Image:   "a5a665ff33eced1e0803148700880edab4",
-			ImageID: "a5a665ff33eced1e0803148700880edab4269067ed77e27737a708d0d293fbf5",
-		},
-			false,
-			"a5a665ff33eced1e0803148700880edab4",
-			imageHeader,
-			ctx.Image,
-		},
-		{types.Container{Image: ""}, true, "<no image>", imageHeader, ctx.Image},
-		{types.Container{Command: "sh -c 'ls -la'"}, true, `"sh -c 'ls -la'"`, commandHeader, ctx.Command},
-		{types.Container{Created: unix}, true, time.Unix(unix, 0).String(), createdAtHeader, ctx.CreatedAt},
-		{types.Container{Ports: []types.Port{{PrivatePort: 8080, PublicPort: 8080, Type: "tcp"}}}, true, "8080/tcp", portsHeader, ctx.Ports},
-		{types.Container{Status: "RUNNING"}, true, "RUNNING", statusHeader, ctx.Status},
-		{types.Container{SizeRw: 10}, true, "10 B", sizeHeader, ctx.Size},
-		{types.Container{SizeRw: 10, SizeRootFs: 20}, true, "10 B (virtual 20 B)", sizeHeader, ctx.Size},
-		{types.Container{}, true, "", labelsHeader, ctx.Labels},
-		{types.Container{Labels: map[string]string{"cpu": "6", "storage": "ssd"}}, true, "cpu=6,storage=ssd", labelsHeader, ctx.Labels},
-		{types.Container{Created: unix}, true, "About a minute", runningForHeader, ctx.RunningFor},
-	}
-
-	for _, c := range cases {
-		ctx = containerContext{c: c.container, trunc: c.trunc}
-		v := c.call()
-		if strings.Contains(v, ",") {
-			compareMultipleValues(t, v, c.expValue)
-		} else if v != c.expValue {
-			t.Fatalf("Expected %s, was %s\n", c.expValue, v)
-		}
-
-		h := ctx.fullHeader()
-		if h != c.expHeader {
-			t.Fatalf("Expected %s, was %s\n", c.expHeader, h)
-		}
-	}
-
-	c1 := types.Container{Labels: map[string]string{"com.docker.swarm.swarm-id": "33", "com.docker.swarm.node_name": "ubuntu"}}
-	ctx = containerContext{c: c1, trunc: true}
-
-	sid := ctx.Label("com.docker.swarm.swarm-id")
-	node := ctx.Label("com.docker.swarm.node_name")
-	if sid != "33" {
-		t.Fatalf("Expected 33, was %s\n", sid)
-	}
-
-	if node != "ubuntu" {
-		t.Fatalf("Expected ubuntu, was %s\n", node)
-	}
-
-	h := ctx.fullHeader()
-	if h != "SWARM ID\tNODE NAME" {
-		t.Fatalf("Expected %s, was %s\n", "SWARM ID\tNODE NAME", h)
-
-	}
-
-	c2 := types.Container{}
-	ctx = containerContext{c: c2, trunc: true}
-
-	label := ctx.Label("anything.really")
-	if label != "" {
-		t.Fatalf("Expected an empty string, was %s", label)
-	}
-
-	ctx = containerContext{c: c2, trunc: true}
-	fullHeader := ctx.fullHeader()
-	if fullHeader != "" {
-		t.Fatalf("Expected fullHeader to be empty, was %s", fullHeader)
-	}
-
-}
-
-func TestImagesContext(t *testing.T) {
-	imageID := stringid.GenerateRandomID()
-	unix := time.Now().Unix()
-
-	var ctx imageContext
-	cases := []struct {
-		imageCtx  imageContext
-		expValue  string
-		expHeader string
-		call      func() string
-	}{
-		{imageContext{
-			i:     types.Image{ID: imageID},
-			trunc: true,
-		}, stringid.TruncateID(imageID), imageIDHeader, ctx.ID},
-		{imageContext{
-			i:     types.Image{ID: imageID},
-			trunc: false,
-		}, imageID, imageIDHeader, ctx.ID},
-		{imageContext{
-			i:     types.Image{Size: 10},
-			trunc: true,
-		}, "10 B", sizeHeader, ctx.Size},
-		{imageContext{
-			i:     types.Image{Created: unix},
-			trunc: true,
-		}, time.Unix(unix, 0).String(), createdAtHeader, ctx.CreatedAt},
-		// FIXME
-		// {imageContext{
-		// 	i:     types.Image{Created: unix},
-		// 	trunc: true,
-		// }, units.HumanDuration(time.Unix(unix, 0)), createdSinceHeader, ctx.CreatedSince},
-		{imageContext{
-			i:    types.Image{},
-			repo: "busybox",
-		}, "busybox", repositoryHeader, ctx.Repository},
-		{imageContext{
-			i:   types.Image{},
-			tag: "latest",
-		}, "latest", tagHeader, ctx.Tag},
-		{imageContext{
-			i:      types.Image{},
-			digest: "sha256:d149ab53f8718e987c3a3024bb8aa0e2caadf6c0328f1d9d850b2a2a67f2819a",
-		}, "sha256:d149ab53f8718e987c3a3024bb8aa0e2caadf6c0328f1d9d850b2a2a67f2819a", digestHeader, ctx.Digest},
-	}
-
-	for _, c := range cases {
-		ctx = c.imageCtx
-		v := c.call()
-		if strings.Contains(v, ",") {
-			compareMultipleValues(t, v, c.expValue)
-		} else if v != c.expValue {
-			t.Fatalf("Expected %s, was %s\n", c.expValue, v)
-		}
-
-		h := ctx.fullHeader()
-		if h != c.expHeader {
-			t.Fatalf("Expected %s, was %s\n", c.expHeader, h)
-		}
-	}
-}
-
-func compareMultipleValues(t *testing.T, value, expected string) {
-	// comma-separated values means probably a map input, which won't
-	// be guaranteed to have the same order as our expected value
-	// We'll create maps and use reflect.DeepEquals to check instead:
-	entriesMap := make(map[string]string)
-	expMap := make(map[string]string)
-	entries := strings.Split(value, ",")
-	expectedEntries := strings.Split(expected, ",")
-	for _, entry := range entries {
-		keyval := strings.Split(entry, "=")
-		entriesMap[keyval[0]] = keyval[1]
-	}
-	for _, expected := range expectedEntries {
-		keyval := strings.Split(expected, "=")
-		expMap[keyval[0]] = keyval[1]
-	}
-	if !reflect.DeepEqual(expMap, entriesMap) {
-		t.Fatalf("Expected entries: %v, got: %v", expected, value)
-	}
-}
--- a/api/client/formatter/formatter.go
+++ b/api/client/formatter/formatter.go
@@ -1,307 +0,0 @@
-package formatter
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"strings"
-	"text/tabwriter"
-	"text/template"
-
-	"github.com/docker/docker/reference"
-	"github.com/docker/docker/utils/templates"
-	"github.com/docker/engine-api/types"
-)
-
-const (
-	tableFormatKey = "table"
-	rawFormatKey   = "raw"
-
-	defaultContainerTableFormat       = "table {{.ID}}\t{{.Image}}\t{{.Command}}\t{{.RunningFor}} ago\t{{.Status}}\t{{.Ports}}\t{{.Names}}"
-	defaultImageTableFormat           = "table {{.Repository}}\t{{.Tag}}\t{{.ID}}\t{{.CreatedSince}} ago\t{{.Size}}"
-	defaultImageTableFormatWithDigest = "table {{.Repository}}\t{{.Tag}}\t{{.Digest}}\t{{.ID}}\t{{.CreatedSince}} ago\t{{.Size}}"
-	defaultQuietFormat                = "{{.ID}}"
-)
-
-// Context contains information required by the formatter to print the output as desired.
-type Context struct {
-	// Output is the output stream to which the formatted string is written.
-	Output io.Writer
-	// Format is used to choose raw, table or custom format for the output.
-	Format string
-	// Quiet when set to true will simply print minimal information.
-	Quiet bool
-	// Trunc when set to true will truncate the output of certain fields such as Container ID.
-	Trunc bool
-
-	// internal element
-	table       bool
-	finalFormat string
-	header      string
-	buffer      *bytes.Buffer
-}
-
-func (c *Context) preformat() {
-	c.finalFormat = c.Format
-
-	if strings.HasPrefix(c.Format, tableKey) {
-		c.table = true
-		c.finalFormat = c.finalFormat[len(tableKey):]
-	}
-
-	c.finalFormat = strings.Trim(c.finalFormat, " ")
-	r := strings.NewReplacer(`\t`, "\t", `\n`, "\n")
-	c.finalFormat = r.Replace(c.finalFormat)
-}
-
-func (c *Context) parseFormat() (*template.Template, error) {
-	tmpl, err := templates.Parse(c.finalFormat)
-	if err != nil {
-		c.buffer.WriteString(fmt.Sprintf("Template parsing error: %v\n", err))
-		c.buffer.WriteTo(c.Output)
-	}
-	return tmpl, err
-}
-
-func (c *Context) postformat(tmpl *template.Template, subContext subContext) {
-	if c.table {
-		if len(c.header) == 0 {
-			// if we still don't have a header, we didn't have any containers so we need to fake it to get the right headers from the template
-			tmpl.Execute(bytes.NewBufferString(""), subContext)
-			c.header = subContext.fullHeader()
-		}
-
-		t := tabwriter.NewWriter(c.Output, 20, 1, 3, ' ', 0)
-		t.Write([]byte(c.header))
-		t.Write([]byte("\n"))
-		c.buffer.WriteTo(t)
-		t.Flush()
-	} else {
-		c.buffer.WriteTo(c.Output)
-	}
-}
-
-func (c *Context) contextFormat(tmpl *template.Template, subContext subContext) error {
-	if err := tmpl.Execute(c.buffer, subContext); err != nil {
-		c.buffer = bytes.NewBufferString(fmt.Sprintf("Template parsing error: %v\n", err))
-		c.buffer.WriteTo(c.Output)
-		return err
-	}
-	if c.table && len(c.header) == 0 {
-		c.header = subContext.fullHeader()
-	}
-	c.buffer.WriteString("\n")
-	return nil
-}
-
-// ContainerContext contains container specific information required by the formater, encapsulate a Context struct.
-type ContainerContext struct {
-	Context
-	// Size when set to true will display the size of the output.
-	Size bool
-	// Containers
-	Containers []types.Container
-}
-
-// ImageContext contains image specific information required by the formater, encapsulate a Context struct.
-type ImageContext struct {
-	Context
-	Digest bool
-	// Images
-	Images []types.Image
-}
-
-func (ctx ContainerContext) Write() {
-	switch ctx.Format {
-	case tableFormatKey:
-		if ctx.Quiet {
-			ctx.Format = defaultQuietFormat
-		} else {
-			ctx.Format = defaultContainerTableFormat
-			if ctx.Size {
-				ctx.Format += `\t{{.Size}}`
-			}
-		}
-	case rawFormatKey:
-		if ctx.Quiet {
-			ctx.Format = `container_id: {{.ID}}`
-		} else {
-			ctx.Format = `container_id: {{.ID}}\nimage: {{.Image}}\ncommand: {{.Command}}\ncreated_at: {{.CreatedAt}}\nstatus: {{.Status}}\nnames: {{.Names}}\nlabels: {{.Labels}}\nports: {{.Ports}}\n`
-			if ctx.Size {
-				ctx.Format += `size: {{.Size}}\n`
-			}
-		}
-	}
-
-	ctx.buffer = bytes.NewBufferString("")
-	ctx.preformat()
-
-	tmpl, err := ctx.parseFormat()
-	if err != nil {
-		return
-	}
-
-	for _, container := range ctx.Containers {
-		containerCtx := &containerContext{
-			trunc: ctx.Trunc,
-			c:     container,
-		}
-		err = ctx.contextFormat(tmpl, containerCtx)
-		if err != nil {
-			return
-		}
-	}
-
-	ctx.postformat(tmpl, &containerContext{})
-}
-
-func isDangling(image types.Image) bool {
-	return len(image.RepoTags) == 1 && image.RepoTags[0] == "<none>:<none>" && len(image.RepoDigests) == 1 && image.RepoDigests[0] == "<none>@<none>"
-}
-
-func (ctx ImageContext) Write() {
-	switch ctx.Format {
-	case tableFormatKey:
-		ctx.Format = defaultImageTableFormat
-		if ctx.Digest {
-			ctx.Format = defaultImageTableFormatWithDigest
-		}
-		if ctx.Quiet {
-			ctx.Format = defaultQuietFormat
-		}
-	case rawFormatKey:
-		if ctx.Quiet {
-			ctx.Format = `image_id: {{.ID}}`
-		} else {
-			if ctx.Digest {
-				ctx.Format = `repository: {{ .Repository }}
-tag: {{.Tag}}
-digest: {{.Digest}}
-image_id: {{.ID}}
-created_at: {{.CreatedAt}}
-virtual_size: {{.Size}}
-`
-			} else {
-				ctx.Format = `repository: {{ .Repository }}
-tag: {{.Tag}}
-image_id: {{.ID}}
-created_at: {{.CreatedAt}}
-virtual_size: {{.Size}}
-`
-			}
-		}
-	}
-
-	ctx.buffer = bytes.NewBufferString("")
-	ctx.preformat()
-	if ctx.table && ctx.Digest && !strings.Contains(ctx.Format, "{{.Digest}}") {
-		ctx.finalFormat += "\t{{.Digest}}"
-	}
-
-	tmpl, err := ctx.parseFormat()
-	if err != nil {
-		return
-	}
-
-	for _, image := range ctx.Images {
-		images := []*imageContext{}
-		if isDangling(image) {
-			images = append(images, &imageContext{
-				trunc:  ctx.Trunc,
-				i:      image,
-				repo:   "<none>",
-				tag:    "<none>",
-				digest: "<none>",
-			})
-		} else {
-			repoTags := map[string][]string{}
-			repoDigests := map[string][]string{}
-
-			for _, refString := range append(image.RepoTags) {
-				ref, err := reference.ParseNamed(refString)
-				if err != nil {
-					continue
-				}
-				if nt, ok := ref.(reference.NamedTagged); ok {
-					repoTags[ref.Name()] = append(repoTags[ref.Name()], nt.Tag())
-				}
-			}
-			for _, refString := range append(image.RepoDigests) {
-				ref, err := reference.ParseNamed(refString)
-				if err != nil {
-					continue
-				}
-				if c, ok := ref.(reference.Canonical); ok {
-					repoDigests[ref.Name()] = append(repoDigests[ref.Name()], c.Digest().String())
-				}
-			}
-
-			for repo, tags := range repoTags {
-				digests := repoDigests[repo]
-
-				// Do not display digests as their own row
-				delete(repoDigests, repo)
-
-				if !ctx.Digest {
-					// Ignore digest references, just show tag once
-					digests = nil
-				}
-
-				for _, tag := range tags {
-					if len(digests) == 0 {
-						images = append(images, &imageContext{
-							trunc:  ctx.Trunc,
-							i:      image,
-							repo:   repo,
-							tag:    tag,
-							digest: "<none>",
-						})
-						continue
-					}
-					// Display the digests for each tag
-					for _, dgst := range digests {
-						images = append(images, &imageContext{
-							trunc:  ctx.Trunc,
-							i:      image,
-							repo:   repo,
-							tag:    tag,
-							digest: dgst,
-						})
-					}
-
-				}
-			}
-
-			// Show rows for remaining digest only references
-			for repo, digests := range repoDigests {
-				// If digests are displayed, show row per digest
-				if ctx.Digest {
-					for _, dgst := range digests {
-						images = append(images, &imageContext{
-							trunc:  ctx.Trunc,
-							i:      image,
-							repo:   repo,
-							tag:    "<none>",
-							digest: dgst,
-						})
-					}
-				} else {
-					images = append(images, &imageContext{
-						trunc: ctx.Trunc,
-						i:     image,
-						repo:  repo,
-						tag:   "<none>",
-					})
-				}
-			}
-		}
-		for _, imageCtx := range images {
-			err = ctx.contextFormat(tmpl, imageCtx)
-			if err != nil {
-				return
-			}
-		}
-	}
-
-	ctx.postformat(tmpl, &imageContext{})
-}
--- a/api/client/formatter/formatter_test.go
+++ b/api/client/formatter/formatter_test.go
@@ -1,537 +0,0 @@
-package formatter
-
-import (
-	"bytes"
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/docker/engine-api/types"
-)
-
-func TestContainerContextWrite(t *testing.T) {
-	unixTime := time.Now().AddDate(0, 0, -1).Unix()
-	expectedTime := time.Unix(unixTime, 0).String()
-
-	contexts := []struct {
-		context  ContainerContext
-		expected string
-	}{
-		// Errors
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "{{InvalidFunction}}",
-				},
-			},
-			`Template parsing error: template: :1: function "InvalidFunction" not defined
-`,
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "{{nil}}",
-				},
-			},
-			`Template parsing error: template: :1:2: executing "" at <nil>: nil is not a command
-`,
-		},
-		// Table Format
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "table",
-				},
-			},
-			`CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
-containerID1        ubuntu              ""                  24 hours ago                                                foobar_baz
-containerID2        ubuntu              ""                  24 hours ago                                                foobar_bar
-`,
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "table {{.Image}}",
-				},
-			},
-			"IMAGE\nubuntu\nubuntu\n",
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "table {{.Image}}",
-				},
-				Size: true,
-			},
-			"IMAGE\nubuntu\nubuntu\n",
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "table {{.Image}}",
-					Quiet:  true,
-				},
-			},
-			"IMAGE\nubuntu\nubuntu\n",
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "table",
-					Quiet:  true,
-				},
-			},
-			"containerID1\ncontainerID2\n",
-		},
-		// Raw Format
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "raw",
-				},
-			},
-			fmt.Sprintf(`container_id: containerID1
-image: ubuntu
-command: ""
-created_at: %s
-status: 
-names: foobar_baz
-labels: 
-ports: 
-
-container_id: containerID2
-image: ubuntu
-command: ""
-created_at: %s
-status: 
-names: foobar_bar
-labels: 
-ports: 
-
-`, expectedTime, expectedTime),
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "raw",
-				},
-				Size: true,
-			},
-			fmt.Sprintf(`container_id: containerID1
-image: ubuntu
-command: ""
-created_at: %s
-status: 
-names: foobar_baz
-labels: 
-ports: 
-size: 0 B
-
-container_id: containerID2
-image: ubuntu
-command: ""
-created_at: %s
-status: 
-names: foobar_bar
-labels: 
-ports: 
-size: 0 B
-
-`, expectedTime, expectedTime),
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "raw",
-					Quiet:  true,
-				},
-			},
-			"container_id: containerID1\ncontainer_id: containerID2\n",
-		},
-		// Custom Format
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "{{.Image}}",
-				},
-			},
-			"ubuntu\nubuntu\n",
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "{{.Image}}",
-				},
-				Size: true,
-			},
-			"ubuntu\nubuntu\n",
-		},
-	}
-
-	for _, context := range contexts {
-		containers := []types.Container{
-			{ID: "containerID1", Names: []string{"/foobar_baz"}, Image: "ubuntu", Created: unixTime},
-			{ID: "containerID2", Names: []string{"/foobar_bar"}, Image: "ubuntu", Created: unixTime},
-		}
-		out := bytes.NewBufferString("")
-		context.context.Output = out
-		context.context.Containers = containers
-		context.context.Write()
-		actual := out.String()
-		if actual != context.expected {
-			t.Fatalf("Expected \n%s, got \n%s", context.expected, actual)
-		}
-		// Clean buffer
-		out.Reset()
-	}
-}
-
-func TestContainerContextWriteWithNoContainers(t *testing.T) {
-	out := bytes.NewBufferString("")
-	containers := []types.Container{}
-
-	contexts := []struct {
-		context  ContainerContext
-		expected string
-	}{
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "{{.Image}}",
-					Output: out,
-				},
-			},
-			"",
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "table {{.Image}}",
-					Output: out,
-				},
-			},
-			"IMAGE\n",
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "{{.Image}}",
-					Output: out,
-				},
-				Size: true,
-			},
-			"",
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "table {{.Image}}",
-					Output: out,
-				},
-				Size: true,
-			},
-			"IMAGE\n",
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "table {{.Image}}\t{{.Size}}",
-					Output: out,
-				},
-			},
-			"IMAGE               SIZE\n",
-		},
-		{
-			ContainerContext{
-				Context: Context{
-					Format: "table {{.Image}}\t{{.Size}}",
-					Output: out,
-				},
-				Size: true,
-			},
-			"IMAGE               SIZE\n",
-		},
-	}
-
-	for _, context := range contexts {
-		context.context.Containers = containers
-		context.context.Write()
-		actual := out.String()
-		if actual != context.expected {
-			t.Fatalf("Expected \n%s, got \n%s", context.expected, actual)
-		}
-		// Clean buffer
-		out.Reset()
-	}
-}
-
-func TestImageContextWrite(t *testing.T) {
-	unixTime := time.Now().AddDate(0, 0, -1).Unix()
-	expectedTime := time.Unix(unixTime, 0).String()
-
-	contexts := []struct {
-		context  ImageContext
-		expected string
-	}{
-		// Errors
-		{
-			ImageContext{
-				Context: Context{
-					Format: "{{InvalidFunction}}",
-				},
-			},
-			`Template parsing error: template: :1: function "InvalidFunction" not defined
-`,
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "{{nil}}",
-				},
-			},
-			`Template parsing error: template: :1:2: executing "" at <nil>: nil is not a command
-`,
-		},
-		// Table Format
-		{
-			ImageContext{
-				Context: Context{
-					Format: "table",
-				},
-			},
-			`REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
-image               tag1                imageID1            24 hours ago        0 B
-image               tag2                imageID2            24 hours ago        0 B
-<none>              <none>              imageID3            24 hours ago        0 B
-`,
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "table {{.Repository}}",
-				},
-			},
-			"REPOSITORY\nimage\nimage\n<none>\n",
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "table {{.Repository}}",
-				},
-				Digest: true,
-			},
-			`REPOSITORY          DIGEST
-image               sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf
-image               <none>
-<none>              <none>
-`,
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "table {{.Repository}}",
-					Quiet:  true,
-				},
-			},
-			"REPOSITORY\nimage\nimage\n<none>\n",
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "table",
-					Quiet:  true,
-				},
-			},
-			"imageID1\nimageID2\nimageID3\n",
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "table",
-					Quiet:  false,
-				},
-				Digest: true,
-			},
-			`REPOSITORY          TAG                 DIGEST                                                                    IMAGE ID            CREATED             SIZE
-image               tag1                sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf   imageID1            24 hours ago        0 B
-image               tag2                <none>                                                                    imageID2            24 hours ago        0 B
-<none>              <none>              <none>                                                                    imageID3            24 hours ago        0 B
-`,
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "table",
-					Quiet:  true,
-				},
-				Digest: true,
-			},
-			"imageID1\nimageID2\nimageID3\n",
-		},
-		// Raw Format
-		{
-			ImageContext{
-				Context: Context{
-					Format: "raw",
-				},
-			},
-			fmt.Sprintf(`repository: image
-tag: tag1
-image_id: imageID1
-created_at: %s
-virtual_size: 0 B
-
-repository: image
-tag: tag2
-image_id: imageID2
-created_at: %s
-virtual_size: 0 B
-
-repository: <none>
-tag: <none>
-image_id: imageID3
-created_at: %s
-virtual_size: 0 B
-
-`, expectedTime, expectedTime, expectedTime),
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "raw",
-				},
-				Digest: true,
-			},
-			fmt.Sprintf(`repository: image
-tag: tag1
-digest: sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf
-image_id: imageID1
-created_at: %s
-virtual_size: 0 B
-
-repository: image
-tag: tag2
-digest: <none>
-image_id: imageID2
-created_at: %s
-virtual_size: 0 B
-
-repository: <none>
-tag: <none>
-digest: <none>
-image_id: imageID3
-created_at: %s
-virtual_size: 0 B
-
-`, expectedTime, expectedTime, expectedTime),
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "raw",
-					Quiet:  true,
-				},
-			},
-			`image_id: imageID1
-image_id: imageID2
-image_id: imageID3
-`,
-		},
-		// Custom Format
-		{
-			ImageContext{
-				Context: Context{
-					Format: "{{.Repository}}",
-				},
-			},
-			"image\nimage\n<none>\n",
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "{{.Repository}}",
-				},
-				Digest: true,
-			},
-			"image\nimage\n<none>\n",
-		},
-	}
-
-	for _, context := range contexts {
-		images := []types.Image{
-			{ID: "imageID1", RepoTags: []string{"image:tag1"}, RepoDigests: []string{"image@sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf"}, Created: unixTime},
-			{ID: "imageID2", RepoTags: []string{"image:tag2"}, Created: unixTime},
-			{ID: "imageID3", RepoTags: []string{"<none>:<none>"}, RepoDigests: []string{"<none>@<none>"}, Created: unixTime},
-		}
-		out := bytes.NewBufferString("")
-		context.context.Output = out
-		context.context.Images = images
-		context.context.Write()
-		actual := out.String()
-		if actual != context.expected {
-			t.Fatalf("Expected \n%s, got \n%s", context.expected, actual)
-		}
-		// Clean buffer
-		out.Reset()
-	}
-}
-
-func TestImageContextWriteWithNoImage(t *testing.T) {
-	out := bytes.NewBufferString("")
-	images := []types.Image{}
-
-	contexts := []struct {
-		context  ImageContext
-		expected string
-	}{
-		{
-			ImageContext{
-				Context: Context{
-					Format: "{{.Repository}}",
-					Output: out,
-				},
-			},
-			"",
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "table {{.Repository}}",
-					Output: out,
-				},
-			},
-			"REPOSITORY\n",
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "{{.Repository}}",
-					Output: out,
-				},
-				Digest: true,
-			},
-			"",
-		},
-		{
-			ImageContext{
-				Context: Context{
-					Format: "table {{.Repository}}",
-					Output: out,
-				},
-				Digest: true,
-			},
-			"REPOSITORY          DIGEST\n",
-		},
-	}
-
-	for _, context := range contexts {
-		context.context.Images = images
-		context.context.Write()
-		actual := out.String()
-		if actual != context.expected {
-			t.Fatalf("Expected \n%s, got \n%s", context.expected, actual)
-		}
-		// Clean buffer
-		out.Reset()
-	}
-}
--- a/api/client/hijack.go
+++ b/api/client/hijack.go
@@ -1,95 +1,250 @@
 package client

 import (
+	"crypto/tls"
+	"errors"
+	"fmt"
 	"io"
-	"sync"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"os"
+	"runtime"
+	"strings"
+	"time"

-	"golang.org/x/net/context"
-
-	"github.com/Sirupsen/logrus"
+	log "github.com/Sirupsen/logrus"
+	"github.com/docker/docker/api"
+	"github.com/docker/docker/autogen/dockerversion"
+	"github.com/docker/docker/pkg/promise"
 	"github.com/docker/docker/pkg/stdcopy"
-	"github.com/docker/engine-api/types"
+	"github.com/docker/docker/pkg/term"
 )

-// HoldHijackedConnection handles copying input to and output from streams to the
-// connection
-func (cli *DockerCli) HoldHijackedConnection(ctx context.Context, tty bool, inputStream io.ReadCloser, outputStream, errorStream io.Writer, resp types.HijackedResponse) error {
-	var (
-		err         error
-		restoreOnce sync.Once
-	)
-	if inputStream != nil && tty {
-		if err := cli.setRawTerminal(); err != nil {
-			return err
-		}
-		defer func() {
-			restoreOnce.Do(func() {
-				cli.restoreTerminal(inputStream)
-			})
-		}()
+type tlsClientCon struct {
+	*tls.Conn
+	rawConn net.Conn
+}
+
+func (c *tlsClientCon) CloseWrite() error {
+	// Go standard tls.Conn doesn't provide the CloseWrite() method so we do it
+	// on its underlying connection.
+	if cwc, ok := c.rawConn.(interface {
+		CloseWrite() error
+	}); ok {
+		return cwc.CloseWrite()
+	}
+	return nil
+}
+
+func tlsDial(network, addr string, config *tls.Config) (net.Conn, error) {
+	return tlsDialWithDialer(new(net.Dialer), network, addr, config)
+}
+
+// We need to copy Go's implementation of tls.Dial (pkg/cryptor/tls/tls.go) in
+// order to return our custom tlsClientCon struct which holds both the tls.Conn
+// object _and_ its underlying raw connection. The rationale for this is that
+// we need to be able to close the write end of the connection when attaching,
+// which tls.Conn does not provide.
+func tlsDialWithDialer(dialer *net.Dialer, network, addr string, config *tls.Config) (net.Conn, error) {
+	// We want the Timeout and Deadline values from dialer to cover the
+	// whole process: TCP connection and TLS handshake. This means that we
+	// also need to start our own timers now.
+	timeout := dialer.Timeout
+
+	if !dialer.Deadline.IsZero() {
+		deadlineTimeout := dialer.Deadline.Sub(time.Now())
+		if timeout == 0 || deadlineTimeout < timeout {
+			timeout = deadlineTimeout
+		}
+	}
+
+	var errChannel chan error
+
+	if timeout != 0 {
+		errChannel = make(chan error, 2)
+		time.AfterFunc(timeout, func() {
+			errChannel <- errors.New("")
+		})
+	}
+
+	rawConn, err := dialer.Dial(network, addr)
+	if err != nil {
+		return nil, err
+	}
+	// When we set up a TCP connection for hijack, there could be long periods
+	// of inactivity (a long running command with no output) that in certain
+	// network setups may cause ECONNTIMEOUT, leaving the client in an unknown
+	// state. Setting TCP KeepAlive on the socket connection will prohibit
+	// ECONNTIMEOUT unless the socket connection truly is broken
+	if tcpConn, ok := rawConn.(*net.TCPConn); ok {
+		tcpConn.SetKeepAlive(true)
+		tcpConn.SetKeepAlivePeriod(30 * time.Second)
+	}
+
+	colonPos := strings.LastIndex(addr, ":")
+	if colonPos == -1 {
+		colonPos = len(addr)
+	}
+	hostname := addr[:colonPos]
+
+	// If no ServerName is set, infer the ServerName
+	// from the hostname we're connecting to.
+	if config.ServerName == "" {
+		// Make a copy to avoid polluting argument or default.
+		c := *config
+		c.ServerName = hostname
+		config = &c
+	}
+
+	conn := tls.Client(rawConn, config)
+
+	if timeout == 0 {
+		err = conn.Handshake()
+	} else {
+		go func() {
+			errChannel <- conn.Handshake()
+		}()
+
+		err = <-errChannel
+	}
+
+	if err != nil {
+		rawConn.Close()
+		return nil, err
+	}
+
+	// This is Docker difference with standard's crypto/tls package: returned a
+	// wrapper which holds both the TLS and raw connections.
+	return &tlsClientCon{conn, rawConn}, nil
+}
+
+func (cli *DockerCli) dial() (net.Conn, error) {
+	if cli.tlsConfig != nil && cli.proto != "unix" {
+		// Notice this isn't Go standard's tls.Dial function
+		return tlsDial(cli.proto, cli.addr, cli.tlsConfig)
+	}
+	return net.Dial(cli.proto, cli.addr)
+}
+
+func (cli *DockerCli) hijack(method, path string, setRawTerminal bool, in io.ReadCloser, stdout, stderr io.Writer, started chan io.Closer, data interface{}) error {
+	defer func() {
+		if started != nil {
+			close(started)
+		}
+	}()
+
+	params, err := cli.encodeData(data)
+	if err != nil {
+		return err
+	}
+	req, err := http.NewRequest(method, fmt.Sprintf("/v%s%s", api.APIVERSION, path), params)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("User-Agent", "Docker-Client/"+dockerversion.VERSION)
+	req.Header.Set("Content-Type", "text/plain")
+	req.Header.Set("Connection", "Upgrade")
+	req.Header.Set("Upgrade", "tcp")
+	req.Host = cli.addr
+
+	dial, err := cli.dial()
+	// When we set up a TCP connection for hijack, there could be long periods
+	// of inactivity (a long running command with no output) that in certain
+	// network setups may cause ECONNTIMEOUT, leaving the client in an unknown
+	// state. Setting TCP KeepAlive on the socket connection will prohibit
+	// ECONNTIMEOUT unless the socket connection truly is broken
+	if tcpConn, ok := dial.(*net.TCPConn); ok {
+		tcpConn.SetKeepAlive(true)
+		tcpConn.SetKeepAlivePeriod(30 * time.Second)
+	}
+	if err != nil {
+		if strings.Contains(err.Error(), "connection refused") {
+			return fmt.Errorf("Cannot connect to the Docker daemon. Is 'docker -d' running on this host?")
+		}
+		return err
+	}
+	clientconn := httputil.NewClientConn(dial, nil)
+	defer clientconn.Close()
+
+	// Server hijacks the connection, error 'connection closed' expected
+	clientconn.Do(req)
+
+	rwc, br := clientconn.Hijack()
+	defer rwc.Close()
+
+	if started != nil {
+		started <- rwc
+	}
+
+	var receiveStdout chan error
+
+	var oldState *term.State
+
+	if in != nil && setRawTerminal && cli.isTerminalIn && os.Getenv("NORAW") == "" {
+		oldState, err = term.SetRawTerminal(cli.inFd)
+		if err != nil {
+			return err
+		}
+		defer term.RestoreTerminal(cli.inFd, oldState)
+	}
+
+	if stdout != nil || stderr != nil {
+		receiveStdout = promise.Go(func() (err error) {
+			defer func() {
+				if in != nil {
+					if setRawTerminal && cli.isTerminalIn {
+						term.RestoreTerminal(cli.inFd, oldState)
+					}
+					// For some reason this Close call blocks on darwin..
+					// As the client exists right after, simply discard the close
+					// until we find a better solution.
+					if runtime.GOOS != "darwin" {
+						in.Close()
+					}
+				}
+			}()
+
+			// When TTY is ON, use regular copy
+			if setRawTerminal && stdout != nil {
+				_, err = io.Copy(stdout, br)
+			} else {
+				_, err = stdcopy.StdCopy(stdout, stderr, br)
+			}
+			log.Debugf("[hijack] End of stdout")
+			return err
+		})
+	}
+
+	sendStdin := promise.Go(func() error {
+		if in != nil {
+			io.Copy(rwc, in)
+			log.Debugf("[hijack] End of stdin")
+		}
+
+		if conn, ok := rwc.(interface {
+			CloseWrite() error
+		}); ok {
+			if err := conn.CloseWrite(); err != nil {
+				log.Debugf("Couldn't send EOF: %s", err)
+			}
+		}
+		// Discard errors due to pipe interruption
+		return nil
+	})
+
+	if stdout != nil || stderr != nil {
+		if err := <-receiveStdout; err != nil {
+			log.Debugf("Error receiveStdout: %s", err)
+			return err
+		}
+	}
+
+	if !cli.isTerminalIn {
+		if err := <-sendStdin; err != nil {
+			log.Debugf("Error sendStdin: %s", err)
+			return err
+		}
 	}
-
-	receiveStdout := make(chan error, 1)
-	if outputStream != nil || errorStream != nil {
-		go func() {
-			// When TTY is ON, use regular copy
-			if tty && outputStream != nil {
-				_, err = io.Copy(outputStream, resp.Reader)
-				// we should restore the terminal as soon as possible once connection end
-				// so any following print messages will be in normal type.
-				if inputStream != nil {
-					restoreOnce.Do(func() {
-						cli.restoreTerminal(inputStream)
-					})
-				}
-			} else {
-				_, err = stdcopy.StdCopy(outputStream, errorStream, resp.Reader)
-			}
-
-			logrus.Debug("[hijack] End of stdout")
-			receiveStdout <- err
-		}()
-	}
-
-	stdinDone := make(chan struct{})
-	go func() {
-		if inputStream != nil {
-			io.Copy(resp.Conn, inputStream)
-			// we should restore the terminal as soon as possible once connection end
-			// so any following print messages will be in normal type.
-			if tty {
-				restoreOnce.Do(func() {
-					cli.restoreTerminal(inputStream)
-				})
-			}
-			logrus.Debug("[hijack] End of stdin")
-		}
-
-		if err := resp.CloseWrite(); err != nil {
-			logrus.Debugf("Couldn't send EOF: %s", err)
-		}
-		close(stdinDone)
-	}()
-
-	select {
-	case err := <-receiveStdout:
-		if err != nil {
-			logrus.Debugf("Error receiveStdout: %s", err)
-			return err
-		}
-	case <-stdinDone:
-		if outputStream != nil || errorStream != nil {
-			select {
-			case err := <-receiveStdout:
-				if err != nil {
-					logrus.Debugf("Error receiveStdout: %s", err)
-					return err
-				}
-			case <-ctx.Done():
-			}
-		}
-	case <-ctx.Done():
-	}
-
 	return nil
 }
--- a/api/client/idresolver/idresolver.go
+++ b/api/client/idresolver/idresolver.go
@@ -1,70 +0,0 @@
-package idresolver
-
-import (
-	"fmt"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/engine-api/client"
-	"github.com/docker/engine-api/types/swarm"
-)
-
-// IDResolver provides ID to Name resolution.
-type IDResolver struct {
-	client    client.APIClient
-	noResolve bool
-	cache     map[string]string
-}
-
-// New creates a new IDResolver.
-func New(client client.APIClient, noResolve bool) *IDResolver {
-	return &IDResolver{
-		client:    client,
-		noResolve: noResolve,
-		cache:     make(map[string]string),
-	}
-}
-
-func (r *IDResolver) get(ctx context.Context, t interface{}, id string) (string, error) {
-	switch t.(type) {
-	case swarm.Node:
-		node, _, err := r.client.NodeInspectWithRaw(ctx, id)
-		if err != nil {
-			return id, nil
-		}
-		if node.Spec.Annotations.Name != "" {
-			return node.Spec.Annotations.Name, nil
-		}
-		if node.Description.Hostname != "" {
-			return node.Description.Hostname, nil
-		}
-		return id, nil
-	case swarm.Service:
-		service, _, err := r.client.ServiceInspectWithRaw(ctx, id)
-		if err != nil {
-			return id, nil
-		}
-		return service.Spec.Annotations.Name, nil
-	default:
-		return "", fmt.Errorf("unsupported type")
-	}
-
-}
-
-// Resolve will attempt to resolve an ID to a Name by querying the manager.
-// Results are stored into a cache.
-// If the `-n` flag is used in the command-line, resolution is disabled.
-func (r *IDResolver) Resolve(ctx context.Context, t interface{}, id string) (string, error) {
-	if r.noResolve {
-		return id, nil
-	}
-	if name, ok := r.cache[id]; ok {
-		return name, nil
-	}
-	name, err := r.get(ctx, t, id)
-	if err != nil {
-		return "", err
-	}
-	r.cache[id] = name
-	return name, nil
-}
--- a/api/client/image/build.go
+++ b/api/client/image/build.go
@@ -1,433 +0,0 @@
-package image
-
-import (
-	"archive/tar"
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"regexp"
-	"runtime"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api"
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/builder"
-	"github.com/docker/docker/builder/dockerignore"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/opts"
-	"github.com/docker/docker/pkg/archive"
-	"github.com/docker/docker/pkg/fileutils"
-	"github.com/docker/docker/pkg/jsonmessage"
-	"github.com/docker/docker/pkg/progress"
-	"github.com/docker/docker/pkg/streamformatter"
-	"github.com/docker/docker/pkg/urlutil"
-	"github.com/docker/docker/reference"
-	runconfigopts "github.com/docker/docker/runconfig/opts"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/container"
-	"github.com/docker/go-units"
-	"github.com/spf13/cobra"
-)
-
-type buildOptions struct {
-	context        string
-	dockerfileName string
-	tags           opts.ListOpts
-	labels         opts.ListOpts
-	buildArgs      opts.ListOpts
-	ulimits        *runconfigopts.UlimitOpt
-	memory         string
-	memorySwap     string
-	shmSize        string
-	cpuShares      int64
-	cpuPeriod      int64
-	cpuQuota       int64
-	cpuSetCpus     string
-	cpuSetMems     string
-	cgroupParent   string
-	isolation      string
-	quiet          bool
-	noCache        bool
-	rm             bool
-	forceRm        bool
-	pull           bool
-}
-
-// NewBuildCommand creates a new `docker build` command
-func NewBuildCommand(dockerCli *client.DockerCli) *cobra.Command {
-	ulimits := make(map[string]*units.Ulimit)
-	options := buildOptions{
-		tags:      opts.NewListOpts(validateTag),
-		buildArgs: opts.NewListOpts(runconfigopts.ValidateEnv),
-		ulimits:   runconfigopts.NewUlimitOpt(&ulimits),
-		labels:    opts.NewListOpts(runconfigopts.ValidateEnv),
-	}
-
-	cmd := &cobra.Command{
-		Use:   "build [OPTIONS] PATH | URL | -",
-		Short: "Build an image from a Dockerfile",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			options.context = args[0]
-			return runBuild(dockerCli, options)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.VarP(&options.tags, "tag", "t", "Name and optionally a tag in the 'name:tag' format")
-	flags.Var(&options.buildArgs, "build-arg", "Set build-time variables")
-	flags.Var(options.ulimits, "ulimit", "Ulimit options")
-	flags.StringVarP(&options.dockerfileName, "file", "f", "", "Name of the Dockerfile (Default is 'PATH/Dockerfile')")
-	flags.StringVarP(&options.memory, "memory", "m", "", "Memory limit")
-	flags.StringVar(&options.memorySwap, "memory-swap", "", "Swap limit equal to memory plus swap: '-1' to enable unlimited swap")
-	flags.StringVar(&options.shmSize, "shm-size", "", "Size of /dev/shm, default value is 64MB")
-	flags.Int64VarP(&options.cpuShares, "cpu-shares", "c", 0, "CPU shares (relative weight)")
-	flags.Int64Var(&options.cpuPeriod, "cpu-period", 0, "Limit the CPU CFS (Completely Fair Scheduler) period")
-	flags.Int64Var(&options.cpuQuota, "cpu-quota", 0, "Limit the CPU CFS (Completely Fair Scheduler) quota")
-	flags.StringVar(&options.cpuSetCpus, "cpuset-cpus", "", "CPUs in which to allow execution (0-3, 0,1)")
-	flags.StringVar(&options.cpuSetMems, "cpuset-mems", "", "MEMs in which to allow execution (0-3, 0,1)")
-	flags.StringVar(&options.cgroupParent, "cgroup-parent", "", "Optional parent cgroup for the container")
-	flags.StringVar(&options.isolation, "isolation", "", "Container isolation technology")
-	flags.Var(&options.labels, "label", "Set metadata for an image")
-	flags.BoolVar(&options.noCache, "no-cache", false, "Do not use cache when building the image")
-	flags.BoolVar(&options.rm, "rm", true, "Remove intermediate containers after a successful build")
-	flags.BoolVar(&options.forceRm, "force-rm", false, "Always remove intermediate containers")
-	flags.BoolVarP(&options.quiet, "quiet", "q", false, "Suppress the build output and print image ID on success")
-	flags.BoolVar(&options.pull, "pull", false, "Always attempt to pull a newer version of the image")
-
-	client.AddTrustedFlags(flags, true)
-
-	return cmd
-}
-
-func runBuild(dockerCli *client.DockerCli, options buildOptions) error {
-
-	var (
-		buildCtx io.ReadCloser
-		err      error
-	)
-
-	specifiedContext := options.context
-
-	var (
-		contextDir    string
-		tempDir       string
-		relDockerfile string
-		progBuff      io.Writer
-		buildBuff     io.Writer
-	)
-
-	progBuff = dockerCli.Out()
-	buildBuff = dockerCli.Out()
-	if options.quiet {
-		progBuff = bytes.NewBuffer(nil)
-		buildBuff = bytes.NewBuffer(nil)
-	}
-
-	switch {
-	case specifiedContext == "-":
-		buildCtx, relDockerfile, err = builder.GetContextFromReader(dockerCli.In(), options.dockerfileName)
-	case urlutil.IsGitURL(specifiedContext):
-		tempDir, relDockerfile, err = builder.GetContextFromGitURL(specifiedContext, options.dockerfileName)
-	case urlutil.IsURL(specifiedContext):
-		buildCtx, relDockerfile, err = builder.GetContextFromURL(progBuff, specifiedContext, options.dockerfileName)
-	default:
-		contextDir, relDockerfile, err = builder.GetContextFromLocalDir(specifiedContext, options.dockerfileName)
-	}
-
-	if err != nil {
-		if options.quiet && urlutil.IsURL(specifiedContext) {
-			fmt.Fprintln(dockerCli.Err(), progBuff)
-		}
-		return fmt.Errorf("unable to prepare context: %s", err)
-	}
-
-	if tempDir != "" {
-		defer os.RemoveAll(tempDir)
-		contextDir = tempDir
-	}
-
-	if buildCtx == nil {
-		// And canonicalize dockerfile name to a platform-independent one
-		relDockerfile, err = archive.CanonicalTarNameForPath(relDockerfile)
-		if err != nil {
-			return fmt.Errorf("cannot canonicalize dockerfile path %s: %v", relDockerfile, err)
-		}
-
-		f, err := os.Open(filepath.Join(contextDir, ".dockerignore"))
-		if err != nil && !os.IsNotExist(err) {
-			return err
-		}
-
-		var excludes []string
-		if err == nil {
-			excludes, err = dockerignore.ReadAll(f)
-			if err != nil {
-				return err
-			}
-		}
-
-		if err := builder.ValidateContextDirectory(contextDir, excludes); err != nil {
-			return fmt.Errorf("Error checking context: '%s'.", err)
-		}
-
-		// If .dockerignore mentions .dockerignore or the Dockerfile
-		// then make sure we send both files over to the daemon
-		// because Dockerfile is, obviously, needed no matter what, and
-		// .dockerignore is needed to know if either one needs to be
-		// removed. The daemon will remove them for us, if needed, after it
-		// parses the Dockerfile. Ignore errors here, as they will have been
-		// caught by validateContextDirectory above.
-		var includes = []string{"."}
-		keepThem1, _ := fileutils.Matches(".dockerignore", excludes)
-		keepThem2, _ := fileutils.Matches(relDockerfile, excludes)
-		if keepThem1 || keepThem2 {
-			includes = append(includes, ".dockerignore", relDockerfile)
-		}
-
-		buildCtx, err = archive.TarWithOptions(contextDir, &archive.TarOptions{
-			Compression:     archive.Uncompressed,
-			ExcludePatterns: excludes,
-			IncludeFiles:    includes,
-		})
-		if err != nil {
-			return err
-		}
-	}
-
-	ctx := context.Background()
-
-	var resolvedTags []*resolvedTag
-	if client.IsTrusted() {
-		// Wrap the tar archive to replace the Dockerfile entry with the rewritten
-		// Dockerfile which uses trusted pulls.
-		buildCtx = replaceDockerfileTarWrapper(ctx, buildCtx, relDockerfile, dockerCli.TrustedReference, &resolvedTags)
-	}
-
-	// Setup an upload progress bar
-	progressOutput := streamformatter.NewStreamFormatter().NewProgressOutput(progBuff, true)
-
-	var body io.Reader = progress.NewProgressReader(buildCtx, progressOutput, 0, "", "Sending build context to Docker daemon")
-
-	var memory int64
-	if options.memory != "" {
-		parsedMemory, err := units.RAMInBytes(options.memory)
-		if err != nil {
-			return err
-		}
-		memory = parsedMemory
-	}
-
-	var memorySwap int64
-	if options.memorySwap != "" {
-		if options.memorySwap == "-1" {
-			memorySwap = -1
-		} else {
-			parsedMemorySwap, err := units.RAMInBytes(options.memorySwap)
-			if err != nil {
-				return err
-			}
-			memorySwap = parsedMemorySwap
-		}
-	}
-
-	var shmSize int64
-	if options.shmSize != "" {
-		shmSize, err = units.RAMInBytes(options.shmSize)
-		if err != nil {
-			return err
-		}
-	}
-
-	buildOptions := types.ImageBuildOptions{
-		Memory:         memory,
-		MemorySwap:     memorySwap,
-		Tags:           options.tags.GetAll(),
-		SuppressOutput: options.quiet,
-		NoCache:        options.noCache,
-		Remove:         options.rm,
-		ForceRemove:    options.forceRm,
-		PullParent:     options.pull,
-		Isolation:      container.Isolation(options.isolation),
-		CPUSetCPUs:     options.cpuSetCpus,
-		CPUSetMems:     options.cpuSetMems,
-		CPUShares:      options.cpuShares,
-		CPUQuota:       options.cpuQuota,
-		CPUPeriod:      options.cpuPeriod,
-		CgroupParent:   options.cgroupParent,
-		Dockerfile:     relDockerfile,
-		ShmSize:        shmSize,
-		Ulimits:        options.ulimits.GetList(),
-		BuildArgs:      runconfigopts.ConvertKVStringsToMap(options.buildArgs.GetAll()),
-		AuthConfigs:    dockerCli.RetrieveAuthConfigs(),
-		Labels:         runconfigopts.ConvertKVStringsToMap(options.labels.GetAll()),
-	}
-
-	response, err := dockerCli.Client().ImageBuild(ctx, body, buildOptions)
-	if err != nil {
-		return err
-	}
-	defer response.Body.Close()
-
-	err = jsonmessage.DisplayJSONMessagesStream(response.Body, buildBuff, dockerCli.OutFd(), dockerCli.IsTerminalOut(), nil)
-	if err != nil {
-		if jerr, ok := err.(*jsonmessage.JSONError); ok {
-			// If no error code is set, default to 1
-			if jerr.Code == 0 {
-				jerr.Code = 1
-			}
-			if options.quiet {
-				fmt.Fprintf(dockerCli.Err(), "%s%s", progBuff, buildBuff)
-			}
-			return cli.StatusError{Status: jerr.Message, StatusCode: jerr.Code}
-		}
-	}
-
-	// Windows: show error message about modified file permissions if the
-	// daemon isn't running Windows.
-	if response.OSType != "windows" && runtime.GOOS == "windows" {
-		fmt.Fprintln(dockerCli.Err(), `SECURITY WARNING: You are building a Docker image from Windows against a non-Windows Docker host. All files and directories added to build context will have '-rwxr-xr-x' permissions. It is recommended to double check and reset permissions for sensitive files and directories.`)
-	}
-
-	// Everything worked so if -q was provided the output from the daemon
-	// should be just the image ID and we'll print that to stdout.
-	if options.quiet {
-		fmt.Fprintf(dockerCli.Out(), "%s", buildBuff)
-	}
-
-	if client.IsTrusted() {
-		// Since the build was successful, now we must tag any of the resolved
-		// images from the above Dockerfile rewrite.
-		for _, resolved := range resolvedTags {
-			if err := dockerCli.TagTrusted(ctx, resolved.digestRef, resolved.tagRef); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-type translatorFunc func(context.Context, reference.NamedTagged) (reference.Canonical, error)
-
-// validateTag checks if the given image name can be resolved.
-func validateTag(rawRepo string) (string, error) {
-	_, err := reference.ParseNamed(rawRepo)
-	if err != nil {
-		return "", err
-	}
-
-	return rawRepo, nil
-}
-
-var dockerfileFromLinePattern = regexp.MustCompile(`(?i)^[\s]*FROM[ \f\r\t\v]+(?P<image>[^ \f\r\t\v\n#]+)`)
-
-// resolvedTag records the repository, tag, and resolved digest reference
-// from a Dockerfile rewrite.
-type resolvedTag struct {
-	digestRef reference.Canonical
-	tagRef    reference.NamedTagged
-}
-
-// rewriteDockerfileFrom rewrites the given Dockerfile by resolving images in
-// "FROM <image>" instructions to a digest reference. `translator` is a
-// function that takes a repository name and tag reference and returns a
-// trusted digest reference.
-func rewriteDockerfileFrom(ctx context.Context, dockerfile io.Reader, translator translatorFunc) (newDockerfile []byte, resolvedTags []*resolvedTag, err error) {
-	scanner := bufio.NewScanner(dockerfile)
-	buf := bytes.NewBuffer(nil)
-
-	// Scan the lines of the Dockerfile, looking for a "FROM" line.
-	for scanner.Scan() {
-		line := scanner.Text()
-
-		matches := dockerfileFromLinePattern.FindStringSubmatch(line)
-		if matches != nil && matches[1] != api.NoBaseImageSpecifier {
-			// Replace the line with a resolved "FROM repo@digest"
-			ref, err := reference.ParseNamed(matches[1])
-			if err != nil {
-				return nil, nil, err
-			}
-			ref = reference.WithDefaultTag(ref)
-			if ref, ok := ref.(reference.NamedTagged); ok && client.IsTrusted() {
-				trustedRef, err := translator(ctx, ref)
-				if err != nil {
-					return nil, nil, err
-				}
-
-				line = dockerfileFromLinePattern.ReplaceAllLiteralString(line, fmt.Sprintf("FROM %s", trustedRef.String()))
-				resolvedTags = append(resolvedTags, &resolvedTag{
-					digestRef: trustedRef,
-					tagRef:    ref,
-				})
-			}
-		}
-
-		_, err := fmt.Fprintln(buf, line)
-		if err != nil {
-			return nil, nil, err
-		}
-	}
-
-	return buf.Bytes(), resolvedTags, scanner.Err()
-}
-
-// replaceDockerfileTarWrapper wraps the given input tar archive stream and
-// replaces the entry with the given Dockerfile name with the contents of the
-// new Dockerfile. Returns a new tar archive stream with the replaced
-// Dockerfile.
-func replaceDockerfileTarWrapper(ctx context.Context, inputTarStream io.ReadCloser, dockerfileName string, translator translatorFunc, resolvedTags *[]*resolvedTag) io.ReadCloser {
-	pipeReader, pipeWriter := io.Pipe()
-	go func() {
-		tarReader := tar.NewReader(inputTarStream)
-		tarWriter := tar.NewWriter(pipeWriter)
-
-		defer inputTarStream.Close()
-
-		for {
-			hdr, err := tarReader.Next()
-			if err == io.EOF {
-				// Signals end of archive.
-				tarWriter.Close()
-				pipeWriter.Close()
-				return
-			}
-			if err != nil {
-				pipeWriter.CloseWithError(err)
-				return
-			}
-
-			var content io.Reader = tarReader
-			if hdr.Name == dockerfileName {
-				// This entry is the Dockerfile. Since the tar archive was
-				// generated from a directory on the local filesystem, the
-				// Dockerfile will only appear once in the archive.
-				var newDockerfile []byte
-				newDockerfile, *resolvedTags, err = rewriteDockerfileFrom(ctx, content, translator)
-				if err != nil {
-					pipeWriter.CloseWithError(err)
-					return
-				}
-				hdr.Size = int64(len(newDockerfile))
-				content = bytes.NewBuffer(newDockerfile)
-			}
-
-			if err := tarWriter.WriteHeader(hdr); err != nil {
-				pipeWriter.CloseWithError(err)
-				return
-			}
-
-			if _, err := io.Copy(tarWriter, content); err != nil {
-				pipeWriter.CloseWithError(err)
-				return
-			}
-		}
-	}()
-
-	return pipeReader
-}
--- a/api/client/image/history.go
+++ b/api/client/image/history.go
@@ -1,99 +0,0 @@
-package image
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"text/tabwriter"
-	"time"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/docker/pkg/stringutils"
-	"github.com/docker/go-units"
-	"github.com/spf13/cobra"
-)
-
-type historyOptions struct {
-	image string
-
-	human   bool
-	quiet   bool
-	noTrunc bool
-}
-
-// NewHistoryCommand create a new `docker history` command
-func NewHistoryCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts historyOptions
-
-	cmd := &cobra.Command{
-		Use:   "history [OPTIONS] IMAGE",
-		Short: "Show the history of an image",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.image = args[0]
-			return runHistory(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.BoolVarP(&opts.human, "human", "H", true, "Print sizes and dates in human readable format")
-	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Only show numeric IDs")
-	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Don't truncate output")
-
-	return cmd
-}
-
-func runHistory(dockerCli *client.DockerCli, opts historyOptions) error {
-	ctx := context.Background()
-
-	history, err := dockerCli.Client().ImageHistory(ctx, opts.image)
-	if err != nil {
-		return err
-	}
-
-	w := tabwriter.NewWriter(dockerCli.Out(), 20, 1, 3, ' ', 0)
-
-	if opts.quiet {
-		for _, entry := range history {
-			if opts.noTrunc {
-				fmt.Fprintf(w, "%s\n", entry.ID)
-			} else {
-				fmt.Fprintf(w, "%s\n", stringid.TruncateID(entry.ID))
-			}
-		}
-		w.Flush()
-		return nil
-	}
-
-	var imageID string
-	var createdBy string
-	var created string
-	var size string
-
-	fmt.Fprintln(w, "IMAGE\tCREATED\tCREATED BY\tSIZE\tCOMMENT")
-	for _, entry := range history {
-		imageID = entry.ID
-		createdBy = strings.Replace(entry.CreatedBy, "\t", " ", -1)
-		if opts.noTrunc == false {
-			createdBy = stringutils.Truncate(createdBy, 45)
-			imageID = stringid.TruncateID(entry.ID)
-		}
-
-		if opts.human {
-			created = units.HumanDuration(time.Now().UTC().Sub(time.Unix(entry.Created, 0))) + " ago"
-			size = units.HumanSize(float64(entry.Size))
-		} else {
-			created = time.Unix(entry.Created, 0).Format(time.RFC3339)
-			size = strconv.FormatInt(entry.Size, 10)
-		}
-
-		fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", imageID, created, createdBy, size, entry.Comment)
-	}
-	w.Flush()
-	return nil
-}
--- a/api/client/image/images.go
+++ b/api/client/image/images.go
@@ -1,103 +0,0 @@
-package image
-
-import (
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/api/client/formatter"
-	"github.com/docker/docker/cli"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	"github.com/spf13/cobra"
-)
-
-type imagesOptions struct {
-	matchName string
-
-	quiet       bool
-	all         bool
-	noTrunc     bool
-	showDigests bool
-	format      string
-	filter      []string
-}
-
-// NewImagesCommand create a new `docker images` command
-func NewImagesCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts imagesOptions
-
-	cmd := &cobra.Command{
-		Use:   "images [OPTIONS] [REPOSITORY[:TAG]]",
-		Short: "List images",
-		Args:  cli.RequiresMaxArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			if len(args) > 0 {
-				opts.matchName = args[0]
-			}
-			return runImages(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Only show numeric IDs")
-	flags.BoolVarP(&opts.all, "all", "a", false, "Show all images (default hides intermediate images)")
-	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Don't truncate output")
-	flags.BoolVar(&opts.showDigests, "digests", false, "Show digests")
-	flags.StringVar(&opts.format, "format", "", "Pretty-print images using a Go template")
-	flags.StringSliceVarP(&opts.filter, "filter", "f", []string{}, "Filter output based on conditions provided")
-
-	return cmd
-}
-
-func runImages(dockerCli *client.DockerCli, opts imagesOptions) error {
-	ctx := context.Background()
-
-	// Consolidate all filter flags, and sanity check them early.
-	// They'll get process in the daemon/server.
-	imageFilterArgs := filters.NewArgs()
-	for _, f := range opts.filter {
-		var err error
-		imageFilterArgs, err = filters.ParseFlag(f, imageFilterArgs)
-		if err != nil {
-			return err
-		}
-	}
-
-	matchName := opts.matchName
-
-	options := types.ImageListOptions{
-		MatchName: matchName,
-		All:       opts.all,
-		Filters:   imageFilterArgs,
-	}
-
-	images, err := dockerCli.Client().ImageList(ctx, options)
-	if err != nil {
-		return err
-	}
-
-	f := opts.format
-	if len(f) == 0 {
-		if len(dockerCli.ImagesFormat()) > 0 && !opts.quiet {
-			f = dockerCli.ImagesFormat()
-		} else {
-			f = "table"
-		}
-	}
-
-	imagesCtx := formatter.ImageContext{
-		Context: formatter.Context{
-			Output: dockerCli.Out(),
-			Format: f,
-			Quiet:  opts.quiet,
-			Trunc:  !opts.noTrunc,
-		},
-		Digest: opts.showDigests,
-		Images: images,
-	}
-
-	imagesCtx.Write()
-
-	return nil
-}
--- a/api/client/image/import.go
+++ b/api/client/image/import.go
@@ -1,86 +0,0 @@
-package image
-
-import (
-	"io"
-	"os"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/jsonmessage"
-	"github.com/docker/docker/pkg/urlutil"
-	"github.com/docker/engine-api/types"
-	"github.com/spf13/cobra"
-)
-
-type importOptions struct {
-	source    string
-	reference string
-	changes   []string
-	message   string
-}
-
-// NewImportCommand creates a new `docker import` command
-func NewImportCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts importOptions
-
-	cmd := &cobra.Command{
-		Use:   "import [OPTIONS] file|URL|- [REPOSITORY[:TAG]]",
-		Short: "Import the contents from a tarball to create a filesystem image",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.source = args[0]
-			if len(args) > 1 {
-				opts.reference = args[1]
-			}
-			return runImport(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.StringSliceVarP(&opts.changes, "change", "c", []string{}, "Apply Dockerfile instruction to the created image")
-	flags.StringVarP(&opts.message, "message", "m", "", "Set commit message for imported image")
-
-	return cmd
-}
-
-func runImport(dockerCli *client.DockerCli, opts importOptions) error {
-	var (
-		in      io.Reader
-		srcName = opts.source
-	)
-
-	if opts.source == "-" {
-		in = dockerCli.In()
-	} else if !urlutil.IsURL(opts.source) {
-		srcName = "-"
-		file, err := os.Open(opts.source)
-		if err != nil {
-			return err
-		}
-		defer file.Close()
-		in = file
-	}
-
-	source := types.ImageImportSource{
-		Source:     in,
-		SourceName: srcName,
-	}
-
-	options := types.ImageImportOptions{
-		Message: opts.message,
-		Changes: opts.changes,
-	}
-
-	clnt := dockerCli.Client()
-
-	responseBody, err := clnt.ImageImport(context.Background(), source, opts.reference, options)
-	if err != nil {
-		return err
-	}
-	defer responseBody.Close()
-
-	return jsonmessage.DisplayJSONMessagesStream(responseBody, dockerCli.Out(), dockerCli.OutFd(), dockerCli.IsTerminalOut(), nil)
-}
--- a/api/client/image/load.go
+++ b/api/client/image/load.go
@@ -1,67 +0,0 @@
-package image
-
-import (
-	"io"
-	"os"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/jsonmessage"
-	"github.com/spf13/cobra"
-)
-
-type loadOptions struct {
-	input string
-	quiet bool
-}
-
-// NewLoadCommand creates a new `docker load` command
-func NewLoadCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts loadOptions
-
-	cmd := &cobra.Command{
-		Use:   "load [OPTIONS]",
-		Short: "Load an image from a tar archive or STDIN",
-		Args:  cli.NoArgs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runLoad(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.StringVarP(&opts.input, "input", "i", "", "Read from tar archive file, instead of STDIN")
-	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Suppress the load output")
-
-	return cmd
-}
-
-func runLoad(dockerCli *client.DockerCli, opts loadOptions) error {
-
-	var input io.Reader = dockerCli.In()
-	if opts.input != "" {
-		file, err := os.Open(opts.input)
-		if err != nil {
-			return err
-		}
-		defer file.Close()
-		input = file
-	}
-	if !dockerCli.IsTerminalOut() {
-		opts.quiet = true
-	}
-	response, err := dockerCli.Client().ImageLoad(context.Background(), input, opts.quiet)
-	if err != nil {
-		return err
-	}
-	defer response.Body.Close()
-
-	if response.Body != nil && response.JSON {
-		return jsonmessage.DisplayJSONMessagesStream(response.Body, dockerCli.Out(), dockerCli.OutFd(), dockerCli.IsTerminalOut(), nil)
-	}
-
-	_, err = io.Copy(dockerCli.Out(), response.Body)
-	return err
-}
--- a/api/client/image/pull.go
+++ b/api/client/image/pull.go
@@ -1,85 +0,0 @@
-package image
-
-import (
-	"errors"
-	"fmt"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/reference"
-	"github.com/docker/docker/registry"
-	"github.com/spf13/cobra"
-)
-
-type pullOptions struct {
-	remote string
-	all    bool
-}
-
-// NewPullCommand creates a new `docker pull` command
-func NewPullCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts pullOptions
-
-	cmd := &cobra.Command{
-		Use:   "pull [OPTIONS] NAME[:TAG|@DIGEST]",
-		Short: "Pull an image or a repository from a registry",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.remote = args[0]
-			return runPull(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.BoolVarP(&opts.all, "all-tags", "a", false, "Download all tagged images in the repository")
-	client.AddTrustedFlags(flags, true)
-
-	return cmd
-}
-
-func runPull(dockerCli *client.DockerCli, opts pullOptions) error {
-	distributionRef, err := reference.ParseNamed(opts.remote)
-	if err != nil {
-		return err
-	}
-	if opts.all && !reference.IsNameOnly(distributionRef) {
-		return errors.New("tag can't be used with --all-tags/-a")
-	}
-
-	if !opts.all && reference.IsNameOnly(distributionRef) {
-		distributionRef = reference.WithDefaultTag(distributionRef)
-		fmt.Fprintf(dockerCli.Out(), "Using default tag: %s\n", reference.DefaultTag)
-	}
-
-	var tag string
-	switch x := distributionRef.(type) {
-	case reference.Canonical:
-		tag = x.Digest().String()
-	case reference.NamedTagged:
-		tag = x.Tag()
-	}
-
-	registryRef := registry.ParseReference(tag)
-
-	// Resolve the Repository name from fqn to RepositoryInfo
-	repoInfo, err := registry.ParseRepositoryInfo(distributionRef)
-	if err != nil {
-		return err
-	}
-
-	ctx := context.Background()
-
-	authConfig := dockerCli.ResolveAuthConfig(ctx, repoInfo.Index)
-	requestPrivilege := dockerCli.RegistryAuthenticationPrivilegedFunc(repoInfo.Index, "pull")
-
-	if client.IsTrusted() && !registryRef.HasDigest() {
-		// Check if tag is digest
-		return dockerCli.TrustedPull(ctx, repoInfo, registryRef, authConfig, requestPrivilege)
-	}
-
-	return dockerCli.ImagePullPrivileged(ctx, authConfig, distributionRef.String(), requestPrivilege, opts.all)
-
-}
--- a/api/client/image/push.go
+++ b/api/client/image/push.go
@@ -1,62 +0,0 @@
-package image
-
-import (
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/jsonmessage"
-	"github.com/docker/docker/reference"
-	"github.com/docker/docker/registry"
-	"github.com/spf13/cobra"
-)
-
-// NewPushCommand creates a new `docker push` command
-func NewPushCommand(dockerCli *client.DockerCli) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "push [OPTIONS] NAME[:TAG]",
-		Short: "Push an image or a repository to a registry",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runPush(dockerCli, args[0])
-		},
-	}
-
-	flags := cmd.Flags()
-
-	client.AddTrustedFlags(flags, true)
-
-	return cmd
-}
-
-func runPush(dockerCli *client.DockerCli, remote string) error {
-	ref, err := reference.ParseNamed(remote)
-	if err != nil {
-		return err
-	}
-
-	// Resolve the Repository name from fqn to RepositoryInfo
-	repoInfo, err := registry.ParseRepositoryInfo(ref)
-	if err != nil {
-		return err
-	}
-
-	ctx := context.Background()
-
-	// Resolve the Auth config relevant for this server
-	authConfig := dockerCli.ResolveAuthConfig(ctx, repoInfo.Index)
-	requestPrivilege := dockerCli.RegistryAuthenticationPrivilegedFunc(repoInfo.Index, "push")
-
-	if client.IsTrusted() {
-		return dockerCli.TrustedPush(ctx, repoInfo, ref, authConfig, requestPrivilege)
-	}
-
-	responseBody, err := dockerCli.ImagePushPrivileged(ctx, authConfig, ref.String(), requestPrivilege)
-	if err != nil {
-		return err
-	}
-
-	defer responseBody.Close()
-
-	return jsonmessage.DisplayJSONMessagesStream(responseBody, dockerCli.Out(), dockerCli.OutFd(), dockerCli.IsTerminalOut(), nil)
-}
--- a/api/client/image/remove.go
+++ b/api/client/image/remove.go
@@ -1,70 +0,0 @@
-package image
-
-import (
-	"fmt"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/engine-api/types"
-	"github.com/spf13/cobra"
-)
-
-type removeOptions struct {
-	force   bool
-	noPrune bool
-}
-
-// NewRemoveCommand create a new `docker remove` command
-func NewRemoveCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts removeOptions
-
-	cmd := &cobra.Command{
-		Use:   "rmi [OPTIONS] IMAGE [IMAGE...]",
-		Short: "Remove one or more images",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runRemove(dockerCli, opts, args)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.BoolVarP(&opts.force, "force", "f", false, "Force removal of the image")
-	flags.BoolVar(&opts.noPrune, "no-prune", false, "Do not delete untagged parents")
-
-	return cmd
-}
-
-func runRemove(dockerCli *client.DockerCli, opts removeOptions, images []string) error {
-	client := dockerCli.Client()
-	ctx := context.Background()
-
-	options := types.ImageRemoveOptions{
-		Force:         opts.force,
-		PruneChildren: !opts.noPrune,
-	}
-
-	var errs []string
-	for _, image := range images {
-		dels, err := client.ImageRemove(ctx, image, options)
-		if err != nil {
-			errs = append(errs, err.Error())
-		} else {
-			for _, del := range dels {
-				if del.Deleted != "" {
-					fmt.Fprintf(dockerCli.Out(), "Deleted: %s\n", del.Deleted)
-				} else {
-					fmt.Fprintf(dockerCli.Out(), "Untagged: %s\n", del.Untagged)
-				}
-			}
-		}
-	}
-
-	if len(errs) > 0 {
-		return fmt.Errorf("%s", strings.Join(errs, "\n"))
-	}
-	return nil
-}
--- a/api/client/image/save.go
+++ b/api/client/image/save.go
@@ -1,57 +0,0 @@
-package image
-
-import (
-	"errors"
-	"io"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type saveOptions struct {
-	images []string
-	output string
-}
-
-// NewSaveCommand creates a new `docker save` command
-func NewSaveCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts saveOptions
-
-	cmd := &cobra.Command{
-		Use:   "save [OPTIONS] IMAGE [IMAGE...]",
-		Short: "Save one or more images to a tar archive (streamed to STDOUT by default)",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.images = args
-			return runSave(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.StringVarP(&opts.output, "output", "o", "", "Write to a file, instead of STDOUT")
-
-	return cmd
-}
-
-func runSave(dockerCli *client.DockerCli, opts saveOptions) error {
-	if opts.output == "" && dockerCli.IsTerminalOut() {
-		return errors.New("Cowardly refusing to save to a terminal. Use the -o flag or redirect.")
-	}
-
-	responseBody, err := dockerCli.Client().ImageSave(context.Background(), opts.images)
-	if err != nil {
-		return err
-	}
-	defer responseBody.Close()
-
-	if opts.output == "" {
-		_, err := io.Copy(dockerCli.Out(), responseBody)
-		return err
-	}
-
-	return client.CopyToFile(opts.output, responseBody)
-}
--- a/api/client/image/search.go
+++ b/api/client/image/search.go
@@ -1,135 +0,0 @@
-package image
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-	"text/tabwriter"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/stringutils"
-	"github.com/docker/docker/registry"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	registrytypes "github.com/docker/engine-api/types/registry"
-	"github.com/spf13/cobra"
-)
-
-type searchOptions struct {
-	term    string
-	noTrunc bool
-	limit   int
-	filter  []string
-
-	// Deprecated
-	stars     uint
-	automated bool
-}
-
-// NewSearchCommand create a new `docker search` command
-func NewSearchCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts searchOptions
-
-	cmd := &cobra.Command{
-		Use:   "search [OPTIONS] TERM",
-		Short: "Search the Docker Hub for images",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.term = args[0]
-			return runSearch(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Don't truncate output")
-	flags.StringSliceVarP(&opts.filter, "filter", "f", []string{}, "Filter output based on conditions provided")
-	flags.IntVar(&opts.limit, "limit", registry.DefaultSearchLimit, "Max number of search results")
-
-	flags.BoolVar(&opts.automated, "automated", false, "Only show automated builds")
-	flags.UintVarP(&opts.stars, "stars", "s", 0, "Only displays with at least x stars")
-
-	flags.MarkDeprecated("automated", "use --filter=automated=true instead")
-	flags.MarkDeprecated("stars", "use --filter=stars=3 instead")
-
-	return cmd
-}
-
-func runSearch(dockerCli *client.DockerCli, opts searchOptions) error {
-	indexInfo, err := registry.ParseSearchIndexInfo(opts.term)
-	if err != nil {
-		return err
-	}
-
-	ctx := context.Background()
-
-	authConfig := dockerCli.ResolveAuthConfig(ctx, indexInfo)
-	requestPrivilege := dockerCli.RegistryAuthenticationPrivilegedFunc(indexInfo, "search")
-
-	encodedAuth, err := client.EncodeAuthToBase64(authConfig)
-	if err != nil {
-		return err
-	}
-
-	searchFilters := filters.NewArgs()
-	for _, f := range opts.filter {
-		var err error
-		searchFilters, err = filters.ParseFlag(f, searchFilters)
-		if err != nil {
-			return err
-		}
-	}
-
-	options := types.ImageSearchOptions{
-		RegistryAuth:  encodedAuth,
-		PrivilegeFunc: requestPrivilege,
-		Filters:       searchFilters,
-		Limit:         opts.limit,
-	}
-
-	clnt := dockerCli.Client()
-
-	unorderedResults, err := clnt.ImageSearch(ctx, opts.term, options)
-	if err != nil {
-		return err
-	}
-
-	results := searchResultsByStars(unorderedResults)
-	sort.Sort(results)
-
-	w := tabwriter.NewWriter(dockerCli.Out(), 10, 1, 3, ' ', 0)
-	fmt.Fprintf(w, "NAME\tDESCRIPTION\tSTARS\tOFFICIAL\tAUTOMATED\n")
-	for _, res := range results {
-		// --automated and -s, --stars are deprecated since Docker 1.12
-		if (opts.automated && !res.IsAutomated) || (int(opts.stars) > res.StarCount) {
-			continue
-		}
-		desc := strings.Replace(res.Description, "\n", " ", -1)
-		desc = strings.Replace(desc, "\r", " ", -1)
-		if !opts.noTrunc && len(desc) > 45 {
-			desc = stringutils.Truncate(desc, 42) + "..."
-		}
-		fmt.Fprintf(w, "%s\t%s\t%d\t", res.Name, desc, res.StarCount)
-		if res.IsOfficial {
-			fmt.Fprint(w, "[OK]")
-
-		}
-		fmt.Fprint(w, "\t")
-		if res.IsAutomated {
-			fmt.Fprint(w, "[OK]")
-		}
-		fmt.Fprint(w, "\n")
-	}
-	w.Flush()
-	return nil
-}
-
-// SearchResultsByStars sorts search results in descending order by number of stars.
-type searchResultsByStars []registrytypes.SearchResult
-
-func (r searchResultsByStars) Len() int           { return len(r) }
-func (r searchResultsByStars) Swap(i, j int)      { r[i], r[j] = r[j], r[i] }
-func (r searchResultsByStars) Less(i, j int) bool { return r[j].StarCount < r[i].StarCount }
--- a/api/client/image/tag.go
+++ b/api/client/image/tag.go
@@ -1,41 +0,0 @@
-package image
-
-import (
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type tagOptions struct {
-	image string
-	name  string
-}
-
-// NewTagCommand create a new `docker tag` command
-func NewTagCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts tagOptions
-
-	cmd := &cobra.Command{
-		Use:   "tag IMAGE[:TAG] IMAGE[:TAG]",
-		Short: "Tag an image into a repository",
-		Args:  cli.ExactArgs(2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.image = args[0]
-			opts.name = args[1]
-			return runTag(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.SetInterspersed(false)
-
-	return cmd
-}
-
-func runTag(dockerCli *client.DockerCli, opts tagOptions) error {
-	ctx := context.Background()
-
-	return dockerCli.Client().ImageTag(ctx, opts.image, opts.name)
-}
--- a/api/client/info.go
+++ b/api/client/info.go
@@ -1,215 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"golang.org/x/net/context"
-
-	Cli "github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/ioutils"
-	flag "github.com/docker/docker/pkg/mflag"
-	"github.com/docker/docker/utils"
-	"github.com/docker/engine-api/types/swarm"
-	"github.com/docker/go-units"
-)
-
-// CmdInfo displays system-wide information.
-//
-// Usage: docker info
-func (cli *DockerCli) CmdInfo(args ...string) error {
-	cmd := Cli.Subcmd("info", nil, Cli.DockerCommands["info"].Description, true)
-	cmd.Require(flag.Exact, 0)
-
-	cmd.ParseFlags(args, true)
-
-	ctx := context.Background()
-	info, err := cli.client.Info(ctx)
-	if err != nil {
-		return err
-	}
-
-	fmt.Fprintf(cli.out, "Containers: %d\n", info.Containers)
-	fmt.Fprintf(cli.out, " Running: %d\n", info.ContainersRunning)
-	fmt.Fprintf(cli.out, " Paused: %d\n", info.ContainersPaused)
-	fmt.Fprintf(cli.out, " Stopped: %d\n", info.ContainersStopped)
-	fmt.Fprintf(cli.out, "Images: %d\n", info.Images)
-	ioutils.FprintfIfNotEmpty(cli.out, "Server Version: %s\n", info.ServerVersion)
-	ioutils.FprintfIfNotEmpty(cli.out, "Storage Driver: %s\n", info.Driver)
-	if info.DriverStatus != nil {
-		for _, pair := range info.DriverStatus {
-			fmt.Fprintf(cli.out, " %s: %s\n", pair[0], pair[1])
-
-			// print a warning if devicemapper is using a loopback file
-			if pair[0] == "Data loop file" {
-				fmt.Fprintln(cli.err, " WARNING: Usage of loopback devices is strongly discouraged for production use. Use `--storage-opt dm.thinpooldev` to specify a custom block storage device.")
-			}
-		}
-
-	}
-	if info.SystemStatus != nil {
-		for _, pair := range info.SystemStatus {
-			fmt.Fprintf(cli.out, "%s: %s\n", pair[0], pair[1])
-		}
-	}
-	ioutils.FprintfIfNotEmpty(cli.out, "Logging Driver: %s\n", info.LoggingDriver)
-	ioutils.FprintfIfNotEmpty(cli.out, "Cgroup Driver: %s\n", info.CgroupDriver)
-
-	fmt.Fprintf(cli.out, "Plugins:\n")
-	fmt.Fprintf(cli.out, " Volume:")
-	fmt.Fprintf(cli.out, " %s", strings.Join(info.Plugins.Volume, " "))
-	fmt.Fprintf(cli.out, "\n")
-	fmt.Fprintf(cli.out, " Network:")
-	fmt.Fprintf(cli.out, " %s", strings.Join(info.Plugins.Network, " "))
-	fmt.Fprintf(cli.out, "\n")
-
-	if len(info.Plugins.Authorization) != 0 {
-		fmt.Fprintf(cli.out, " Authorization:")
-		fmt.Fprintf(cli.out, " %s", strings.Join(info.Plugins.Authorization, " "))
-		fmt.Fprintf(cli.out, "\n")
-	}
-
-	fmt.Fprintf(cli.out, "Swarm: %v\n", info.Swarm.LocalNodeState)
-	if info.Swarm.LocalNodeState != swarm.LocalNodeStateInactive {
-		fmt.Fprintf(cli.out, " NodeID: %s\n", info.Swarm.NodeID)
-		if info.Swarm.Error != "" {
-			fmt.Fprintf(cli.out, " Error: %v\n", info.Swarm.Error)
-		}
-		fmt.Fprintf(cli.out, " Is Manager: %v\n", info.Swarm.ControlAvailable)
-		if info.Swarm.ControlAvailable {
-			fmt.Fprintf(cli.out, " ClusterID: %s\n", info.Swarm.Cluster.ID)
-			fmt.Fprintf(cli.out, " Managers: %d\n", info.Swarm.Managers)
-			fmt.Fprintf(cli.out, " Nodes: %d\n", info.Swarm.Nodes)
-			fmt.Fprintf(cli.out, " Orchestration:\n")
-			fmt.Fprintf(cli.out, "  Task History Retention Limit: %d\n", info.Swarm.Cluster.Spec.Orchestration.TaskHistoryRetentionLimit)
-			fmt.Fprintf(cli.out, " Raft:\n")
-			fmt.Fprintf(cli.out, "  Snapshot Interval: %d\n", info.Swarm.Cluster.Spec.Raft.SnapshotInterval)
-			fmt.Fprintf(cli.out, "  Heartbeat Tick: %d\n", info.Swarm.Cluster.Spec.Raft.HeartbeatTick)
-			fmt.Fprintf(cli.out, "  Election Tick: %d\n", info.Swarm.Cluster.Spec.Raft.ElectionTick)
-			fmt.Fprintf(cli.out, " Dispatcher:\n")
-			fmt.Fprintf(cli.out, "  Heartbeat Period: %s\n", units.HumanDuration(time.Duration(info.Swarm.Cluster.Spec.Dispatcher.HeartbeatPeriod)))
-			fmt.Fprintf(cli.out, " CA Configuration:\n")
-			fmt.Fprintf(cli.out, "  Expiry Duration: %s\n", units.HumanDuration(info.Swarm.Cluster.Spec.CAConfig.NodeCertExpiry))
-			if len(info.Swarm.Cluster.Spec.CAConfig.ExternalCAs) > 0 {
-				fmt.Fprintf(cli.out, "  External CAs:\n")
-				for _, entry := range info.Swarm.Cluster.Spec.CAConfig.ExternalCAs {
-					fmt.Fprintf(cli.out, "    %s: %s\n", entry.Protocol, entry.URL)
-				}
-			}
-		}
-		fmt.Fprintf(cli.out, " Node Address: %s\n", info.Swarm.NodeAddr)
-	}
-
-	if len(info.Runtimes) > 0 {
-		fmt.Fprintf(cli.out, "Runtimes:")
-		for name := range info.Runtimes {
-			fmt.Fprintf(cli.out, " %s", name)
-		}
-		fmt.Fprint(cli.out, "\n")
-		fmt.Fprintf(cli.out, "Default Runtime: %s\n", info.DefaultRuntime)
-	}
-
-	fmt.Fprintf(cli.out, "Security Options:")
-	ioutils.FprintfIfNotEmpty(cli.out, " %s", strings.Join(info.SecurityOptions, " "))
-	fmt.Fprintf(cli.out, "\n")
-
-	ioutils.FprintfIfNotEmpty(cli.out, "Kernel Version: %s\n", info.KernelVersion)
-	ioutils.FprintfIfNotEmpty(cli.out, "Operating System: %s\n", info.OperatingSystem)
-	ioutils.FprintfIfNotEmpty(cli.out, "OSType: %s\n", info.OSType)
-	ioutils.FprintfIfNotEmpty(cli.out, "Architecture: %s\n", info.Architecture)
-	fmt.Fprintf(cli.out, "CPUs: %d\n", info.NCPU)
-	fmt.Fprintf(cli.out, "Total Memory: %s\n", units.BytesSize(float64(info.MemTotal)))
-	ioutils.FprintfIfNotEmpty(cli.out, "Name: %s\n", info.Name)
-	ioutils.FprintfIfNotEmpty(cli.out, "ID: %s\n", info.ID)
-	fmt.Fprintf(cli.out, "Docker Root Dir: %s\n", info.DockerRootDir)
-	fmt.Fprintf(cli.out, "Debug Mode (client): %v\n", utils.IsDebugEnabled())
-	fmt.Fprintf(cli.out, "Debug Mode (server): %v\n", info.Debug)
-
-	if info.Debug {
-		fmt.Fprintf(cli.out, " File Descriptors: %d\n", info.NFd)
-		fmt.Fprintf(cli.out, " Goroutines: %d\n", info.NGoroutines)
-		fmt.Fprintf(cli.out, " System Time: %s\n", info.SystemTime)
-		fmt.Fprintf(cli.out, " EventsListeners: %d\n", info.NEventsListener)
-	}
-
-	ioutils.FprintfIfNotEmpty(cli.out, "Http Proxy: %s\n", info.HTTPProxy)
-	ioutils.FprintfIfNotEmpty(cli.out, "Https Proxy: %s\n", info.HTTPSProxy)
-	ioutils.FprintfIfNotEmpty(cli.out, "No Proxy: %s\n", info.NoProxy)
-
-	if info.IndexServerAddress != "" {
-		u := cli.configFile.AuthConfigs[info.IndexServerAddress].Username
-		if len(u) > 0 {
-			fmt.Fprintf(cli.out, "Username: %v\n", u)
-		}
-		fmt.Fprintf(cli.out, "Registry: %v\n", info.IndexServerAddress)
-	}
-
-	// Only output these warnings if the server does not support these features
-	if info.OSType != "windows" {
-		if !info.MemoryLimit {
-			fmt.Fprintln(cli.err, "WARNING: No memory limit support")
-		}
-		if !info.SwapLimit {
-			fmt.Fprintln(cli.err, "WARNING: No swap limit support")
-		}
-		if !info.KernelMemory {
-			fmt.Fprintln(cli.err, "WARNING: No kernel memory limit support")
-		}
-		if !info.OomKillDisable {
-			fmt.Fprintln(cli.err, "WARNING: No oom kill disable support")
-		}
-		if !info.CPUCfsQuota {
-			fmt.Fprintln(cli.err, "WARNING: No cpu cfs quota support")
-		}
-		if !info.CPUCfsPeriod {
-			fmt.Fprintln(cli.err, "WARNING: No cpu cfs period support")
-		}
-		if !info.CPUShares {
-			fmt.Fprintln(cli.err, "WARNING: No cpu shares support")
-		}
-		if !info.CPUSet {
-			fmt.Fprintln(cli.err, "WARNING: No cpuset support")
-		}
-		if !info.IPv4Forwarding {
-			fmt.Fprintln(cli.err, "WARNING: IPv4 forwarding is disabled")
-		}
-		if !info.BridgeNfIptables {
-			fmt.Fprintln(cli.err, "WARNING: bridge-nf-call-iptables is disabled")
-		}
-		if !info.BridgeNfIP6tables {
-			fmt.Fprintln(cli.err, "WARNING: bridge-nf-call-ip6tables is disabled")
-		}
-	}
-
-	if info.Labels != nil {
-		fmt.Fprintln(cli.out, "Labels:")
-		for _, attribute := range info.Labels {
-			fmt.Fprintf(cli.out, " %s\n", attribute)
-		}
-	}
-
-	ioutils.FprintfIfTrue(cli.out, "Experimental: %v\n", info.ExperimentalBuild)
-	if info.ClusterStore != "" {
-		fmt.Fprintf(cli.out, "Cluster Store: %s\n", info.ClusterStore)
-	}
-
-	if info.ClusterAdvertise != "" {
-		fmt.Fprintf(cli.out, "Cluster Advertise: %s\n", info.ClusterAdvertise)
-	}
-
-	if info.RegistryConfig != nil && (len(info.RegistryConfig.InsecureRegistryCIDRs) > 0 || len(info.RegistryConfig.IndexConfigs) > 0) {
-		fmt.Fprintln(cli.out, "Insecure Registries:")
-		for _, registry := range info.RegistryConfig.IndexConfigs {
-			if registry.Secure == false {
-				fmt.Fprintf(cli.out, " %s\n", registry.Name)
-			}
-		}
-
-		for _, registry := range info.RegistryConfig.InsecureRegistryCIDRs {
-			mask, _ := registry.Mask.Size()
-			fmt.Fprintf(cli.out, " %s/%d\n", registry.IP.String(), mask)
-		}
-	}
-	return nil
-}
--- a/api/client/inspect.go
+++ b/api/client/inspect.go
@@ -1,95 +0,0 @@
-package client
-
-import (
-	"fmt"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client/inspect"
-	Cli "github.com/docker/docker/cli"
-	flag "github.com/docker/docker/pkg/mflag"
-	"github.com/docker/engine-api/client"
-)
-
-// CmdInspect displays low-level information on one or more containers, images or tasks.
-//
-// Usage: docker inspect [OPTIONS] CONTAINER|IMAGE|TASK [CONTAINER|IMAGE|TASK...]
-func (cli *DockerCli) CmdInspect(args ...string) error {
-	cmd := Cli.Subcmd("inspect", []string{"[OPTIONS] CONTAINER|IMAGE|TASK [CONTAINER|IMAGE|TASK...]"}, Cli.DockerCommands["inspect"].Description, true)
-	tmplStr := cmd.String([]string{"f", "-format"}, "", "Format the output using the given go template")
-	inspectType := cmd.String([]string{"-type"}, "", "Return JSON for specified type, (e.g image, container or task)")
-	size := cmd.Bool([]string{"s", "-size"}, false, "Display total file sizes if the type is container")
-	cmd.Require(flag.Min, 1)
-
-	cmd.ParseFlags(args, true)
-
-	if *inspectType != "" && *inspectType != "container" && *inspectType != "image" && *inspectType != "task" {
-		return fmt.Errorf("%q is not a valid value for --type", *inspectType)
-	}
-
-	ctx := context.Background()
-
-	var elementSearcher inspect.GetRefFunc
-	switch *inspectType {
-	case "container":
-		elementSearcher = cli.inspectContainers(ctx, *size)
-	case "image":
-		elementSearcher = cli.inspectImages(ctx, *size)
-	case "task":
-		if *size {
-			fmt.Fprintln(cli.err, "WARNING: --size ignored for tasks")
-		}
-		elementSearcher = cli.inspectTasks(ctx)
-	default:
-		elementSearcher = cli.inspectAll(ctx, *size)
-	}
-
-	return inspect.Inspect(cli.out, cmd.Args(), *tmplStr, elementSearcher)
-}
-
-func (cli *DockerCli) inspectContainers(ctx context.Context, getSize bool) inspect.GetRefFunc {
-	return func(ref string) (interface{}, []byte, error) {
-		return cli.client.ContainerInspectWithRaw(ctx, ref, getSize)
-	}
-}
-
-func (cli *DockerCli) inspectImages(ctx context.Context, getSize bool) inspect.GetRefFunc {
-	return func(ref string) (interface{}, []byte, error) {
-		return cli.client.ImageInspectWithRaw(ctx, ref, getSize)
-	}
-}
-
-func (cli *DockerCli) inspectTasks(ctx context.Context) inspect.GetRefFunc {
-	return func(ref string) (interface{}, []byte, error) {
-		return cli.client.TaskInspectWithRaw(ctx, ref)
-	}
-}
-
-func (cli *DockerCli) inspectAll(ctx context.Context, getSize bool) inspect.GetRefFunc {
-	return func(ref string) (interface{}, []byte, error) {
-		c, rawContainer, err := cli.client.ContainerInspectWithRaw(ctx, ref, getSize)
-		if err != nil {
-			// Search for image with that id if a container doesn't exist.
-			if client.IsErrContainerNotFound(err) {
-				i, rawImage, err := cli.client.ImageInspectWithRaw(ctx, ref, getSize)
-				if err != nil {
-					if client.IsErrImageNotFound(err) {
-						// Search for task with that id if an image doesn't exists.
-						t, rawTask, err := cli.client.TaskInspectWithRaw(ctx, ref)
-						if err != nil {
-							return nil, nil, fmt.Errorf("Error: No such image, container or task: %s", ref)
-						}
-						if getSize {
-							fmt.Fprintln(cli.err, "WARNING: --size ignored for tasks")
-						}
-						return t, rawTask, nil
-					}
-					return nil, nil, err
-				}
-				return i, rawImage, nil
-			}
-			return nil, nil, err
-		}
-		return c, rawContainer, nil
-	}
-}
--- a/api/client/inspect/inspector.go
+++ b/api/client/inspect/inspector.go
@@ -1,195 +0,0 @@
-package inspect
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"text/template"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/utils/templates"
-)
-
-// Inspector defines an interface to implement to process elements
-type Inspector interface {
-	Inspect(typedElement interface{}, rawElement []byte) error
-	Flush() error
-}
-
-// TemplateInspector uses a text template to inspect elements.
-type TemplateInspector struct {
-	outputStream io.Writer
-	buffer       *bytes.Buffer
-	tmpl         *template.Template
-}
-
-// NewTemplateInspector creates a new inspector with a template.
-func NewTemplateInspector(outputStream io.Writer, tmpl *template.Template) Inspector {
-	return &TemplateInspector{
-		outputStream: outputStream,
-		buffer:       new(bytes.Buffer),
-		tmpl:         tmpl,
-	}
-}
-
-// NewTemplateInspectorFromString creates a new TemplateInspector from a string
-// which is compiled into a template.
-func NewTemplateInspectorFromString(out io.Writer, tmplStr string) (Inspector, error) {
-	if tmplStr == "" {
-		return NewIndentedInspector(out), nil
-	}
-
-	tmpl, err := templates.Parse(tmplStr)
-	if err != nil {
-		return nil, fmt.Errorf("Template parsing error: %s", err)
-	}
-	return NewTemplateInspector(out, tmpl), nil
-}
-
-// GetRefFunc is a function which used by Inspect to fetch an object from a
-// reference
-type GetRefFunc func(ref string) (interface{}, []byte, error)
-
-// Inspect fetches objects by reference using GetRefFunc and writes the json
-// representation to the output writer.
-func Inspect(out io.Writer, references []string, tmplStr string, getRef GetRefFunc) error {
-	inspector, err := NewTemplateInspectorFromString(out, tmplStr)
-	if err != nil {
-		return cli.StatusError{StatusCode: 64, Status: err.Error()}
-	}
-
-	var inspectErr error
-	for _, ref := range references {
-		element, raw, err := getRef(ref)
-		if err != nil {
-			inspectErr = err
-			break
-		}
-
-		if err := inspector.Inspect(element, raw); err != nil {
-			inspectErr = err
-			break
-		}
-	}
-
-	if err := inspector.Flush(); err != nil {
-		logrus.Errorf("%s\n", err)
-	}
-
-	if inspectErr != nil {
-		return cli.StatusError{StatusCode: 1, Status: inspectErr.Error()}
-	}
-	return nil
-}
-
-// Inspect executes the inspect template.
-// It decodes the raw element into a map if the initial execution fails.
-// This allows docker cli to parse inspect structs injected with Swarm fields.
-func (i *TemplateInspector) Inspect(typedElement interface{}, rawElement []byte) error {
-	buffer := new(bytes.Buffer)
-	if err := i.tmpl.Execute(buffer, typedElement); err != nil {
-		if rawElement == nil {
-			return fmt.Errorf("Template parsing error: %v", err)
-		}
-		return i.tryRawInspectFallback(rawElement)
-	}
-	i.buffer.Write(buffer.Bytes())
-	i.buffer.WriteByte('\n')
-	return nil
-}
-
-// tryRawInspectFallback executes the inspect template with a raw interface.
-// This allows docker cli to parse inspect structs injected with Swarm fields.
-func (i *TemplateInspector) tryRawInspectFallback(rawElement []byte) error {
-	var raw interface{}
-	buffer := new(bytes.Buffer)
-	rdr := bytes.NewReader(rawElement)
-	dec := json.NewDecoder(rdr)
-
-	if rawErr := dec.Decode(&raw); rawErr != nil {
-		return fmt.Errorf("unable to read inspect data: %v", rawErr)
-	}
-
-	tmplMissingKey := i.tmpl.Option("missingkey=error")
-	if rawErr := tmplMissingKey.Execute(buffer, raw); rawErr != nil {
-		return fmt.Errorf("Template parsing error: %v", rawErr)
-	}
-
-	i.buffer.Write(buffer.Bytes())
-	i.buffer.WriteByte('\n')
-	return nil
-}
-
-// Flush write the result of inspecting all elements into the output stream.
-func (i *TemplateInspector) Flush() error {
-	if i.buffer.Len() == 0 {
-		_, err := io.WriteString(i.outputStream, "\n")
-		return err
-	}
-	_, err := io.Copy(i.outputStream, i.buffer)
-	return err
-}
-
-// IndentedInspector uses a buffer to stop the indented representation of an element.
-type IndentedInspector struct {
-	outputStream io.Writer
-	elements     []interface{}
-	rawElements  [][]byte
-}
-
-// NewIndentedInspector generates a new IndentedInspector.
-func NewIndentedInspector(outputStream io.Writer) Inspector {
-	return &IndentedInspector{
-		outputStream: outputStream,
-	}
-}
-
-// Inspect writes the raw element with an indented json format.
-func (i *IndentedInspector) Inspect(typedElement interface{}, rawElement []byte) error {
-	if rawElement != nil {
-		i.rawElements = append(i.rawElements, rawElement)
-	} else {
-		i.elements = append(i.elements, typedElement)
-	}
-	return nil
-}
-
-// Flush write the result of inspecting all elements into the output stream.
-func (i *IndentedInspector) Flush() error {
-	if len(i.elements) == 0 && len(i.rawElements) == 0 {
-		_, err := io.WriteString(i.outputStream, "[]\n")
-		return err
-	}
-
-	var buffer io.Reader
-	if len(i.rawElements) > 0 {
-		bytesBuffer := new(bytes.Buffer)
-		bytesBuffer.WriteString("[")
-		for idx, r := range i.rawElements {
-			bytesBuffer.Write(r)
-			if idx < len(i.rawElements)-1 {
-				bytesBuffer.WriteString(",")
-			}
-		}
-		bytesBuffer.WriteString("]")
-		indented := new(bytes.Buffer)
-		if err := json.Indent(indented, bytesBuffer.Bytes(), "", "    "); err != nil {
-			return err
-		}
-		buffer = indented
-	} else {
-		b, err := json.MarshalIndent(i.elements, "", "    ")
-		if err != nil {
-			return err
-		}
-		buffer = bytes.NewReader(b)
-	}
-
-	if _, err := io.Copy(i.outputStream, buffer); err != nil {
-		return err
-	}
-	_, err := io.WriteString(i.outputStream, "\n")
-	return err
-}
--- a/api/client/inspect/inspector_test.go
+++ b/api/client/inspect/inspector_test.go
@@ -1,221 +0,0 @@
-package inspect
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-
-	"github.com/docker/docker/utils/templates"
-)
-
-type testElement struct {
-	DNS string `json:"Dns"`
-}
-
-func TestTemplateInspectorDefault(t *testing.T) {
-	b := new(bytes.Buffer)
-	tmpl, err := templates.Parse("{{.DNS}}")
-	if err != nil {
-		t.Fatal(err)
-	}
-	i := NewTemplateInspector(b, tmpl)
-	if err := i.Inspect(testElement{"0.0.0.0"}, nil); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := i.Flush(); err != nil {
-		t.Fatal(err)
-	}
-	if b.String() != "0.0.0.0\n" {
-		t.Fatalf("Expected `0.0.0.0\\n`, got `%s`", b.String())
-	}
-}
-
-func TestTemplateInspectorEmpty(t *testing.T) {
-	b := new(bytes.Buffer)
-	tmpl, err := templates.Parse("{{.DNS}}")
-	if err != nil {
-		t.Fatal(err)
-	}
-	i := NewTemplateInspector(b, tmpl)
-
-	if err := i.Flush(); err != nil {
-		t.Fatal(err)
-	}
-	if b.String() != "\n" {
-		t.Fatalf("Expected `\\n`, got `%s`", b.String())
-	}
-}
-
-func TestTemplateInspectorTemplateError(t *testing.T) {
-	b := new(bytes.Buffer)
-	tmpl, err := templates.Parse("{{.Foo}}")
-	if err != nil {
-		t.Fatal(err)
-	}
-	i := NewTemplateInspector(b, tmpl)
-
-	err = i.Inspect(testElement{"0.0.0.0"}, nil)
-	if err == nil {
-		t.Fatal("Expected error got nil")
-	}
-
-	if !strings.HasPrefix(err.Error(), "Template parsing error") {
-		t.Fatalf("Expected template error, got %v", err)
-	}
-}
-
-func TestTemplateInspectorRawFallback(t *testing.T) {
-	b := new(bytes.Buffer)
-	tmpl, err := templates.Parse("{{.Dns}}")
-	if err != nil {
-		t.Fatal(err)
-	}
-	i := NewTemplateInspector(b, tmpl)
-	if err := i.Inspect(testElement{"0.0.0.0"}, []byte(`{"Dns": "0.0.0.0"}`)); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := i.Flush(); err != nil {
-		t.Fatal(err)
-	}
-	if b.String() != "0.0.0.0\n" {
-		t.Fatalf("Expected `0.0.0.0\\n`, got `%s`", b.String())
-	}
-}
-
-func TestTemplateInspectorRawFallbackError(t *testing.T) {
-	b := new(bytes.Buffer)
-	tmpl, err := templates.Parse("{{.Dns}}")
-	if err != nil {
-		t.Fatal(err)
-	}
-	i := NewTemplateInspector(b, tmpl)
-	err = i.Inspect(testElement{"0.0.0.0"}, []byte(`{"Foo": "0.0.0.0"}`))
-	if err == nil {
-		t.Fatal("Expected error got nil")
-	}
-
-	if !strings.HasPrefix(err.Error(), "Template parsing error") {
-		t.Fatalf("Expected template error, got %v", err)
-	}
-}
-
-func TestTemplateInspectorMultiple(t *testing.T) {
-	b := new(bytes.Buffer)
-	tmpl, err := templates.Parse("{{.DNS}}")
-	if err != nil {
-		t.Fatal(err)
-	}
-	i := NewTemplateInspector(b, tmpl)
-
-	if err := i.Inspect(testElement{"0.0.0.0"}, nil); err != nil {
-		t.Fatal(err)
-	}
-	if err := i.Inspect(testElement{"1.1.1.1"}, nil); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := i.Flush(); err != nil {
-		t.Fatal(err)
-	}
-	if b.String() != "0.0.0.0\n1.1.1.1\n" {
-		t.Fatalf("Expected `0.0.0.0\\n1.1.1.1\\n`, got `%s`", b.String())
-	}
-}
-
-func TestIndentedInspectorDefault(t *testing.T) {
-	b := new(bytes.Buffer)
-	i := NewIndentedInspector(b)
-	if err := i.Inspect(testElement{"0.0.0.0"}, nil); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := i.Flush(); err != nil {
-		t.Fatal(err)
-	}
-
-	expected := `[
-    {
-        "Dns": "0.0.0.0"
-    }
-]
-`
-	if b.String() != expected {
-		t.Fatalf("Expected `%s`, got `%s`", expected, b.String())
-	}
-}
-
-func TestIndentedInspectorMultiple(t *testing.T) {
-	b := new(bytes.Buffer)
-	i := NewIndentedInspector(b)
-	if err := i.Inspect(testElement{"0.0.0.0"}, nil); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := i.Inspect(testElement{"1.1.1.1"}, nil); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := i.Flush(); err != nil {
-		t.Fatal(err)
-	}
-
-	expected := `[
-    {
-        "Dns": "0.0.0.0"
-    },
-    {
-        "Dns": "1.1.1.1"
-    }
-]
-`
-	if b.String() != expected {
-		t.Fatalf("Expected `%s`, got `%s`", expected, b.String())
-	}
-}
-
-func TestIndentedInspectorEmpty(t *testing.T) {
-	b := new(bytes.Buffer)
-	i := NewIndentedInspector(b)
-
-	if err := i.Flush(); err != nil {
-		t.Fatal(err)
-	}
-
-	expected := "[]\n"
-	if b.String() != expected {
-		t.Fatalf("Expected `%s`, got `%s`", expected, b.String())
-	}
-}
-
-func TestIndentedInspectorRawElements(t *testing.T) {
-	b := new(bytes.Buffer)
-	i := NewIndentedInspector(b)
-	if err := i.Inspect(testElement{"0.0.0.0"}, []byte(`{"Dns": "0.0.0.0", "Node": "0"}`)); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := i.Inspect(testElement{"1.1.1.1"}, []byte(`{"Dns": "1.1.1.1", "Node": "1"}`)); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := i.Flush(); err != nil {
-		t.Fatal(err)
-	}
-
-	expected := `[
-    {
-        "Dns": "0.0.0.0",
-        "Node": "0"
-    },
-    {
-        "Dns": "1.1.1.1",
-        "Node": "1"
-    }
-]
-`
-	if b.String() != expected {
-		t.Fatalf("Expected `%s`, got `%s`", expected, b.String())
-	}
-}
--- a/api/client/network/cmd.go
+++ b/api/client/network/cmd.go
@@ -1,31 +0,0 @@
-package network
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-)
-
-// NewNetworkCommand returns a cobra command for `network` subcommands
-func NewNetworkCommand(dockerCli *client.DockerCli) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "network",
-		Short: "Manage Docker networks",
-		Args:  cli.NoArgs,
-		Run: func(cmd *cobra.Command, args []string) {
-			fmt.Fprintf(dockerCli.Err(), "\n"+cmd.UsageString())
-		},
-	}
-	cmd.AddCommand(
-		newConnectCommand(dockerCli),
-		newCreateCommand(dockerCli),
-		newDisconnectCommand(dockerCli),
-		newInspectCommand(dockerCli),
-		newListCommand(dockerCli),
-		newRemoveCommand(dockerCli),
-	)
-	return cmd
-}
--- a/api/client/network/connect.go
+++ b/api/client/network/connect.go
@@ -1,64 +0,0 @@
-package network
-
-import (
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/opts"
-	runconfigopts "github.com/docker/docker/runconfig/opts"
-	"github.com/docker/engine-api/types/network"
-	"github.com/spf13/cobra"
-)
-
-type connectOptions struct {
-	network      string
-	container    string
-	ipaddress    string
-	ipv6address  string
-	links        opts.ListOpts
-	aliases      []string
-	linklocalips []string
-}
-
-func newConnectCommand(dockerCli *client.DockerCli) *cobra.Command {
-	opts := connectOptions{
-		links: opts.NewListOpts(runconfigopts.ValidateLink),
-	}
-
-	cmd := &cobra.Command{
-		Use:   "connect [OPTIONS] NETWORK CONTAINER",
-		Short: "Connect a container to a network",
-		Args:  cli.ExactArgs(2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.network = args[0]
-			opts.container = args[1]
-			return runConnect(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.StringVar(&opts.ipaddress, "ip", "", "IP Address")
-	flags.StringVar(&opts.ipv6address, "ip6", "", "IPv6 Address")
-	flags.Var(&opts.links, "link", "Add link to another container")
-	flags.StringSliceVar(&opts.aliases, "alias", []string{}, "Add network-scoped alias for the container")
-	flags.StringSliceVar(&opts.linklocalips, "link-local-ip", []string{}, "Add a link-local address for the container")
-
-	return cmd
-}
-
-func runConnect(dockerCli *client.DockerCli, opts connectOptions) error {
-	client := dockerCli.Client()
-
-	epConfig := &network.EndpointSettings{
-		IPAMConfig: &network.EndpointIPAMConfig{
-			IPv4Address:  opts.ipaddress,
-			IPv6Address:  opts.ipv6address,
-			LinkLocalIPs: opts.linklocalips,
-		},
-		Links:   opts.links.GetAll(),
-		Aliases: opts.aliases,
-	}
-
-	return client.NetworkConnect(context.Background(), opts.network, opts.container, epConfig)
-}
--- a/api/client/network/create.go
+++ b/api/client/network/create.go
@@ -1,222 +0,0 @@
-package network
-
-import (
-	"fmt"
-	"net"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/opts"
-	runconfigopts "github.com/docker/docker/runconfig/opts"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/network"
-	"github.com/spf13/cobra"
-)
-
-type createOptions struct {
-	name       string
-	driver     string
-	driverOpts opts.MapOpts
-	labels     []string
-	internal   bool
-	ipv6       bool
-
-	ipamDriver  string
-	ipamSubnet  []string
-	ipamIPRange []string
-	ipamGateway []string
-	ipamAux     opts.MapOpts
-	ipamOpt     opts.MapOpts
-}
-
-func newCreateCommand(dockerCli *client.DockerCli) *cobra.Command {
-	opts := createOptions{
-		driverOpts: *opts.NewMapOpts(nil, nil),
-		ipamAux:    *opts.NewMapOpts(nil, nil),
-		ipamOpt:    *opts.NewMapOpts(nil, nil),
-	}
-
-	cmd := &cobra.Command{
-		Use:   "create [OPTIONS] NETWORK",
-		Short: "Create a network",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.name = args[0]
-			return runCreate(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.StringVarP(&opts.driver, "driver", "d", "bridge", "Driver to manage the Network")
-	flags.VarP(&opts.driverOpts, "opt", "o", "Set driver specific options")
-	flags.StringSliceVar(&opts.labels, "label", []string{}, "Set metadata on a network")
-	flags.BoolVar(&opts.internal, "internal", false, "Restrict external access to the network")
-	flags.BoolVar(&opts.ipv6, "ipv6", false, "Enable IPv6 networking")
-
-	flags.StringVar(&opts.ipamDriver, "ipam-driver", "default", "IP Address Management Driver")
-	flags.StringSliceVar(&opts.ipamSubnet, "subnet", []string{}, "Subnet in CIDR format that represents a network segment")
-	flags.StringSliceVar(&opts.ipamIPRange, "ip-range", []string{}, "Allocate container ip from a sub-range")
-	flags.StringSliceVar(&opts.ipamGateway, "gateway", []string{}, "IPv4 or IPv6 Gateway for the master subnet")
-
-	flags.Var(&opts.ipamAux, "aux-address", "Auxiliary IPv4 or IPv6 addresses used by Network driver")
-	flags.Var(&opts.ipamOpt, "ipam-opt", "Set IPAM driver specific options")
-
-	return cmd
-}
-
-func runCreate(dockerCli *client.DockerCli, opts createOptions) error {
-	client := dockerCli.Client()
-
-	ipamCfg, err := consolidateIpam(opts.ipamSubnet, opts.ipamIPRange, opts.ipamGateway, opts.ipamAux.GetAll())
-	if err != nil {
-		return err
-	}
-
-	// Construct network create request body
-	nc := types.NetworkCreate{
-		Driver:  opts.driver,
-		Options: opts.driverOpts.GetAll(),
-		IPAM: network.IPAM{
-			Driver:  opts.ipamDriver,
-			Config:  ipamCfg,
-			Options: opts.ipamOpt.GetAll(),
-		},
-		CheckDuplicate: true,
-		Internal:       opts.internal,
-		EnableIPv6:     opts.ipv6,
-		Labels:         runconfigopts.ConvertKVStringsToMap(opts.labels),
-	}
-
-	resp, err := client.NetworkCreate(context.Background(), opts.name, nc)
-	if err != nil {
-		return err
-	}
-	fmt.Fprintf(dockerCli.Out(), "%s\n", resp.ID)
-	return nil
-}
-
-// Consolidates the ipam configuration as a group from different related configurations
-// user can configure network with multiple non-overlapping subnets and hence it is
-// possible to correlate the various related parameters and consolidate them.
-// consoidateIpam consolidates subnets, ip-ranges, gateways and auxiliary addresses into
-// structured ipam data.
-func consolidateIpam(subnets, ranges, gateways []string, auxaddrs map[string]string) ([]network.IPAMConfig, error) {
-	if len(subnets) < len(ranges) || len(subnets) < len(gateways) {
-		return nil, fmt.Errorf("every ip-range or gateway must have a corresponding subnet")
-	}
-	iData := map[string]*network.IPAMConfig{}
-
-	// Populate non-overlapping subnets into consolidation map
-	for _, s := range subnets {
-		for k := range iData {
-			ok1, err := subnetMatches(s, k)
-			if err != nil {
-				return nil, err
-			}
-			ok2, err := subnetMatches(k, s)
-			if err != nil {
-				return nil, err
-			}
-			if ok1 || ok2 {
-				return nil, fmt.Errorf("multiple overlapping subnet configuration is not supported")
-			}
-		}
-		iData[s] = &network.IPAMConfig{Subnet: s, AuxAddress: map[string]string{}}
-	}
-
-	// Validate and add valid ip ranges
-	for _, r := range ranges {
-		match := false
-		for _, s := range subnets {
-			ok, err := subnetMatches(s, r)
-			if err != nil {
-				return nil, err
-			}
-			if !ok {
-				continue
-			}
-			if iData[s].IPRange != "" {
-				return nil, fmt.Errorf("cannot configure multiple ranges (%s, %s) on the same subnet (%s)", r, iData[s].IPRange, s)
-			}
-			d := iData[s]
-			d.IPRange = r
-			match = true
-		}
-		if !match {
-			return nil, fmt.Errorf("no matching subnet for range %s", r)
-		}
-	}
-
-	// Validate and add valid gateways
-	for _, g := range gateways {
-		match := false
-		for _, s := range subnets {
-			ok, err := subnetMatches(s, g)
-			if err != nil {
-				return nil, err
-			}
-			if !ok {
-				continue
-			}
-			if iData[s].Gateway != "" {
-				return nil, fmt.Errorf("cannot configure multiple gateways (%s, %s) for the same subnet (%s)", g, iData[s].Gateway, s)
-			}
-			d := iData[s]
-			d.Gateway = g
-			match = true
-		}
-		if !match {
-			return nil, fmt.Errorf("no matching subnet for gateway %s", g)
-		}
-	}
-
-	// Validate and add aux-addresses
-	for key, aa := range auxaddrs {
-		match := false
-		for _, s := range subnets {
-			ok, err := subnetMatches(s, aa)
-			if err != nil {
-				return nil, err
-			}
-			if !ok {
-				continue
-			}
-			iData[s].AuxAddress[key] = aa
-			match = true
-		}
-		if !match {
-			return nil, fmt.Errorf("no matching subnet for aux-address %s", aa)
-		}
-	}
-
-	idl := []network.IPAMConfig{}
-	for _, v := range iData {
-		idl = append(idl, *v)
-	}
-	return idl, nil
-}
-
-func subnetMatches(subnet, data string) (bool, error) {
-	var (
-		ip net.IP
-	)
-
-	_, s, err := net.ParseCIDR(subnet)
-	if err != nil {
-		return false, fmt.Errorf("Invalid subnet %s : %v", s, err)
-	}
-
-	if strings.Contains(data, "/") {
-		ip, _, err = net.ParseCIDR(data)
-		if err != nil {
-			return false, fmt.Errorf("Invalid cidr %s : %v", data, err)
-		}
-	} else {
-		ip = net.ParseIP(data)
-	}
-
-	return s.Contains(ip), nil
-}
--- a/api/client/network/disconnect.go
+++ b/api/client/network/disconnect.go
@@ -1,41 +0,0 @@
-package network
-
-import (
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type disconnectOptions struct {
-	network   string
-	container string
-	force     bool
-}
-
-func newDisconnectCommand(dockerCli *client.DockerCli) *cobra.Command {
-	opts := disconnectOptions{}
-
-	cmd := &cobra.Command{
-		Use:   "disconnect [OPTIONS] NETWORK CONTAINER",
-		Short: "Disconnect a container from a network",
-		Args:  cli.ExactArgs(2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.network = args[0]
-			opts.container = args[1]
-			return runDisconnect(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.BoolVarP(&opts.force, "force", "f", false, "Force the container to disconnect from a network")
-
-	return cmd
-}
-
-func runDisconnect(dockerCli *client.DockerCli, opts disconnectOptions) error {
-	client := dockerCli.Client()
-
-	return client.NetworkDisconnect(context.Background(), opts.network, opts.container, opts.force)
-}
--- a/api/client/network/inspect.go
+++ b/api/client/network/inspect.go
@@ -1,45 +0,0 @@
-package network
-
-import (
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/api/client/inspect"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-type inspectOptions struct {
-	format string
-	names  []string
-}
-
-func newInspectCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts inspectOptions
-
-	cmd := &cobra.Command{
-		Use:   "inspect [OPTIONS] NETWORK [NETWORK...]",
-		Short: "Display detailed information on one or more networks",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.names = args
-			return runInspect(dockerCli, opts)
-		},
-	}
-
-	cmd.Flags().StringVarP(&opts.format, "format", "f", "", "Format the output using the given go template")
-
-	return cmd
-}
-
-func runInspect(dockerCli *client.DockerCli, opts inspectOptions) error {
-	client := dockerCli.Client()
-
-	ctx := context.Background()
-
-	getNetFunc := func(name string) (interface{}, []byte, error) {
-		return client.NetworkInspectWithRaw(ctx, name)
-	}
-
-	return inspect.Inspect(dockerCli.Out(), opts.names, opts.format, getNetFunc)
-}
--- a/api/client/network/list.go
+++ b/api/client/network/list.go
@@ -1,100 +0,0 @@
-package network
-
-import (
-	"fmt"
-	"sort"
-	"text/tabwriter"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	"github.com/spf13/cobra"
-)
-
-type byNetworkName []types.NetworkResource
-
-func (r byNetworkName) Len() int           { return len(r) }
-func (r byNetworkName) Swap(i, j int)      { r[i], r[j] = r[j], r[i] }
-func (r byNetworkName) Less(i, j int) bool { return r[i].Name < r[j].Name }
-
-type listOptions struct {
-	quiet   bool
-	noTrunc bool
-	filter  []string
-}
-
-func newListCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts listOptions
-
-	cmd := &cobra.Command{
-		Use:     "ls [OPTIONS]",
-		Aliases: []string{"list"},
-		Short:   "List networks",
-		Args:    cli.NoArgs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runList(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Only display network IDs")
-	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Do not truncate the output")
-	flags.StringSliceVarP(&opts.filter, "filter", "f", []string{}, "Provide filter values (i.e. 'dangling=true')")
-
-	return cmd
-}
-
-func runList(dockerCli *client.DockerCli, opts listOptions) error {
-	client := dockerCli.Client()
-
-	netFilterArgs := filters.NewArgs()
-	for _, f := range opts.filter {
-		var err error
-		netFilterArgs, err = filters.ParseFlag(f, netFilterArgs)
-		if err != nil {
-			return err
-		}
-	}
-
-	options := types.NetworkListOptions{
-		Filters: netFilterArgs,
-	}
-
-	networkResources, err := client.NetworkList(context.Background(), options)
-	if err != nil {
-		return err
-	}
-
-	w := tabwriter.NewWriter(dockerCli.Out(), 20, 1, 3, ' ', 0)
-	if !opts.quiet {
-		fmt.Fprintf(w, "NETWORK ID\tNAME\tDRIVER\tSCOPE")
-		fmt.Fprintf(w, "\n")
-	}
-
-	sort.Sort(byNetworkName(networkResources))
-	for _, networkResource := range networkResources {
-		ID := networkResource.ID
-		netName := networkResource.Name
-		driver := networkResource.Driver
-		scope := networkResource.Scope
-		if !opts.noTrunc {
-			ID = stringid.TruncateID(ID)
-		}
-		if opts.quiet {
-			fmt.Fprintln(w, ID)
-			continue
-		}
-		fmt.Fprintf(w, "%s\t%s\t%s\t%s\t",
-			ID,
-			netName,
-			driver,
-			scope)
-		fmt.Fprint(w, "\n")
-	}
-	w.Flush()
-	return nil
-}
--- a/api/client/network/remove.go
+++ b/api/client/network/remove.go
@@ -1,43 +0,0 @@
-package network
-
-import (
-	"fmt"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-func newRemoveCommand(dockerCli *client.DockerCli) *cobra.Command {
-	return &cobra.Command{
-		Use:     "rm NETWORK [NETWORK...]",
-		Aliases: []string{"remove"},
-		Short:   "Remove one or more networks",
-		Args:    cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runRemove(dockerCli, args)
-		},
-	}
-}
-
-func runRemove(dockerCli *client.DockerCli, networks []string) error {
-	client := dockerCli.Client()
-	ctx := context.Background()
-	status := 0
-
-	for _, name := range networks {
-		if err := client.NetworkRemove(ctx, name); err != nil {
-			fmt.Fprintf(dockerCli.Err(), "%s\n", err)
-			status = 1
-			continue
-		}
-		fmt.Fprintf(dockerCli.Out(), "%s\n", name)
-	}
-
-	if status != 0 {
-		return cli.StatusError{StatusCode: status}
-	}
-	return nil
-}
--- a/api/client/node/cmd.go
+++ b/api/client/node/cmd.go
@@ -1,49 +0,0 @@
-package node
-
-import (
-	"fmt"
-
-	"golang.org/x/net/context"
-
-	"github.com/spf13/cobra"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	apiclient "github.com/docker/engine-api/client"
-)
-
-// NewNodeCommand returns a cobra command for `node` subcommands
-func NewNodeCommand(dockerCli *client.DockerCli) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "node",
-		Short: "Manage Docker Swarm nodes",
-		Args:  cli.NoArgs,
-		Run: func(cmd *cobra.Command, args []string) {
-			fmt.Fprintf(dockerCli.Err(), "\n"+cmd.UsageString())
-		},
-	}
-	cmd.AddCommand(
-		newDemoteCommand(dockerCli),
-		newInspectCommand(dockerCli),
-		newListCommand(dockerCli),
-		newPromoteCommand(dockerCli),
-		newRemoveCommand(dockerCli),
-		newPSCommand(dockerCli),
-		newUpdateCommand(dockerCli),
-	)
-	return cmd
-}
-
-// Reference returns the reference of a node. The special value "self" for a node
-// reference is mapped to the current node, hence the node ID is retrieved using
-// the `/info` endpoint.
-func Reference(client apiclient.APIClient, ctx context.Context, ref string) (string, error) {
-	if ref == "self" {
-		info, err := client.Info(ctx)
-		if err != nil {
-			return "", err
-		}
-		return info.Swarm.NodeID, nil
-	}
-	return ref, nil
-}
--- a/api/client/node/demote.go
+++ b/api/client/node/demote.go
@@ -1,32 +0,0 @@
-package node
-
-import (
-	"fmt"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/engine-api/types/swarm"
-	"github.com/spf13/cobra"
-)
-
-func newDemoteCommand(dockerCli *client.DockerCli) *cobra.Command {
-	return &cobra.Command{
-		Use:   "demote NODE [NODE...]",
-		Short: "Demote one or more nodes from manager in the swarm",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runDemote(dockerCli, args)
-		},
-	}
-}
-
-func runDemote(dockerCli *client.DockerCli, nodes []string) error {
-	demote := func(node *swarm.Node) error {
-		node.Spec.Role = swarm.NodeRoleWorker
-		return nil
-	}
-	success := func(nodeID string) {
-		fmt.Fprintf(dockerCli.Out(), "Manager %s demoted in the swarm.\n", nodeID)
-	}
-	return updateNodes(dockerCli, nodes, demote, success)
-}
--- a/api/client/node/inspect.go
+++ b/api/client/node/inspect.go
@@ -1,144 +0,0 @@
-package node
-
-import (
-	"fmt"
-	"io"
-	"sort"
-	"strings"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/api/client/inspect"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/pkg/ioutils"
-	"github.com/docker/engine-api/types/swarm"
-	"github.com/docker/go-units"
-	"github.com/spf13/cobra"
-	"golang.org/x/net/context"
-)
-
-type inspectOptions struct {
-	nodeIds []string
-	format  string
-	pretty  bool
-}
-
-func newInspectCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var opts inspectOptions
-
-	cmd := &cobra.Command{
-		Use:   "inspect [OPTIONS] self|NODE [NODE...]",
-		Short: "Display detailed information on one or more nodes",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.nodeIds = args
-			return runInspect(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.StringVarP(&opts.format, "format", "f", "", "Format the output using the given go template")
-	flags.BoolVar(&opts.pretty, "pretty", false, "Print the information in a human friendly format.")
-	return cmd
-}
-
-func runInspect(dockerCli *client.DockerCli, opts inspectOptions) error {
-	client := dockerCli.Client()
-	ctx := context.Background()
-	getRef := func(ref string) (interface{}, []byte, error) {
-		nodeRef, err := Reference(client, ctx, ref)
-		if err != nil {
-			return nil, nil, err
-		}
-		node, _, err := client.NodeInspectWithRaw(ctx, nodeRef)
-		return node, nil, err
-	}
-
-	if !opts.pretty {
-		return inspect.Inspect(dockerCli.Out(), opts.nodeIds, opts.format, getRef)
-	}
-	return printHumanFriendly(dockerCli.Out(), opts.nodeIds, getRef)
-}
-
-func printHumanFriendly(out io.Writer, refs []string, getRef inspect.GetRefFunc) error {
-	for idx, ref := range refs {
-		obj, _, err := getRef(ref)
-		if err != nil {
-			return err
-		}
-		printNode(out, obj.(swarm.Node))
-
-		// TODO: better way to do this?
-		// print extra space between objects, but not after the last one
-		if idx+1 != len(refs) {
-			fmt.Fprintf(out, "\n\n")
-		} else {
-			fmt.Fprintf(out, "\n")
-		}
-	}
-	return nil
-}
-
-// TODO: use a template
-func printNode(out io.Writer, node swarm.Node) {
-	fmt.Fprintf(out, "ID:\t\t\t%s\n", node.ID)
-	ioutils.FprintfIfNotEmpty(out, "Name:\t\t\t%s\n", node.Spec.Name)
-	if node.Spec.Labels != nil {
-		fmt.Fprintln(out, "Labels:")
-		for k, v := range node.Spec.Labels {
-			fmt.Fprintf(out, " - %s = %s\n", k, v)
-		}
-	}
-
-	ioutils.FprintfIfNotEmpty(out, "Hostname:\t\t%s\n", node.Description.Hostname)
-	fmt.Fprintf(out, "Joined at:\t\t%s\n", client.PrettyPrint(node.CreatedAt))
-	fmt.Fprintln(out, "Status:")
-	fmt.Fprintf(out, " State:\t\t\t%s\n", client.PrettyPrint(node.Status.State))
-	ioutils.FprintfIfNotEmpty(out, " Message:\t\t%s\n", client.PrettyPrint(node.Status.Message))
-	fmt.Fprintf(out, " Availability:\t\t%s\n", client.PrettyPrint(node.Spec.Availability))
-
-	if node.ManagerStatus != nil {
-		fmt.Fprintln(out, "Manager Status:")
-		fmt.Fprintf(out, " Address:\t\t%s\n", node.ManagerStatus.Addr)
-		fmt.Fprintf(out, " Raft Status:\t\t%s\n", client.PrettyPrint(node.ManagerStatus.Reachability))
-		leader := "No"
-		if node.ManagerStatus.Leader {
-			leader = "Yes"
-		}
-		fmt.Fprintf(out, " Leader:\t\t%s\n", leader)
-	}
-
-	fmt.Fprintln(out, "Platform:")
-	fmt.Fprintf(out, " Operating System:\t%s\n", node.Description.Platform.OS)
-	fmt.Fprintf(out, " Architecture:\t\t%s\n", node.Description.Platform.Architecture)
-
-	fmt.Fprintln(out, "Resources:")
-	fmt.Fprintf(out, " CPUs:\t\t\t%d\n", node.Description.Resources.NanoCPUs/1e9)
-	fmt.Fprintf(out, " Memory:\t\t%s\n", units.BytesSize(float64(node.Description.Resources.MemoryBytes)))
-
-	var pluginTypes []string
-	pluginNamesByType := map[string][]string{}
-	for _, p := range node.Description.Engine.Plugins {
-		// append to pluginTypes only if not done previously
-		if _, ok := pluginNamesByType[p.Type]; !ok {
-			pluginTypes = append(pluginTypes, p.Type)
-		}
-		pluginNamesByType[p.Type] = append(pluginNamesByType[p.Type], p.Name)
-	}
-
-	if len(pluginTypes) > 0 {
-		fmt.Fprintln(out, "Plugins:")
-		sort.Strings(pluginTypes) // ensure stable output
-		for _, pluginType := range pluginTypes {
-			fmt.Fprintf(out, "  %s:\t\t%s\n", pluginType, strings.Join(pluginNamesByType[pluginType], ", "))
-		}
-	}
-	fmt.Fprintf(out, "Engine Version:\t\t%s\n", node.Description.Engine.EngineVersion)
-
-	if len(node.Description.Engine.Labels) != 0 {
-		fmt.Fprintln(out, "Engine Labels:")
-		for k, v := range node.Description.Engine.Labels {
-			fmt.Fprintf(out, " - %s = %s", k, v)
-		}
-	}
-
-}
--- a/api/client/node/list.go
+++ b/api/client/node/list.go
@@ -1,111 +0,0 @@
-package node
-
-import (
-	"fmt"
-	"io"
-	"text/tabwriter"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/opts"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/swarm"
-	"github.com/spf13/cobra"
-)
-
-const (
-	listItemFmt = "%s\t%s\t%s\t%s\t%s\n"
-)
-
-type listOptions struct {
-	quiet  bool
-	filter opts.FilterOpt
-}
-
-func newListCommand(dockerCli *client.DockerCli) *cobra.Command {
-	opts := listOptions{filter: opts.NewFilterOpt()}
-
-	cmd := &cobra.Command{
-		Use:     "ls [OPTIONS]",
-		Aliases: []string{"list"},
-		Short:   "List nodes in the swarm",
-		Args:    cli.NoArgs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runList(dockerCli, opts)
-		},
-	}
-	flags := cmd.Flags()
-	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Only display IDs")
-	flags.VarP(&opts.filter, "filter", "f", "Filter output based on conditions provided")
-
-	return cmd
-}
-
-func runList(dockerCli *client.DockerCli, opts listOptions) error {
-	client := dockerCli.Client()
-	ctx := context.Background()
-
-	nodes, err := client.NodeList(
-		ctx,
-		types.NodeListOptions{Filter: opts.filter.Value()})
-	if err != nil {
-		return err
-	}
-
-	info, err := client.Info(ctx)
-	if err != nil {
-		return err
-	}
-
-	out := dockerCli.Out()
-	if opts.quiet {
-		printQuiet(out, nodes)
-	} else {
-		printTable(out, nodes, info)
-	}
-	return nil
-}
-
-func printTable(out io.Writer, nodes []swarm.Node, info types.Info) {
-	writer := tabwriter.NewWriter(out, 0, 4, 2, ' ', 0)
-
-	// Ignore flushing errors
-	defer writer.Flush()
-
-	fmt.Fprintf(writer, listItemFmt, "ID", "HOSTNAME", "STATUS", "AVAILABILITY", "MANAGER STATUS")
-	for _, node := range nodes {
-		name := node.Description.Hostname
-		availability := string(node.Spec.Availability)
-
-		reachability := ""
-		if node.ManagerStatus != nil {
-			if node.ManagerStatus.Leader {
-				reachability = "Leader"
-			} else {
-				reachability = string(node.ManagerStatus.Reachability)
-			}
-		}
-
-		ID := node.ID
-		if node.ID == info.Swarm.NodeID {
-			ID = ID + " *"
-		}
-
-		fmt.Fprintf(
-			writer,
-			listItemFmt,
-			ID,
-			name,
-			client.PrettyPrint(string(node.Status.State)),
-			client.PrettyPrint(availability),
-			client.PrettyPrint(reachability))
-	}
-}
-
-func printQuiet(out io.Writer, nodes []swarm.Node) {
-	for _, node := range nodes {
-		fmt.Fprintln(out, node.ID)
-	}
-}
--- a/api/client/node/opts.go
+++ b/api/client/node/opts.go
@@ -1,60 +0,0 @@
-package node
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/docker/docker/opts"
-	runconfigopts "github.com/docker/docker/runconfig/opts"
-	"github.com/docker/engine-api/types/swarm"
-)
-
-type nodeOptions struct {
-	annotations
-	role         string
-	availability string
-}
-
-type annotations struct {
-	name   string
-	labels opts.ListOpts
-}
-
-func newNodeOptions() *nodeOptions {
-	return &nodeOptions{
-		annotations: annotations{
-			labels: opts.NewListOpts(nil),
-		},
-	}
-}
-
-func (opts *nodeOptions) ToNodeSpec() (swarm.NodeSpec, error) {
-	var spec swarm.NodeSpec
-
-	spec.Annotations.Name = opts.annotations.name
-	spec.Annotations.Labels = runconfigopts.ConvertKVStringsToMap(opts.annotations.labels.GetAll())
-
-	switch swarm.NodeRole(strings.ToLower(opts.role)) {
-	case swarm.NodeRoleWorker:
-		spec.Role = swarm.NodeRoleWorker
-	case swarm.NodeRoleManager:
-		spec.Role = swarm.NodeRoleManager
-	case "":
-	default:
-		return swarm.NodeSpec{}, fmt.Errorf("invalid role %q, only worker and manager are supported", opts.role)
-	}
-
-	switch swarm.NodeAvailability(strings.ToLower(opts.availability)) {
-	case swarm.NodeAvailabilityActive:
-		spec.Availability = swarm.NodeAvailabilityActive
-	case swarm.NodeAvailabilityPause:
-		spec.Availability = swarm.NodeAvailabilityPause
-	case swarm.NodeAvailabilityDrain:
-		spec.Availability = swarm.NodeAvailabilityDrain
-	case "":
-	default:
-		return swarm.NodeSpec{}, fmt.Errorf("invalid availability %q, only active, pause and drain are supported", opts.availability)
-	}
-
-	return spec, nil
-}
--- a/api/client/node/promote.go
+++ b/api/client/node/promote.go
@@ -1,32 +0,0 @@
-package node
-
-import (
-	"fmt"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/engine-api/types/swarm"
-	"github.com/spf13/cobra"
-)
-
-func newPromoteCommand(dockerCli *client.DockerCli) *cobra.Command {
-	return &cobra.Command{
-		Use:   "promote NODE [NODE...]",
-		Short: "Promote one or more nodes to manager in the swarm",
-		Args:  cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runPromote(dockerCli, args)
-		},
-	}
-}
-
-func runPromote(dockerCli *client.DockerCli, nodes []string) error {
-	promote := func(node *swarm.Node) error {
-		node.Spec.Role = swarm.NodeRoleManager
-		return nil
-	}
-	success := func(nodeID string) {
-		fmt.Fprintf(dockerCli.Out(), "Node %s promoted to a manager in the swarm.\n", nodeID)
-	}
-	return updateNodes(dockerCli, nodes, promote, success)
-}
--- a/api/client/node/ps.go
+++ b/api/client/node/ps.go
@@ -1,63 +0,0 @@
-package node
-
-import (
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/api/client/idresolver"
-	"github.com/docker/docker/api/client/task"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/opts"
-	"github.com/docker/engine-api/types"
-	"github.com/spf13/cobra"
-)
-
-type psOptions struct {
-	nodeID    string
-	noResolve bool
-	filter    opts.FilterOpt
-}
-
-func newPSCommand(dockerCli *client.DockerCli) *cobra.Command {
-	opts := psOptions{filter: opts.NewFilterOpt()}
-
-	cmd := &cobra.Command{
-		Use:   "ps [OPTIONS] self|NODE",
-		Short: "List tasks running on a node",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.nodeID = args[0]
-			return runPS(dockerCli, opts)
-		},
-	}
-	flags := cmd.Flags()
-	flags.BoolVar(&opts.noResolve, "no-resolve", false, "Do not map IDs to Names")
-	flags.VarP(&opts.filter, "filter", "f", "Filter output based on conditions provided")
-
-	return cmd
-}
-
-func runPS(dockerCli *client.DockerCli, opts psOptions) error {
-	client := dockerCli.Client()
-	ctx := context.Background()
-
-	nodeRef, err := Reference(client, ctx, opts.nodeID)
-	if err != nil {
-		return nil
-	}
-	node, _, err := client.NodeInspectWithRaw(ctx, nodeRef)
-	if err != nil {
-		return err
-	}
-
-	filter := opts.filter.Value()
-	filter.Add("node", node.ID)
-	tasks, err := client.TaskList(
-		ctx,
-		types.TaskListOptions{Filter: filter})
-	if err != nil {
-		return err
-	}
-
-	return task.Print(dockerCli, ctx, tasks, idresolver.New(client, opts.noResolve))
-}
--- a/api/client/node/remove.go
+++ b/api/client/node/remove.go
@@ -1,46 +0,0 @@
-package node
-
-import (
-	"fmt"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/engine-api/types"
-	"github.com/spf13/cobra"
-)
-
-type removeOptions struct {
-	force bool
-}
-
-func newRemoveCommand(dockerCli *client.DockerCli) *cobra.Command {
-	opts := removeOptions{}
-
-	cmd := &cobra.Command{
-		Use:     "rm [OPTIONS] NODE [NODE...]",
-		Aliases: []string{"remove"},
-		Short:   "Remove one or more nodes from the swarm",
-		Args:    cli.RequiresMinArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runRemove(dockerCli, args, opts)
-		},
-	}
-	flags := cmd.Flags()
-	flags.BoolVar(&opts.force, "force", false, "Force remove an active node")
-	return cmd
-}
-
-func runRemove(dockerCli *client.DockerCli, args []string, opts removeOptions) error {
-	client := dockerCli.Client()
-	ctx := context.Background()
-	for _, nodeID := range args {
-		err := client.NodeRemove(ctx, nodeID, types.NodeRemoveOptions{Force: opts.force})
-		if err != nil {
-			return err
-		}
-		fmt.Fprintf(dockerCli.Out(), "%s\n", nodeID)
-	}
-	return nil
-}
--- a/api/client/node/update.go
+++ b/api/client/node/update.go
@@ -1,113 +0,0 @@
-package node
-
-import (
-	"fmt"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/opts"
-	runconfigopts "github.com/docker/docker/runconfig/opts"
-	"github.com/docker/engine-api/types/swarm"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-	"golang.org/x/net/context"
-)
-
-func newUpdateCommand(dockerCli *client.DockerCli) *cobra.Command {
-	nodeOpts := newNodeOptions()
-
-	cmd := &cobra.Command{
-		Use:   "update [OPTIONS] NODE",
-		Short: "Update a node",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runUpdate(dockerCli, cmd.Flags(), args[0])
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.StringVar(&nodeOpts.role, flagRole, "", "Role of the node (worker/manager)")
-	flags.StringVar(&nodeOpts.availability, flagAvailability, "", "Availability of the node (active/pause/drain)")
-	flags.Var(&nodeOpts.annotations.labels, flagLabelAdd, "Add or update a node label (key=value)")
-	labelKeys := opts.NewListOpts(nil)
-	flags.Var(&labelKeys, flagLabelRemove, "Remove a node label if exists")
-	return cmd
-}
-
-func runUpdate(dockerCli *client.DockerCli, flags *pflag.FlagSet, nodeID string) error {
-	success := func(_ string) {
-		fmt.Fprintln(dockerCli.Out(), nodeID)
-	}
-	return updateNodes(dockerCli, []string{nodeID}, mergeNodeUpdate(flags), success)
-}
-
-func updateNodes(dockerCli *client.DockerCli, nodes []string, mergeNode func(node *swarm.Node) error, success func(nodeID string)) error {
-	client := dockerCli.Client()
-	ctx := context.Background()
-
-	for _, nodeID := range nodes {
-		node, _, err := client.NodeInspectWithRaw(ctx, nodeID)
-		if err != nil {
-			return err
-		}
-
-		err = mergeNode(&node)
-		if err != nil {
-			return err
-		}
-		err = client.NodeUpdate(ctx, node.ID, node.Version, node.Spec)
-		if err != nil {
-			return err
-		}
-		success(nodeID)
-	}
-	return nil
-}
-
-func mergeNodeUpdate(flags *pflag.FlagSet) func(*swarm.Node) error {
-	return func(node *swarm.Node) error {
-		spec := &node.Spec
-
-		if flags.Changed(flagRole) {
-			str, err := flags.GetString(flagRole)
-			if err != nil {
-				return err
-			}
-			spec.Role = swarm.NodeRole(str)
-		}
-		if flags.Changed(flagAvailability) {
-			str, err := flags.GetString(flagAvailability)
-			if err != nil {
-				return err
-			}
-			spec.Availability = swarm.NodeAvailability(str)
-		}
-		if spec.Annotations.Labels == nil {
-			spec.Annotations.Labels = make(map[string]string)
-		}
-		if flags.Changed(flagLabelAdd) {
-			labels := flags.Lookup(flagLabelAdd).Value.(*opts.ListOpts).GetAll()
-			for k, v := range runconfigopts.ConvertKVStringsToMap(labels) {
-				spec.Annotations.Labels[k] = v
-			}
-		}
-		if flags.Changed(flagLabelRemove) {
-			keys := flags.Lookup(flagLabelRemove).Value.(*opts.ListOpts).GetAll()
-			for _, k := range keys {
-				// if a key doesn't exist, fail the command explicitly
-				if _, exists := spec.Annotations.Labels[k]; !exists {
-					return fmt.Errorf("key %s doesn't exist in node's labels", k)
-				}
-				delete(spec.Annotations.Labels, k)
-			}
-		}
-		return nil
-	}
-}
-
-const (
-	flagRole         = "role"
-	flagAvailability = "availability"
-	flagLabelAdd     = "label-add"
-	flagLabelRemove  = "label-rm"
-)
--- a/api/client/plugin/cmd.go
+++ b/api/client/plugin/cmd.go
@@ -1,12 +0,0 @@
-// +build !experimental
-
-package plugin
-
-import (
-	"github.com/docker/docker/api/client"
-	"github.com/spf13/cobra"
-)
-
-// NewPluginCommand returns a cobra command for `plugin` subcommands
-func NewPluginCommand(cmd *cobra.Command, dockerCli *client.DockerCli) {
-}
--- a/api/client/plugin/cmd_experimental.go
+++ b/api/client/plugin/cmd_experimental.go
@@ -1,36 +0,0 @@
-// +build experimental
-
-package plugin
-
-import (
-	"fmt"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/spf13/cobra"
-)
-
-// NewPluginCommand returns a cobra command for `plugin` subcommands
-func NewPluginCommand(rootCmd *cobra.Command, dockerCli *client.DockerCli) {
-	cmd := &cobra.Command{
-		Use:   "plugin",
-		Short: "Manage Docker plugins",
-		Args:  cli.NoArgs,
-		Run: func(cmd *cobra.Command, args []string) {
-			fmt.Fprintf(dockerCli.Err(), "\n"+cmd.UsageString())
-		},
-	}
-
-	cmd.AddCommand(
-		newDisableCommand(dockerCli),
-		newEnableCommand(dockerCli),
-		newInspectCommand(dockerCli),
-		newInstallCommand(dockerCli),
-		newListCommand(dockerCli),
-		newRemoveCommand(dockerCli),
-		newSetCommand(dockerCli),
-		newPushCommand(dockerCli),
-	)
-
-	rootCmd.AddCommand(cmd)
-}
--- a/api/client/plugin/disable.go
+++ b/api/client/plugin/disable.go
@@ -1,45 +0,0 @@
-// +build experimental
-
-package plugin
-
-import (
-	"fmt"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/reference"
-	"github.com/spf13/cobra"
-	"golang.org/x/net/context"
-)
-
-func newDisableCommand(dockerCli *client.DockerCli) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "disable PLUGIN",
-		Short: "Disable a plugin",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runDisable(dockerCli, args[0])
-		},
-	}
-
-	return cmd
-}
-
-func runDisable(dockerCli *client.DockerCli, name string) error {
-	named, err := reference.ParseNamed(name) // FIXME: validate
-	if err != nil {
-		return err
-	}
-	if reference.IsNameOnly(named) {
-		named = reference.WithDefaultTag(named)
-	}
-	ref, ok := named.(reference.NamedTagged)
-	if !ok {
-		return fmt.Errorf("invalid name: %s", named.String())
-	}
-	if err := dockerCli.Client().PluginDisable(context.Background(), ref.String()); err != nil {
-		return err
-	}
-	fmt.Fprintln(dockerCli.Out(), name)
-	return nil
-}
--- a/api/client/plugin/enable.go
+++ b/api/client/plugin/enable.go
@@ -1,45 +0,0 @@
-// +build experimental
-
-package plugin
-
-import (
-	"fmt"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/reference"
-	"github.com/spf13/cobra"
-	"golang.org/x/net/context"
-)
-
-func newEnableCommand(dockerCli *client.DockerCli) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "enable PLUGIN",
-		Short: "Enable a plugin",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runEnable(dockerCli, args[0])
-		},
-	}
-
-	return cmd
-}
-
-func runEnable(dockerCli *client.DockerCli, name string) error {
-	named, err := reference.ParseNamed(name) // FIXME: validate
-	if err != nil {
-		return err
-	}
-	if reference.IsNameOnly(named) {
-		named = reference.WithDefaultTag(named)
-	}
-	ref, ok := named.(reference.NamedTagged)
-	if !ok {
-		return fmt.Errorf("invalid name: %s", named.String())
-	}
-	if err := dockerCli.Client().PluginEnable(context.Background(), ref.String()); err != nil {
-		return err
-	}
-	fmt.Fprintln(dockerCli.Out(), name)
-	return nil
-}
--- a/api/client/plugin/inspect.go
+++ b/api/client/plugin/inspect.go
@@ -1,52 +0,0 @@
-// +build experimental
-
-package plugin
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/reference"
-	"github.com/spf13/cobra"
-	"golang.org/x/net/context"
-)
-
-func newInspectCommand(dockerCli *client.DockerCli) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "inspect PLUGIN",
-		Short: "Inspect a plugin",
-		Args:  cli.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runInspect(dockerCli, args[0])
-		},
-	}
-
-	return cmd
-}
-
-func runInspect(dockerCli *client.DockerCli, name string) error {
-	named, err := reference.ParseNamed(name) // FIXME: validate
-	if err != nil {
-		return err
-	}
-	if reference.IsNameOnly(named) {
-		named = reference.WithDefaultTag(named)
-	}
-	ref, ok := named.(reference.NamedTagged)
-	if !ok {
-		return fmt.Errorf("invalid name: %s", named.String())
-	}
-	p, err := dockerCli.Client().PluginInspect(context.Background(), ref.String())
-	if err != nil {
-		return err
-	}
-
-	b, err := json.MarshalIndent(p, "", "\t")
-	if err != nil {
-		return err
-	}
-	_, err = dockerCli.Out().Write(b)
-	return err
-}
--- a/api/client/plugin/install.go
+++ b/api/client/plugin/install.go
@@ -1,103 +0,0 @@
-// +build experimental
-
-package plugin
-
-import (
-	"bufio"
-	"fmt"
-	"strings"
-
-	"github.com/docker/docker/api/client"
-	"github.com/docker/docker/cli"
-	"github.com/docker/docker/reference"
-	"github.com/docker/docker/registry"
-	"github.com/docker/engine-api/types"
-	"github.com/spf13/cobra"
-	"golang.org/x/net/context"
-)
-
-type pluginOptions struct {
-	name       string
-	grantPerms bool
-	disable    bool
-}
-
-func newInstallCommand(dockerCli *client.DockerCli) *cobra.Command {
-	var options pluginOptions
-	cmd := &cobra.Command{
-		Use:   "install [OPTIONS] PLUGIN",
-		Short: "Install a plugin",
-		Args:  cli.ExactArgs(1), // TODO: allow for set args
-		RunE: func(cmd *cobra.Command, args []string) error {
-			options.name = args[0]
-			return runInstall(dockerCli, options)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.BoolVar(&options.grantPerms, "grant-all-permissions", false, "grant all permissions necessary to run the plugin")
-	flags.BoolVar(&options.disable, "disable", false, "do not enable the plugin on install")
-
-	return cmd
-}
-
-func runInstall(dockerCli *client.DockerCli, opts pluginOptions) error {
-	named, err := reference.ParseNamed(opts.name) // FIXME: validate
-	if err != nil {
-		return err
-	}
-	if reference.IsNameOnly(named) {
-		named = reference.WithDefaultTag(named)
-	}
-	ref, ok := named.(reference.NamedTagged)
-	if !ok {
-		return fmt.Errorf("invalid name: %s", named.String())
-	}
-
-	ctx := context.Background()
-
-	repoInfo, err := registry.ParseRepositoryInfo(named)
-	if err != nil {
-		return err
-	}
-
-	authConfig := dockerCli.ResolveAuthConfig(ctx, repoInfo.Index)
-
-	encodedAuth, err := client.EncodeAuthToBase64(authConfig)
-	if err != nil {
-		return err
-	}
-
-	registryAuthFunc := dockerCli.RegistryAuthenticationPrivilegedFunc(repoInfo.Index, "plugin install")
-
-	options := types.PluginInstallOptions{
-		RegistryAuth:          encodedAuth,
-		Disabled:              opts.disable,
-		AcceptAllPermissions:  opts.grantPerms,
-		AcceptPermissionsFunc: acceptPrivileges(dockerCli, opts.name),
-		// TODO: Rename PrivilegeFunc, it has nothing to do with privileges
-		PrivilegeFunc: registryAuthFunc,
-	}
-	if err := dockerCli.Client().PluginInstall(ctx, ref.String(), options); err != nil {
-		return err
-	}
-	fmt.Fprintln(dockerCli.Out(), opts.name)
-	return nil
-}
-
-func acceptPrivileges(dockerCli *client.DockerCli, name string) func(privileges types.PluginPrivileges) (bool, error) {
-	return func(privileges types.PluginPrivileges) (bool, error) {
-		fmt.Fprintf(dockerCli.Out(), "Plugin %q is requesting the following privileges:\n", name)
-		for _, privilege := range privileges {
-			fmt.Fprintf(dockerCli.Out(), " - %s: %v\n", privilege.Name, privilege.Value)
-		}
-
-		fmt.Fprint(dockerCli.Out(), "Do you grant the above permissions? [y/N] ")
-		reader := bufio.NewReader(dockerCli.In())
-		line, _, err := reader.ReadLine()
-		if err != nil {
-			return false, err
-		}
-		return strings.ToLower(string(line)) == "y", nil
-	}
-}
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .12.2
 .6.2