Implement the COPY operator within the builder

Make sure the destination directory exists when using docker insert
Add insert command in order to insert external files within an image
2026-01-12 03:01:38 +00:00 · 2013-04-24 14:28:51 -07:00 · 2013-04-24 13:51:28 -07:00 · 2013-04-24 13:37:00 -07:00 · 2013-04-24 13:35:57 -07:00 · 2013-04-24 12:31:20 -07:00
6526 changed files with 26601 additions and 1642728 deletions
--- a/.DEREK.yml
+++ b/.DEREK.yml
@@ -1,22 +0,0 @@
-curators:
-  - aboch
-  - alexellis
-  - andrewhsu
-  - anonymuse
-  - arkodg
-  - chanwit
-  - ehazlett
-  - fntlnz
-  - gianarb
-  - kolyshkin
-  - mgoelzer
-  - olljanat
-  - programmerq
-  - rheinwein
-  - ripcurld0
-  - thajeztah
-
-features:
-  - comments
-  - pr_description_required
-
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,6 +0,0 @@
-.git
-.go-pkg-cache
-.gopath
-bundles
-vendor/pkg
-
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,16 +0,0 @@
-# GitHub code owners
-# See https://help.github.com/articles/about-codeowners/
-#
-# KEEP THIS FILE SORTED. Order is important. Last match takes precedence.
-
-builder/**                              @tonistiigi
-contrib/mkimage/**                      @tianon
-daemon/graphdriver/devmapper/**         @rhvgoyal 
-daemon/graphdriver/lcow/**              @johnstep
-daemon/graphdriver/overlay/**           @dmcgowan
-daemon/graphdriver/overlay2/**          @dmcgowan
-daemon/graphdriver/windows/**           @johnstep
-daemon/logger/awslogs/**                @samuelkarp  
-hack/**                                 @tianon
-plugin/**                               @cpuguy83
-project/**                              @thaJeztah
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,70 +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/moby/moby/blob/master/CONTRIBUTING.md#reporting-other-issues
-
---------------------------------------------------
-GENERAL SUPPORT INFORMATION
---------------------------------------------------
-
-The GitHub issue tracker is for bug reports and feature requests.
-General support for **docker** can be found at the following locations:
-
- Docker Support Forums - https://forums.docker.com
- Slack - community.docker.com #general channel
- Post a question on StackOverflow, using the Docker tag
-
-General support for **moby** can be found at the following locations:
-
- Moby Project Forums - https://forums.mobyproject.org
- Slack - community.docker.com #moby-project channel
- Post a question on StackOverflow, using the Moby tag
-
---------------------------------------------------
-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
-->
-
-**Description**
-
-<!--
-Briefly describe the problem you are having in a few paragraphs.
-->
-
-**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):**
-
-**Output of `docker version`:**
-
-```
-(paste your output here)
-```
-
-**Output of `docker info`:**
-
-```
-(paste your output here)
-```
-
-**Additional environment details (AWS, VirtualBox, physical, etc.):**
--- 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/moby/moby/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,23 +1,17 @@
-# 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
-*.exe
-*.exe~
-*.gz
-*.orig
-test.main
+.vagrant*
+bin
+docker/docker
 .*.swp
+a.out
+*.orig
+build_src
+command-line-arguments.test
+.flymake*
+docker.test
+auth/auth.test
+.idea
 .DS_Store
-# a .bashrc may be added to customize the build environment
-.bashrc
-.editorconfig
+docs/_build
+docs/_static
+docs/_templates
 .gopath/
-.go-pkg-cache/
-autogen/
-bundles/
-cmd/dockerd/dockerd
-contrib/builder/rpm/*/changelog
-vendor/pkg/
-go-test-report.json
-profile.out
-junit-report.xml
--- a/.mailmap
+++ b/.mailmap
@@ -1,581 +1,19 @@
-# Generate AUTHORS: hack/generate-authors.sh
-
-# Tip for finding duplicates (besides scanning the output of AUTHORS for name
-# duplicates that aren't also email duplicates): scan the output of:
-#   git log --format='%aE - %aN' | sort -uf
-#
-# For explanation on this file format: man git-shortlog
-
-<21551195@zju.edu.cn> <hsinko@users.noreply.github.com>
-<mr.wrfly@gmail.com> <wrfly@users.noreply.github.com>
-Aaron L. Xu <liker.xu@foxmail.com>
-Abhinandan Prativadi <abhi@docker.com>
-Adam Dobrawy <naczelnik@jawnosc.tk>
-Adam Dobrawy <naczelnik@jawnosc.tk> <ad-m@users.noreply.github.com>
-Adrien Gallouët <adrien@gallouet.fr> <angt@users.noreply.github.com>
-Ahmed Kamal <email.ahmedkamal@googlemail.com>
-Ahmet Alp Balkan <ahmetb@microsoft.com> <ahmetalpbalkan@gmail.com>
-AJ Bowen <aj@soulshake.net>
-AJ Bowen <aj@soulshake.net> <aj@gandi.net>
-AJ Bowen <aj@soulshake.net> <amy@gandi.net>
-Akihiro Matsushima <amatsusbit@gmail.com> <amatsus@users.noreply.github.com>
-Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp>
-Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp> <suda.akihiro@lab.ntt.co.jp>
-Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp> <suda.kyoto@gmail.com>
-Aleksa Sarai <asarai@suse.de>
-Aleksa Sarai <asarai@suse.de> <asarai@suse.com>
-Aleksa Sarai <asarai@suse.de> <cyphar@cyphar.com>
-Aleksandrs Fadins <aleks@s-ko.net>
-Alessandro Boch <aboch@tetrationanalytics.com> <aboch@docker.com>
-Alex Chen <alexchenunix@gmail.com> <root@localhost.localdomain>
-Alex Ellis <alexellis2@gmail.com>
-Alex Goodman <wagoodman@gmail.com> <wagoodman@users.noreply.github.com>
-Alexander Larsson <alexl@redhat.com> <alexander.larsson@gmail.com>
-Alexander Morozov <lk4d4@docker.com>
-Alexander Morozov <lk4d4@docker.com> <lk4d4math@gmail.com>
-Alexandre Beslic <alexandre.beslic@gmail.com> <abronan@docker.com>
-Alicia Lauerman <alicia@eta.im> <allydevour@me.com>
-Allen Sun <allensun.shl@alibaba-inc.com> <allen.sun@daocloud.io>
-Allen Sun <allensun.shl@alibaba-inc.com> <shlallen1990@gmail.com>
-Andrea Denisse Gómez <crypto.andrea@protonmail.ch>
-Andrew Weiss <andrew.weiss@docker.com> <andrew.weiss@microsoft.com>
-Andrew Weiss <andrew.weiss@docker.com> <andrew.weiss@outlook.com>
-Andrey Kolomentsev <andrey.kolomentsev@docker.com>
-Andrey Kolomentsev <andrey.kolomentsev@docker.com> <andrey.kolomentsev@gmail.com>
-André Martins  <aanm90@gmail.com> <martins@noironetworks.com>
-Andy Rothfusz <github@developersupport.net> <github@metaliveblog.com>
-Andy Smith <github@anarkystic.com>
-Ankush Agarwal <ankushagarwal11@gmail.com> <ankushagarwal@users.noreply.github.com>
-Antonio Murdaca <antonio.murdaca@gmail.com> <amurdaca@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@redhat.com>
-Antonio Murdaca <antonio.murdaca@gmail.com> <runcom@users.noreply.github.com>
-Anuj Bahuguna <anujbahuguna.dev@gmail.com>
-Anuj Bahuguna <anujbahuguna.dev@gmail.com> <abahuguna@fiberlink.com>
-Anusha Ragunathan <anusha.ragunathan@docker.com> <anusha@docker.com>
-Arko Dasgupta <arko.dasgupta@docker.com>
-Arko Dasgupta <arko.dasgupta@docker.com> <arkodg@users.noreply.github.com>
-Arnaud Porterie <arnaud.porterie@docker.com>
-Arnaud Porterie <arnaud.porterie@docker.com> <icecrime@gmail.com>
-Arthur Gautier <baloo@gandi.net> <superbaloo+registrations.github@superbaloo.net>
-Avi Miller <avi.miller@oracle.com> <avi.miller@gmail.com>
-Ben Bonnefoy <frenchben@docker.com>
-Ben Golub <ben.golub@dotcloud.com>
-Ben Toews <mastahyeti@gmail.com> <mastahyeti@users.noreply.github.com>
-Benny Ng <benny.tpng@gmail.com>
-Benoit Chesneau <bchesneau@gmail.com>
-Bevisy Zhang <binbin36520@gmail.com>
-Bhiraj Butala <abhiraj.butala@gmail.com>
-Bhumika Bayani <bhumikabayani@gmail.com>
-Bilal Amarni <bilal.amarni@gmail.com> <bamarni@users.noreply.github.com>
-Bill Wang <ozbillwang@gmail.com> <SydOps@users.noreply.github.com>
-Bily Zhang <xcoder@tenxcloud.com>
-Bin Liu <liubin0329@gmail.com>
-Bin Liu <liubin0329@gmail.com> <liubin0329@users.noreply.github.com>
-Bingshen Wang <bingshen.wbs@alibaba-inc.com>
-Boaz Shuster <ripcurld.github@gmail.com>
-Boqin Qin <bobbqqin@gmail.com>
-Brandon Philips <brandon.philips@coreos.com> <brandon@ifup.co>
-Brandon Philips <brandon.philips@coreos.com> <brandon@ifup.org>
-Brent Salisbury <brent.salisbury@docker.com> <brent@docker.com>
-Brian Goff <cpuguy83@gmail.com>
-Brian Goff <cpuguy83@gmail.com> <bgoff@cpuguy83-mbp.home>
-Brian Goff <cpuguy83@gmail.com> <bgoff@cpuguy83-mbp.local>
-Carlos de Paula <me@carlosedp.com>
-Chander Govindarajan <chandergovind@gmail.com>
-Chao Wang <wangchao.fnst@cn.fujitsu.com> <chaowang@localhost.localdomain>
-Charles Hooper <charles.hooper@dotcloud.com> <chooper@plumata.com>
-Chen Chao <cc272309126@gmail.com>
-Chen Chuanliang <chen.chuanliang@zte.com.cn>
-Chen Mingjie <chenmingjie0828@163.com>
-Chen Qiu <cheney-90@hotmail.com>
-Chen Qiu <cheney-90@hotmail.com> <21321229@zju.edu.cn>
-Chengfei Shang <cfshang@alauda.io>
-Chris Dias <cdias@microsoft.com>
-Chris McKinnel <chris.mckinnel@tangentlabs.co.uk>
-Chris Price <cprice@mirantis.com>
-Chris Price <cprice@mirantis.com> <chris.price@docker.com>
-Christopher Biscardi <biscarch@sketcht.com>
-Christopher Latham <sudosurootdev@gmail.com>
-Christy Norman <christy@linux.vnet.ibm.com>
-Chun Chen <ramichen@tencent.com> <chenchun.feed@gmail.com>
-Corbin Coleman <corbin.coleman@docker.com>
-Cristian Ariza <dev@cristianrz.com>
-Cristian Staretu <cristian.staretu@gmail.com>
-Cristian Staretu <cristian.staretu@gmail.com> <unclejack@users.noreply.github.com>
-Cristian Staretu <cristian.staretu@gmail.com> <unclejacksons@gmail.com>
-CUI Wei <ghostplant@qq.com> cuiwei13 <cuiwei13@pku.edu.cn>
-Daehyeok Mun <daehyeok@gmail.com>
-Daehyeok Mun <daehyeok@gmail.com> <daehyeok@daehyeok-ui-MacBook-Air.local>
-Daehyeok Mun <daehyeok@gmail.com> <daehyeok@daehyeokui-MacBook-Air.local>
-Dan Feldman <danf@jfrog.com>
-Daniel Dao <dqminh@cloudflare.com>
-Daniel Dao <dqminh@cloudflare.com> <dqminh89@gmail.com>
-Daniel Garcia <daniel@danielgarcia.info>
-Daniel Gasienica <daniel@gasienica.ch> <dgasienica@zynga.com>
-Daniel Goosen <daniel.goosen@surveysampling.com> <djgoosen@users.noreply.github.com>
-Daniel Grunwell <mwgrunny@gmail.com>
-Daniel Hiltgen <daniel.hiltgen@docker.com> <dhiltgen@users.noreply.github.com>
-Daniel J Walsh <dwalsh@redhat.com>
-Daniel Mizyrycki <daniel.mizyrycki@dotcloud.com> <daniel@dotcloud.com>
-Daniel Mizyrycki <daniel.mizyrycki@dotcloud.com> <mzdaniel@glidelink.net>
-Daniel Mizyrycki <daniel.mizyrycki@dotcloud.com> <root@vagrant-ubuntu-12.10.vagrantup.com>
-Daniel Nephin <dnephin@docker.com> <dnephin@gmail.com>
-Daniel Norberg <dano@spotify.com> <daniel.norberg@gmail.com>
-Daniel Watkins <daniel@daniel-watkins.co.uk>
-Daniel Zhang <jmzwcn@gmail.com>
-Danny Yates <danny@codeaholics.org> <Danny.Yates@mailonline.co.uk>
-Darren Shepherd <darren.s.shepherd@gmail.com> <darren@rancher.com>
-Dattatraya Kumbhar <dattatraya.kumbhar@gslab.com>
-Dave Goodchild <buddhamagnet@gmail.com>
-Dave Henderson <dhenderson@gmail.com> <Dave.Henderson@ca.ibm.com>
-Dave Tucker <dt@docker.com> <dave@dtucker.co.uk>
-David M. Karr <davidmichaelkarr@gmail.com>
-David Sheets <dsheets@docker.com> <sheets@alum.mit.edu>
-David Sissitka <me@dsissitka.com>
-David Williamson <david.williamson@docker.com> <davidwilliamson@users.noreply.github.com>
-Deshi Xiao <dxiao@redhat.com> <dsxiao@dataman-inc.com>
-Deshi Xiao <dxiao@redhat.com> <xiaods@gmail.com>
-Diego Siqueira <dieg0@live.com>
-Diogo Monica <diogo@docker.com> <diogo.monica@gmail.com>
-Dmitry Sharshakov <d3dx12.xx@gmail.com>
-Dmitry Sharshakov <d3dx12.xx@gmail.com> <sh7dm@outlook.com>
-Dominic Yin <yindongchao@inspur.com>
-Dominik Honnef <dominik@honnef.co> <dominikh@fork-bomb.org>
-Doug Davis <dug@us.ibm.com> <duglin@users.noreply.github.com>
-Doug Tangren <d.tangren@gmail.com>
-Drew Erny <derny@mirantis.com>
-Drew Erny <derny@mirantis.com> <drew.erny@docker.com>
-Elan Ruusamäe <glen@pld-linux.org>
-Elan Ruusamäe <glen@pld-linux.org> <glen@delfi.ee>
-Elango Sivanandam <elango.siva@docker.com>
-Eric G. Noriega <enoriega@vizuri.com> <egnoriega@users.noreply.github.com>
-Eric Hanchrow <ehanchrow@ine.com> <eric.hanchrow@gmail.com>
-Eric Rosenberg <ehaydenr@gmail.com> <ehaydenr@users.noreply.github.com>
-Erica Windisch <erica@windisch.us> <eric@windisch.us>
-Erica Windisch <erica@windisch.us> <ewindisch@docker.com>
-Erik Hollensbe <github@hollensbe.org> <erik+github@hollensbe.org>
-Erwin van der Koogh <info@erronis.nl>
-Ethan Bell <ebgamer29@gmail.com>
-Euan Kemp <euan.kemp@coreos.com> <euank@amazon.com>
-Eugen Krizo <eugen.krizo@gmail.com>
-Evan Hazlett <ejhazlett@gmail.com> <ehazlett@users.noreply.github.com>
-Evelyn Xu <evelynhsu21@gmail.com>
-Evgeny Shmarnev <shmarnev@gmail.com>
-Faiz Khan <faizkhan00@gmail.com>
-Fangming Fang <fangming.fang@arm.com>
-Felix Hupfeld <felix@quobyte.com> <quofelix@users.noreply.github.com>
-Felix Ruess <felix.ruess@gmail.com> <felix.ruess@roboception.de>
-Feng Yan <fy2462@gmail.com>
-Fengtu Wang <wangfengtu@huawei.com> <wangfengtu@huawei.com>
-Francisco Carriedo <fcarriedo@gmail.com>
-Frank Rosquin <frank.rosquin+github@gmail.com> <frank.rosquin@gmail.com>
-Frederick F. Kautz IV <fkautz@redhat.com> <fkautz@alumni.cmu.edu>
-Fu JinLin <withlin@yeah.net>
-Gabriel Nicolas Avellaneda <avellaneda.gabriel@gmail.com>
-Gaetan de Villele <gdevillele@gmail.com>
-Gang Qiao <qiaohai8866@gmail.com> <1373319223@qq.com>
-Geon Kim <geon0250@gmail.com>
-George Kontridze <george@bugsnag.com>
-Gerwim Feiken <g.feiken@tfe.nl> <gerwim@gmail.com>
-Giampaolo Mancini <giampaolo@trampolineup.com>
-Giovan Isa Musthofa <giovanism@outlook.co.id>
-Gopikannan Venugopalsamy <gopikannan.venugopalsamy@gmail.com>
-Gou Rao <gou@portworx.com> <gourao@users.noreply.github.com>
-Grant Millar <rid@cylo.io>
-Grant Millar <rid@cylo.io> <grant@cylo.io>
-Grant Millar <rid@cylo.io> <grant@seednet.eu>
-Greg Stephens <greg@udon.org>
-Guillaume J. Charmes <guillaume.charmes@docker.com> <charmes.guillaume@gmail.com>
-Guillaume J. Charmes <guillaume.charmes@docker.com> <guillaume.charmes@dotcloud.com>
-Guillaume J. Charmes <guillaume.charmes@docker.com> <guillaume@charmes.net>
-Guillaume J. Charmes <guillaume.charmes@docker.com> <guillaume@docker.com>
-Guillaume J. Charmes <guillaume.charmes@docker.com> <guillaume@dotcloud.com>
-Guri <odg0318@gmail.com>
-Gurjeet Singh <gurjeet@singh.im> <singh.gurjeet@gmail.com>
-Gustav Sinder <gustav.sinder@gmail.com>
-Günther Jungbluth <gunther@gameslabs.net>
-Hakan Özler <hakan.ozler@kodcu.com>
-Hao Shu Wei <haosw@cn.ibm.com>
-Hao Shu Wei <haosw@cn.ibm.com> <haoshuwei1989@163.com>
-Harald Albers <github@albersweb.de> <albers@users.noreply.github.com>
-Harald Niesche <harald@niesche.de>
-Harold Cooper <hrldcpr@gmail.com>
-Harry Zhang <harryz@hyper.sh> <harryzhang@zju.edu.cn>
-Harry Zhang <harryz@hyper.sh> <resouer@163.com>
-Harry Zhang <harryz@hyper.sh> <resouer@gmail.com>
-Harry Zhang <resouer@163.com>
-Harshal Patil <harshal.patil@in.ibm.com> <harche@users.noreply.github.com>
-Helen Xie <chenjg@harmonycloud.cn>
-Hiroyuki Sasagawa <hs19870702@gmail.com>
-Hollie Teal <hollie@docker.com>
-Hollie Teal <hollie@docker.com> <hollie.teal@docker.com>
-Hollie Teal <hollie@docker.com> <hollietealok@users.noreply.github.com>
-Hu Keping <hukeping@huawei.com>
-Huu Nguyen <huu@prismskylabs.com> <whoshuu@gmail.com>
-Hyzhou Zhy <hyzhou.zhy@alibaba-inc.com>
-Hyzhou Zhy <hyzhou.zhy@alibaba-inc.com> <1187766782@qq.com>
-Ian Campbell <ian.campbell@docker.com>
-Ian Campbell <ian.campbell@docker.com> <ijc@docker.com>
-Ilya Khlopotov <ilya.khlopotov@gmail.com>
-Iskander Sharipov <quasilyte@gmail.com>
-Ivan Markin <sw@nogoegst.net> <twim@riseup.net>
-Jack Laxson <jackjrabbit@gmail.com>
-Jacob Atzen <jacob@jacobatzen.dk> <jatzen@gmail.com>
-Jacob Tomlinson <jacob@tom.linson.uk> <jacobtomlinson@users.noreply.github.com>
-Jaivish Kothari <janonymous.codevulture@gmail.com>
-James Nesbitt <jnesbitt@mirantis.com>
-James Nesbitt <jnesbitt@mirantis.com> <james.nesbitt@wunderkraut.com>
-Jamie Hannaford <jamie@limetree.org> <jamie.hannaford@rackspace.com>
-Jean Rouge <rougej+github@gmail.com> <jer329@cornell.edu>
-Jean-Baptiste Barth <jeanbaptiste.barth@gmail.com>
-Jean-Baptiste Dalido <jeanbaptiste@appgratis.com>
-Jean-Tiare Le Bigot <jt@yadutaf.fr> <admin@jtlebi.fr>
-Jeff Anderson <jeff@docker.com> <jefferya@programmerq.net>
-Jeff Nickoloff <jeff.nickoloff@gmail.com> <jeff@allingeek.com>
-Jeroen Franse <jeroenfranse@gmail.com>
-Jessica Frazelle <jess@oxide.computer>
-Jessica Frazelle <jess@oxide.computer> <acidburn@docker.com>
-Jessica Frazelle <jess@oxide.computer> <acidburn@google.com>
-Jessica Frazelle <jess@oxide.computer> <acidburn@microsoft.com>
-Jessica Frazelle <jess@oxide.computer> <jess@docker.com>
-Jessica Frazelle <jess@oxide.computer> <jess@mesosphere.com>
-Jessica Frazelle <jess@oxide.computer> <jessfraz@google.com>
-Jessica Frazelle <jess@oxide.computer> <jfrazelle@users.noreply.github.com>
-Jessica Frazelle <jess@oxide.computer> <me@jessfraz.com>
-Jessica Frazelle <jess@oxide.computer> <princess@docker.com>
-Jian Liao <jliao@alauda.io>
-Jiang Jinyang <jjyruby@gmail.com>
-Jiang Jinyang <jjyruby@gmail.com> <jiangjinyang@outlook.com>
-Jim Galasyn <jim.galasyn@docker.com>
-Jiuyue Ma <majiuyue@huawei.com>
-Joey Geiger <jgeiger@gmail.com>
-Joffrey F <joffrey@docker.com>
-Joffrey F <joffrey@docker.com> <f.joffrey@gmail.com>
-Joffrey F <joffrey@docker.com> <joffrey@dotcloud.com>
-Johan Euphrosine <proppy@google.com> <proppy@aminche.com>
-John Harris <john@johnharris.io>
-John Howard <github@lowenna.com>
-John Howard <github@lowenna.com> <jhoward@microsoft.com>
-John Howard <github@lowenna.com> <jhoward@ntdev.microsoft.com>
-John Howard <github@lowenna.com> <jhowardmsft@users.noreply.github.com>
-John Howard <github@lowenna.com> <John.Howard@microsoft.com>
-John Howard <github@lowenna.com> <john.howard@microsoft.com>
-John Stephens <johnstep@docker.com> <johnstep@users.noreply.github.com>
-Jon Surrell <jon.surrell@gmail.com> <jon.surrell@automattic.com>
-Jonathan Choy <jonathan.j.choy@gmail.com>
-Jonathan Choy <jonathan.j.choy@gmail.com> <oni@tetsujinlabs.com>
-Jordan Arentsen <blissdev@gmail.com>
-Jordan Jennings <jjn2009@gmail.com> <jjn2009@users.noreply.github.com>
-Jorit Kleine-Möllhoff <joppich@bricknet.de> <joppich@users.noreply.github.com>
-Jose Diaz-Gonzalez <email@josediazgonzalez.com>
-Jose Diaz-Gonzalez <email@josediazgonzalez.com> <jose@seatgeek.com>
-Jose Diaz-Gonzalez <email@josediazgonzalez.com> <josegonzalez@users.noreply.github.com>
-Josh Bonczkowski <josh.bonczkowski@gmail.com>
-Josh Eveleth <joshe@opendns.com> <jeveleth@users.noreply.github.com>
-Josh Hawn <josh.hawn@docker.com> <jlhawn@berkeley.edu>
-Josh Horwitz <horwitz@addthis.com> <horwitzja@gmail.com>
-Josh Soref <jsoref@gmail.com> <jsoref@users.noreply.github.com>
-Josh Wilson <josh.wilson@fivestars.com> <jcwilson@users.noreply.github.com>
-Joyce Jang <mail@joycejang.com>
-Julien Bordellier <julienbordellier@gmail.com> <git@julienbordellier.com>
-Julien Bordellier <julienbordellier@gmail.com> <me@julienbordellier.com>
-Justin Cormack <justin.cormack@docker.com>
-Justin Cormack <justin.cormack@docker.com> <justin.cormack@unikernel.com>
-Justin Cormack <justin.cormack@docker.com> <justin@specialbusservice.com>
-Justin Simonelis <justin.p.simonelis@gmail.com> <justin.simonelis@PTS-JSIMON2.toronto.exclamation.com>
-Justin Terry <juterry@microsoft.com>
-Jérôme Petazzoni <jerome.petazzoni@docker.com> <jerome.petazzoni@dotcloud.com>
-Jérôme Petazzoni <jerome.petazzoni@docker.com> <jerome.petazzoni@gmail.com>
-Jérôme Petazzoni <jerome.petazzoni@docker.com> <jp@enix.org>
-K. Heller <pestophagous@gmail.com> <pestophagous@users.noreply.github.com>
-Kai Qiang Wu (Kennan) <wkq5325@gmail.com>
-Kai Qiang Wu (Kennan) <wkq5325@gmail.com> <wkqwu@cn.ibm.com>
-Kamil Domański <kamil@domanski.co>
-Kamjar Gerami <kami.gerami@gmail.com>
-Karthik Nayak <karthik.188@gmail.com>
-Karthik Nayak <karthik.188@gmail.com> <Karthik.188@gmail.com>
-Ken Cochrane <kencochrane@gmail.com> <KenCochrane@gmail.com>
-Ken Herner <kherner@progress.com> <chosenken@gmail.com>
-Ken Reese <krrgithub@gmail.com>
-Kenfe-Mickaël Laventure <mickael.laventure@gmail.com>
-Kevin Feyrer <kevin.feyrer@btinternet.com> <kevinfeyrer@users.noreply.github.com>
-Kevin Kern <kaiwentan@harmonycloud.cn>
-Kevin Meredith <kevin.m.meredith@gmail.com>
-Kir Kolyshkin <kolyshkin@gmail.com>
-Kir Kolyshkin <kolyshkin@gmail.com> <kir@openvz.org>
-Kir Kolyshkin <kolyshkin@gmail.com> <kolyshkin@users.noreply.github.com>
-Konrad Kleine <konrad.wilhelm.kleine@gmail.com> <kwk@users.noreply.github.com>
-Konstantin Gribov <grossws@gmail.com>
-Konstantin Pelykh <kpelykh@zettaset.com>
-Kotaro Yoshimatsu <kotaro.yoshimatsu@gmail.com>
-Kunal Kushwaha <kushwaha_kunal_v7@lab.ntt.co.jp> <kunal.kushwaha@gmail.com>
-Lajos Papp <lajos.papp@sequenceiq.com> <lalyos@yahoo.com>
-Lei Gong <lgong@alauda.io>
-Lei Jitang <leijitang@huawei.com>
-Lei Jitang <leijitang@huawei.com> <leijitang@gmail.com>
-Liang Mingqiang <mqliang.zju@gmail.com>
-Liang-Chi Hsieh <viirya@gmail.com>
-Liao Qingwei <liaoqingwei@huawei.com>
-Linus Heckemann <lheckemann@twig-world.com>
-Linus Heckemann <lheckemann@twig-world.com> <anonymouse2048@gmail.com>
-Lokesh Mandvekar <lsm5@fedoraproject.org> <lsm5@redhat.com>
-Lorenzo Fontana <fontanalorenz@gmail.com> <fontanalorenzo@me.com>
-Lorenzo Fontana <fontanalorenz@gmail.com> <lo@linux.com>
-Louis Opter <kalessin@kalessin.fr>
-Louis Opter <kalessin@kalessin.fr> <louis@dotcloud.com>
-Luca Favatella <luca.favatella@erlang-solutions.com> <lucafavatella@users.noreply.github.com>
-Luke Marsden <me@lukemarsden.net> <luke@digital-crocus.com>
-Lyn <energylyn@zju.edu.cn>
-Lynda O'Leary <lyndaoleary29@gmail.com>
-Lynda O'Leary <lyndaoleary29@gmail.com> <lyndaoleary@hotmail.com>
-Ma Müller <mueller-ma@users.noreply.github.com>
-Madhan Raj Mookkandy <MadhanRaj.Mookkandy@microsoft.com> <madhanm@microsoft.com>
-Madhu Venugopal <madhu@socketplane.io> <madhu@docker.com>
-Mageee <fangpuyi@foxmail.com> <21521230.zju.edu.cn>
-Mansi Nahar <mmn4185@rit.edu> <mansi.nahar@macbookpro-mansinahar.local>
-Mansi Nahar <mmn4185@rit.edu> <mansinahar@users.noreply.github.com>
-Marc Abramowitz <marc@marc-abramowitz.com> <msabramo@gmail.com>
-Marcelo Horacio Fortino <info@fortinux.com> <fortinux@users.noreply.github.com>
-Marcus Linke <marcus.linke@gmx.de>
-Marianna Tessel <mtesselh@gmail.com>
-Mark Oates <fl0yd@me.com>
-Markan Patel <mpatel678@gmail.com>
-Markus Kortlang <hyp3rdino@googlemail.com> <markus.kortlang@lhsystems.com>
-Martin Redmond <redmond.martin@gmail.com> <martin@tinychat.com>
-Martin Redmond <redmond.martin@gmail.com> <xgithub@redmond5.com>
-Mary Anthony <mary.anthony@docker.com> <mary@docker.com>
-Mary Anthony <mary.anthony@docker.com> <moxieandmore@gmail.com>
-Mary Anthony <mary.anthony@docker.com> moxiegirl <mary@docker.com>
-Masato Ohba <over.rye@gmail.com>
-Matt Bentley <matt.bentley@docker.com> <mbentley@mbentley.net>
-Matt Schurenko <matt.schurenko@gmail.com>
-Matt Williams <mattyw@me.com>
-Matt Williams <mattyw@me.com> <gh@mattyw.net>
-Matthew Heon <mheon@redhat.com> <mheon@mheonlaptop.redhat.com>
-Matthew Mosesohn <raytrac3r@gmail.com>
-Matthew Mueller <mattmuelle@gmail.com>
-Matthias Kühnle <git.nivoc@neverbox.com> <kuehnle@online.de>
-Mauricio Garavaglia <mauricio@medallia.com> <mauriciogaravaglia@gmail.com>
-Maxwell <csuhp007@gmail.com>
-Maxwell <csuhp007@gmail.com> <csuhqg@foxmail.com>
-Michael Crosby <michael@docker.com> <crosby.michael@gmail.com>
-Michael Crosby <michael@docker.com> <crosbymichael@gmail.com>
-Michael Crosby <michael@docker.com> <michael@crosbymichael.com>
-Michael Hudson-Doyle <michael.hudson@canonical.com> <michael.hudson@linaro.org>
-Michael Huettermann <michael@huettermann.net>
-Michael Käufl <docker@c.michael-kaeufl.de> <michael-k@users.noreply.github.com>
-Michael Nussbaum <michael.nussbaum@getbraintree.com>
-Michael Nussbaum <michael.nussbaum@getbraintree.com> <code@getbraintree.com>
-Michael Spetsiotis <michael_spets@hotmail.com>
-Michal Minář <miminar@redhat.com>
-Michał Gryko <github@odkurzacz.org>
-Michiel de Jong <michiel@unhosted.org>
-Mickaël Fortunato <morsi.morsicus@gmail.com>
-Miguel Angel Alvarez Cabrerizo <doncicuto@gmail.com> <30386061+doncicuto@users.noreply.github.com>
-Miguel Angel Fernández <elmendalerenda@gmail.com>
-Mihai Borobocea <MihaiBorob@gmail.com> <MihaiBorobocea@gmail.com>
-Mike Casas <mkcsas0@gmail.com> <mikecasas@users.noreply.github.com>
-Mike Goelzer <mike.goelzer@docker.com> <mgoelzer@docker.com>
-Milind Chawre <milindchawre@gmail.com>
-Misty Stanley-Jones <misty@docker.com> <misty@apache.org>
-Mohit Soni <mosoni@ebay.com> <mohitsoni1989@gmail.com>
-Moorthy RS <rsmoorthy@gmail.com> <rsmoorthy@users.noreply.github.com>
-Moysés Borges <moysesb@gmail.com>
-Moysés Borges <moysesb@gmail.com> <moyses.furtado@wplex.com.br>
-Nace Oroz <orkica@gmail.com>
-Natasha Jarus <linuxmercedes@gmail.com>
-Nathan LeClaire <nathan.leclaire@docker.com> <nathan.leclaire@gmail.com>
-Nathan LeClaire <nathan.leclaire@docker.com> <nathanleclaire@gmail.com>
-Neil Horman <nhorman@tuxdriver.com> <nhorman@hmswarspite.think-freely.org>
-Nick Russo <nicholasjamesrusso@gmail.com> <nicholasrusso@icloud.com>
-Nicolas Borboën <ponsfrilus@gmail.com> <ponsfrilus@users.noreply.github.com>
-Nigel Poulton <nigelpoulton@hotmail.com>
-Nik Nyby <nikolas@gnu.org> <nnyby@columbia.edu>
-Nolan Darilek <nolan@thewordnerd.info>
-O.S. Tezer <ostezer@gmail.com>
-O.S. Tezer <ostezer@gmail.com> <ostezer@users.noreply.github.com>
-Oh Jinkyun <tintypemolly@gmail.com> <tintypemolly@Ohui-MacBook-Pro.local>
-Oliver Reason <oli@overrateddev.co>
-Olli Janatuinen <olli.janatuinen@gmail.com>
-Olli Janatuinen <olli.janatuinen@gmail.com> <olljanat@users.noreply.github.com>
-Ouyang Liduo <oyld0210@163.com>
-Patrick Stapleton <github@gdi2290.com>
-Paul Liljenberg <liljenberg.paul@gmail.com> <letters@paulnotcom.se>
-Pavel Tikhomirov <ptikhomirov@virtuozzo.com> <ptikhomirov@parallels.com>
-Pawel Konczalski <mail@konczalski.de>
-Peter Choi <phkchoi89@gmail.com> <reikani@Peters-MacBook-Pro.local>
-Peter Dave Hello <hsu@peterdavehello.org> <PeterDaveHello@users.noreply.github.com>
-Peter Jaffe <pjaffe@nevo.com>
-Peter Nagy <xificurC@gmail.com> <pnagy@gratex.com>
-Peter Waller <p@pwaller.net> <peter@scraperwiki.com>
-Phil Estes <estesp@linux.vnet.ibm.com> <estesp@gmail.com>
-Philip Alexander Etling <paetling@gmail.com>
-Philipp Gillé <philipp.gille@gmail.com> <philippgille@users.noreply.github.com>
-Prasanna Gautam <prasannagautam@gmail.com>
-Qiang Huang <h.huangqiang@huawei.com>
-Qiang Huang <h.huangqiang@huawei.com> <qhuang@10.0.2.15>
-Ray Tsang <rayt@google.com> <saturnism@users.noreply.github.com>
-Renaud Gaubert <rgaubert@nvidia.com> <renaud.gaubert@gmail.com>
-Robert Terhaar <rterhaar@atlanticdynamic.com> <robbyt@users.noreply.github.com>
-Roberto G. Hashioka <roberto.hashioka@docker.com> <roberto_hashioka@hotmail.com>
-Roberto Muñoz Fernández <robertomf@gmail.com> <roberto.munoz.fernandez.contractor@bbva.com>
-Robin Thoni <robin@rthoni.com>
-Roman Dudin <katrmr@gmail.com> <decadent@users.noreply.github.com>
-Rong Zhang <rongzhang@alauda.io>
-Rongxiang Song <tinysong1226@gmail.com>
-Ross Boucher <rboucher@gmail.com>
-Rui Cao <ruicao@alauda.io>
-Runshen Zhu <runshen.zhu@gmail.com>
-Ryan Stelly <ryan.stelly@live.com>
-Sakeven Jiang <jc5930@sina.cn>
-Sandeep Bansal <sabansal@microsoft.com>
-Sandeep Bansal <sabansal@microsoft.com> <msabansal@microsoft.com>
-Sargun Dhillon <sargun@netflix.com> <sargun@sargun.me>
-Sean Lee <seanlee@tw.ibm.com> <scaleoutsean@users.noreply.github.com>
-Sebastiaan van Stijn <github@gone.nl> <sebastiaan@ws-key-sebas3.dpi1.dpi>
-Sebastiaan van Stijn <github@gone.nl> <thaJeztah@users.noreply.github.com>
-Shaun Kaasten <shaunk@gmail.com>
-Shawn Landden <shawn@churchofgit.com> <shawnlandden@gmail.com>
-Shengbo Song <thomassong@tencent.com>
-Shengbo Song <thomassong@tencent.com> <mymneo@163.com>
-Shih-Yuan Lee <fourdollars@gmail.com>
-Shishir Mahajan <shishir.mahajan@redhat.com> <smahajan@redhat.com>
-Shu-Wai Chow <shu-wai.chow@seattlechildrens.org>
-Shukui Yang <yangshukui@huawei.com>
-Shuwei Hao <haosw@cn.ibm.com>
-Shuwei Hao <haosw@cn.ibm.com> <haoshuwei24@gmail.com>
-Sidhartha Mani <sidharthamn@gmail.com>
-Sjoerd Langkemper <sjoerd-github@linuxonly.nl> <sjoerd@byte.nl>
-Solomon Hykes <solomon@docker.com> <s@docker.com>
-Solomon Hykes <solomon@docker.com> <solomon.hykes@dotcloud.com>
-Solomon Hykes <solomon@docker.com> <solomon@dotcloud.com>
-Soshi Katsuta <soshi.katsuta@gmail.com>
-Soshi Katsuta <soshi.katsuta@gmail.com> <katsuta_soshi@cyberagent.co.jp>
-Sridhar Ratnakumar <sridharr@activestate.com>
-Sridhar Ratnakumar <sridharr@activestate.com> <github@srid.name>
-Srini Brahmaroutu <srbrahma@us.ibm.com> <sbrahma@us.ibm.com>
-Srinivasan Srivatsan <srinivasan.srivatsan@hpe.com> <srinsriv@users.noreply.github.com>
-Stefan Berger <stefanb@linux.vnet.ibm.com>
-Stefan Berger <stefanb@linux.vnet.ibm.com> <stefanb@us.ibm.com>
-Stefan J. Wernli <swernli@microsoft.com> <swernli@ntdev.microsoft.com>
-Stefan S. <tronicum@user.github.com>
-Stefan Scherer <stefan.scherer@docker.com>
-Stefan Scherer <stefan.scherer@docker.com> <scherer_stefan@icloud.com>
-Stephan Spindler <shutefan@gmail.com> <shutefan@users.noreply.github.com>
-Stephen Day <stevvooe@gmail.com>
-Stephen Day <stevvooe@gmail.com> <stephen.day@docker.com>
-Stephen Day <stevvooe@gmail.com> <stevvooe@users.noreply.github.com>
-Steve Desmond <steve@vtsv.ca> <stevedesmond-ca@users.noreply.github.com>
-Sun Gengze <690388648@qq.com>
-Sun Jianbo <wonderflow.sun@gmail.com>
-Sun Jianbo <wonderflow.sun@gmail.com> <wonderflow@zju.edu.cn>
-Sven Dowideit <SvenDowideit@home.org.au>
-Sven Dowideit <SvenDowideit@home.org.au> <sven@t440s.home.gateway>
-Sven Dowideit <SvenDowideit@home.org.au> <SvenDowideit@docker.com>
-Sven Dowideit <SvenDowideit@home.org.au> <SvenDowideit@fosiki.com>
-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> <¨SvenDowideit@home.org.au¨>
-Sylvain Bellemare <sylvain@ascribe.io>
-Sylvain Bellemare <sylvain@ascribe.io> <sylvain.bellemare@ezeep.com>
-Tangi Colin <tangicolin@gmail.com>
-Tejesh Mehta <tejesh.mehta@gmail.com> <tj@init.me>
-Thatcher Peskens <thatcher@docker.com>
-Thatcher Peskens <thatcher@docker.com> <thatcher@dotcloud.com>
-Thatcher Peskens <thatcher@docker.com> <thatcher@gmx.net>
-Thomas Gazagnaire <thomas@gazagnaire.org> <thomas@gazagnaire.com>
-Thomas Léveil <thomasleveil@gmail.com>
-Thomas Léveil <thomasleveil@gmail.com> <thomasleveil@users.noreply.github.com>
-Tibor Vass <teabee89@gmail.com> <tibor@docker.com>
-Tibor Vass <teabee89@gmail.com> <tiborvass@users.noreply.github.com>
-Tim Bart <tim@fewagainstmany.com>
-Tim Bosse <taim@bosboot.org> <maztaim@users.noreply.github.com>
-Tim Ruffles <oi@truffles.me.uk> <timruffles@googlemail.com>
+# Generate AUTHORS: git log --all --format='%aN <%aE>' | sort -uf | grep -v vagrant-ubuntu-12
+<charles.hooper@dotcloud.com> <chooper@plumata.com> 
+<daniel.mizyrycki@dotcloud.com> <daniel@dotcloud.com>
+<daniel.mizyrycki@dotcloud.com> <mzdaniel@glidelink.net>
+Guillaume J. Charmes <guillaume.charmes@dotcloud.com> creack <charmes.guillaume@gmail.com>
+<guillaume.charmes@dotcloud.com> <guillaume@dotcloud.com>
+<kencochrane@gmail.com> <KenCochrane@gmail.com>
+<sridharr@activestate.com> <github@srid.name>
+Thatcher Peskens <thatcher@dotcloud.com> dhrp <thatcher@dotcloud.com>
+Thatcher Peskens <thatcher@dotcloud.com> dhrp <thatcher@gmx.net>
+Jérôme Petazzoni <jerome.petazzoni@dotcloud.com> jpetazzo <jerome.petazzoni@dotcloud.com>
+Jérôme Petazzoni <jerome.petazzoni@dotcloud.com> <jp@enix.org>
+Joffrey F <joffrey@dotcloud.com>
+<joffrey@dotcloud.com> <f.joffrey@gmail.com>
 Tim Terhorst <mynamewastaken+git@gmail.com>
-Tim Zju <21651152@zju.edu.cn>
-Timothy Hobbs <timothyhobbs@seznam.cz>
-Toli Kuznets <toli@docker.com>
-Tom Barlow <tomwbarlow@gmail.com>
-Tom Sweeney <tsweeney@redhat.com>
-Tõnis Tiigi <tonistiigi@gmail.com>
-Trace Andreason <tandreason@gmail.com>
-Trishna Guha <trishnaguha17@gmail.com>
-Tristan Carel <tristan@cogniteev.com>
-Tristan Carel <tristan@cogniteev.com> <tristan.carel@gmail.com>
-Tyler Brown <tylers.pile@gmail.com>
-Umesh Yadav <umesh4257@gmail.com>
-Umesh Yadav <umesh4257@gmail.com> <dungeonmaster18@users.noreply.github.com>
-Victor Lyuboslavsky <victor@victoreda.com>
-Victor Vieux <victor.vieux@docker.com> <dev@vvieux.com>
-Victor Vieux <victor.vieux@docker.com> <victor.vieux@dotcloud.com>
-Victor Vieux <victor.vieux@docker.com> <victor@docker.com>
-Victor Vieux <victor.vieux@docker.com> <victor@dotcloud.com>
-Victor Vieux <victor.vieux@docker.com> <victorvieux@gmail.com>
-Victor Vieux <victor.vieux@docker.com> <vieux@docker.com>
-Vikram bir Singh <vsingh@mirantis.com>
-Vikram bir Singh <vsingh@mirantis.com> <vikrambir.singh@docker.com>
-Viktor Vojnovski <viktor.vojnovski@amadeus.com> <vojnovski@gmail.com>
-Vincent Batts <vbatts@redhat.com> <vbatts@hashbangbash.com>
-Vincent Bernat <Vincent.Bernat@exoscale.ch> <bernat@luffy.cx>
-Vincent Bernat <Vincent.Bernat@exoscale.ch> <vincent@bernat.im>
-Vincent Boulineau <vincent.boulineau@datadoghq.com>
-Vincent Demeester <vincent.demeester@docker.com> <vincent+github@demeester.fr>
-Vincent Demeester <vincent.demeester@docker.com> <vincent@demeester.fr>
-Vincent Demeester <vincent.demeester@docker.com> <vincent@sbr.pm>
-Vishnu Kannan <vishnuk@google.com>
-Vitaly Ostrosablin <vostrosablin@virtuozzo.com>
-Vitaly Ostrosablin <vostrosablin@virtuozzo.com> <tmp6154@yandex.ru>
-Vladimir Rutsky <altsysrq@gmail.com> <iamironbob@gmail.com>
-Walter Stanish <walter@pratyeka.org>
-Wang Chao <chao.wang@ucloud.cn>
-Wang Chao <chao.wang@ucloud.cn> <wcwxyz@gmail.com>
-Wang Guoliang <liangcszzu@163.com>
-Wang Jie <wangjie5@chinaskycloud.com>
-Wang Ping <present.wp@icloud.com>
-Wang Xing <hzwangxing@corp.netease.com> <root@localhost>
-Wang Yuexiao <wang.yuexiao@zte.com.cn>
-Wayne Chang <wayne@neverfear.org>
-Wayne Song <wsong@docker.com> <wsong@users.noreply.github.com>
-Wei Wu <wuwei4455@gmail.com> cizixs <cizixs@163.com>
-Wenjun Tang <tangwj2@lenovo.com> <dodia@163.com>
-Wewang Xiaorenfine <wang.xiaoren@zte.com.cn>
-Will Weaver <monkey@buildingbananas.com>
-Wing-Kam Wong <wingkwong.code@gmail.com>
-Xian Chaobo <xianchaobo@huawei.com>
-Xian Chaobo <xianchaobo@huawei.com> <jimmyxian2004@yahoo.com.cn>
-Xianglin Gao <xlgao@zju.edu.cn>
-Xianlu Bird <xianlubird@gmail.com>
-Xiao YongBiao <xyb4638@gmail.com>
-Xiaodong Liu <liuxiaodong@loongson.cn>
-Xiaodong Zhang <a4012017@sina.com>
-Xiaoyu Zhang <zhang.xiaoyu33@zte.com.cn>
-Xuecong Liao <satorulogic@gmail.com>
-Yamasaki Masahide <masahide.y@gmail.com>
-Yao Zaiyong <yaozaiyong@hotmail.com>
-Yassine Tijani <yasstij11@gmail.com>
-Yazhong Liu <yorkiefixer@gmail.com>
-Yestin Sun <sunyi0804@gmail.com> <yestin.sun@polyera.com>
-Yi EungJun <eungjun.yi@navercorp.com> <semtlenori@gmail.com>
-Ying Li <ying.li@docker.com>
-Ying Li <ying.li@docker.com> <cyli@twistedmatrix.com>
-Yong Tang <yong.tang.github@outlook.com> <yongtang@users.noreply.github.com>
-Yongxin Li <yxli@alauda.io>
-Yosef Fertel <yfertel@gmail.com> <frosforever@users.noreply.github.com>
-Yu Changchun <yuchangchun1@huawei.com>
-Yu Chengxia <yuchengxia@huawei.com>
-Yu Peng <yu.peng36@zte.com.cn>
-Yu Peng <yu.peng36@zte.com.cn> <yupeng36@zte.com.cn>
-Yue Zhang <zy675793960@yeah.net>
-Zachary Jaffee <zjaffee@us.ibm.com> <zij@case.edu>
-Zachary Jaffee <zjaffee@us.ibm.com> <zjaffee@apache.org>
-ZhangHang <stevezhang2014@gmail.com>
-Zhenkun Bi <bi.zhenkun@zte.com.cn>
-Zhou Hao <zhouhao@cn.fujitsu.com>
-Zhoulin Xie <zhoulin.xie@daocloud.io>
-Zhu Kunjia <zhu.kunjia@zte.com.cn>
-Ziheng Liu <lzhfromustc@gmail.com>
-Zou Yu <zouyu7@huawei.com>
-Zuhayr Elahi <zuhayr.elahi@docker.com>
-Zuhayr Elahi <zuhayr.elahi@docker.com> <elahi.zuhayr@gmail.com>
+Andy Smith <github@anarkystic.com>
+<kalessin@kalessin.fr> <louis@dotcloud.com>
+<victor.vieux@dotcloud.com> <victor@dotcloud.com>
+<dominik@honnef.co> <dominikh@fork-bomb.org>
--- a/2150
+++ b/2150
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,458 +1,93 @@
-# Contribute to the Moby Project
+# Contributing to Docker

-Want to hack on the Moby Project? Awesome! We have a contributor's guide that explains
-[setting up a development environment and the contribution
-process](docs/contributing/). 
+Want to hack on Docker? Awesome! There are instructions to get you
+started on the website: http://docker.io/gettingstarted.html

-[![Contributors guide](docs/static_files/contributors.png)](https://docs.docker.com/opensource/project/who-written-for/)
+They are probably not perfect, please let us know if anything feels
+wrong or incomplete.

-This page contains information about reporting issues as well as some tips and
-guidelines useful to experienced open source contributors. Finally, make sure
-you read our [community guidelines](#moby-community-guidelines) before you
-start participating.
-
-## Topics
-
-* [Reporting Security Issues](#reporting-security-issues)
-* [Design and Cleanup Proposals](#design-and-cleanup-proposals)
-* [Reporting Issues](#reporting-other-issues)
-* [Quick Contribution Tips and Guidelines](#quick-contribution-tips-and-guidelines)
-* [Community Guidelines](#moby-community-guidelines)
-
-## Reporting security issues
-
-The Moby 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 reports are greatly appreciated and we will publicly thank you for it,
-although we keep your name confidential if you request it. We also like to send
-gifts&mdash;if you're into 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.
-
-
-## Reporting other issues
-
-A great way to contribute to the project is to send a detailed report when you
-encounter an issue. We always appreciate a well-written, thorough bug report,
-and will thank you for it!
-
-Check that [our issue database](https://github.com/moby/moby/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.
-
-When reporting issues, always include:
-
-* The output of `docker version`.
-* The output of `docker info`.
-
-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
-
-This section gives the experienced contributor some tips and guidelines.
+## Contribution guidelines

 ### 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
-documented as [a GitHub issue](https://github.com/moby/moby/issues) before
-anybody starts working on it.
+We are always thrilled to receive pull requests, and do our best to
+process them as fast as possible. Not sure if that typo is worth a pull
+request? Do it! We will appreciate it.

-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/).
+If your pull request is not accepted on the first try, don't be
+discouraged! If there's a problem with the implementation, hopefully you
+received feedback on what to improve.

-### Design and cleanup proposals
+We're trying very hard to keep Docker lean and focused. We don't want it
+to do everything for everybody. This means that we might decide against
+incorporating a new feature. However, there might be a way to implement
+that feature *on top of* docker.

-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.
+### Discuss your design on the mailing list

-### Connect with other Moby Project contributors
+We recommend discussing your plans [on the mailing
+list](https://groups.google.com/forum/?fromgroups#!forum/docker-club)
+before starting to code - especially for more ambitious contributions.
+This gives other contributors a chance to point you in the right
+direction, give feedback on your design, and maybe point out if someone
+else is working on the same thing.

-<table class="tg">
-  <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 all the Moby projects. To participate, log in with your Github
-      account or create an account at <a href="https://forums.mobyproject.org" target="_blank">https://forums.mobyproject.org</a>.
-    </td>
-  </tr>
-  <tr>
-    <td>Slack</td>
-    <td>
-      <p>
-        Register for the Docker Community Slack at
-	<a href="https://community.docker.com/registrations/groups/4316" target="_blank">https://community.docker.com/registrations/groups/4316</a>.
-        We use the #moby-project channel for general discussion, and there are separate channels for other Moby projects such as #containerd.
-	Archives are available at <a href="https://dockercommunity.slackarchive.io/" target="_blank">https://dockercommunity.slackarchive.io/</a>.
-      </p>
-    </td>
-  </tr>
-  <tr>
-    <td>Twitter</td>
-    <td>
-      You can follow <a href="https://twitter.com/moby/" target="_blank">Moby Project Twitter feed</a>
-      to get updates on our products. You can also tweet us questions or just
-      share blogs or stories.
-    </td>
-  </tr>
-</table>
+### Create issues...

+Any significant improvement should be documented as [a github
+issue](https://github.com/dotcloud/docker/issues) before anybody
+starts working on it.
+
+### ...but check for existing issues first!
+
+Please take a moment to check that an issue doesn't already exist
+documenting your bug report or improvement proposal. If it does, it
+never hurts to add a quick "+1" or "I have this problem too". This will
+help prioritize the most common problems and requests.

 ### Conventions

-Fork the repository and make changes on your fork in a feature branch:
+Fork the repo and make changes on your fork in a feature branch:

- If it's a bug fix branch, name it XXXX-something where XXXX is the number of
-	the issue. 
- If it's a feature branch, create an enhancement issue to announce
-	your intentions, and name it XXXX-something where XXXX is the number of the
-	issue.
+- If it's a bugfix branch, name it XXX-something where XXX is the number of the
+  issue
+- If it's a feature branch, create an enhancement issue to announce your
+  intentions, and name it XXX-something where XXX is the number of the issue.

-Submit tests for your changes. See [TESTING.md](./TESTING.md) for details.
+Submit unit tests for your changes.  Go has a great test framework built in; use
+it! Take a look at existing tests for inspiration. Run the full test suite on
+your branch before submitting a pull request.

-If your changes need integration tests, write them against the API. The `cli`
-integration tests are slowly either migrated to API tests or moved away as unit
-tests in `docker/cli` and end-to-end tests for Docker.
-
-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).
+Make sure you include relevant updates or additions to documentation when
+creating or modifying features.

 Write clean code. Universally formatted code promotes ease of writing, reading,
-and maintenance. Always run `gofmt -s -w file.go` on each changed file before
-committing your changes. Most editors have plug-ins that do this automatically.
+and maintenance. Always run `go fmt` before committing your changes. Most
+editors have plugins that do this automatically, and there's also a git
+pre-commit hook:

-Pull request descriptions should be as clear as possible and include a reference
-to all the issues that they address.
+```
+curl -o .git/hooks/pre-commit https://raw.github.com/edsrzf/gofmt-git-hook/master/fmt-check && chmod +x .git/hooks/pre-commit
+```

-### Successful Changes
-
-Before contributing large or high impact changes, make the effort to coordinate
-with the maintainers of the project before submitting a pull request. This
-prevents you from doing extra work that may or may not be merged.
-
-Large PRs that are just submitted without any prior communication are unlikely
-to be successful.
-
-While pull requests are the methodology for submitting changes to code, changes
-are much more likely to be accepted if they are accompanied by additional
-engineering work. While we don't define this explicitly, most of these goals
-are accomplished through communication of the design goals and subsequent
-solutions. Often times, it helps to first state the problem before presenting
-solutions.
-
-Typically, the best methods of accomplishing this are to submit an issue,
-stating the problem. This issue can include a problem statement and a
-checklist with requirements. If solutions are proposed, alternatives should be
-listed and eliminated. Even if the criteria for elimination of a solution is
-frivolous, say so.
-
-Larger changes typically work best with design documents. These are focused on
-providing context to the design at the time the feature was conceived and can
-inform future documentation contributions.
-
-### Commit Messages
-
-Commit messages must start with a capitalized and short summary (max. 50 chars)
-written in the imperative, followed by an optional, more detailed explanatory
-text which is separated from the summary by an empty line.
-
-Commit messages should follow best practices, including explaining the context
-of the problem and how it was solved, including in caveats or follow up changes
-required. They should tell the story of the change and provide readers
-understanding of what led to it.
-
-If you're lost about what this even means, please see [How to Write a Git
-Commit Message](http://chris.beams.io/posts/git-commit/) for a start.
-
-In practice, the best approach to maintaining a nice commit message is to
-leverage a `git add -p` and `git commit --amend` to formulate a solid
-changeset. This allows one to piece together a change, as information becomes
-available.
-
-If you squash a series of commits, don't just submit that. Re-write the commit
-message, as if the series of commits was a single stroke of brilliance.
-
-That said, there is no requirement to have a single commit for a PR, as long as
-each commit tells the story. For example, if there is a feature that requires a
-package, it might make sense to have the package in a separate commit then have
-a subsequent commit that uses it.
-
-Remember, you're telling part of the story with the commit message. Don't make
-your chapter weird.
-
-### Review
+Pull requests descriptions should be as clear as possible and include a
+reference to all the issues that they address.

 Code review comments may be added to your pull request. Discuss, then make the
-suggested modifications and push additional commits to your feature branch. Post
-a comment after pushing. New commits show up in the pull request automatically,
-but the reviewers are notified only when you comment.
+suggested modifications and push additional commits to your feature branch. Be
+sure to post a comment after pushing. The new commits will show up in the pull
+request automatically, but the reviewers will not be notified unless you
+comment.

-Pull requests must be cleanly rebased on top of master without multiple branches
-mixed into the PR.
+Before the pull request is merged, make sure that you squash your commits into
+logical units of work using `git rebase -i` and `git push -f`. After every
+commit the test suite should be passing. Include documentation changes in the
+same commit so that a revert would remove all traces of the feature or fix.

-**Git tip**: If your PR no longer merges cleanly, use `rebase master` in your
-feature branch to update your pull request rather than `merge master`.
+Commits that fix or close an issue should include a reference like `Closes #XXX`
+or `Fixes #XXX`, which will automatically close the issue when merged.

-Before you make a pull request, squash your commits into logical units of work
-using `git rebase -i` and `git push -f`. A logical unit of work is a consistent
-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
-down to one.
-
-After every commit, [make sure the test suite passes](./TESTING.md). Include
-documentation changes in the same pull request so that a revert would remove
-all traces of the feature or fix.
-
-Include an issue reference like `Closes #XXXX` or `Fixes #XXXX` in commits that
-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
-
-Moby maintainers use LGTM (Looks Good To Me) in comments on the code review to
-indicate acceptance, or use the Github review approval feature.
-
-For an explanation of the review and approval process see the
-[REVIEWING](project/REVIEWING.md) page.
-
-### Sign your work
-
-The sign-off is a simple line at the end of the explanation for the patch. Your
-signature certifies that you wrote the patch or otherwise have the right to pass
-it on as an open-source patch. The rules are pretty simple: if you can certify
-the below (from [developercertificate.org](http://developercertificate.org/)):
-
-```
-Developer Certificate of Origin
-Version 1.1
-
-Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
-1 Letterman Drive
-Suite D4700
-San Francisco, CA, 94129
-
-Everyone is permitted to copy and distribute verbatim copies of this
-license document, but changing it is not allowed.
-
-Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
-(a) The contribution was created in whole or in part by me and I
-    have the right to submit it under the open source license
-    indicated in the file; or
-
-(b) The contribution is based upon previous work that, to the best
-    of my knowledge, is covered under an appropriate open source
-    license and I have the right under that license to submit that
-    work with modifications, whether created in whole or in part
-    by me, under the same open source license (unless I am
-    permitted to submit under a different license), as indicated
-    in the file; or
-
-(c) The contribution was provided directly to me by some other
-    person who certified (a), (b) or (c) and I have not modified
-    it.
-
-(d) I understand and agree that this project and the contribution
-    are public and that a record of the contribution (including all
-    personal information I submit with it, including my sign-off) is
-    maintained indefinitely and may be redistributed consistent with
-    this project or the open source license(s) involved.
-```
-
-Then you just add a line to every git commit message:
-
-    Signed-off-by: Joe Smith <joe.smith@email.com>
-
-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`.
-
-### How can I become a maintainer?
-
-The procedures for adding new maintainers are explained in the 
-[/project/GOVERNANCE.md](/project/GOVERNANCE.md)
-file in this repository.
-
-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!
-
-### Manage issues and pull requests using the Derek bot
-
-If you want to help label, assign, close or reopen issues or pull requests
-without commit rights, ask a maintainer to add your Github handle to the 
-`.DEREK.yml` file. [Derek](https://github.com/alexellis/derek) is a bot that extends
-Github's user permissions to help non-committers to manage issues and pull requests simply by commenting.
-
-For example:
-
-* Labels
-
-```
-Derek add label: kind/question
-Derek remove label: status/claimed
-```
-
-* Assign work
-
-```
-Derek assign: username
-Derek unassign: me
-```
-
-* Manage issues and PRs
-
-```
-Derek close
-Derek reopen
-```
-
-## Moby community guidelines
-
-We want to keep the Moby community awesome, growing and collaborative. We need
-your help to keep it that way. To help with this we've come up with some general
-guidelines for the community as a whole:
-
-* Be nice: Be courteous, respectful and polite to fellow community members:
-  no regional, racial, gender, or other abuse will be tolerated. We like
-  nice people way better than mean ones!
-
-* Encourage diversity and participation: Make everyone in our community feel
-  welcome, regardless of their background and the extent of their
-  contributions, and do everything possible to encourage participation in
-  our community.
-
-* Keep it legal: Basically, don't get us in trouble. Share only content that
-  you own, do not share private or sensitive information, and don't break
-  the law.
-
-* Stay on topic: Make sure that you are posting to the correct channel and
-  avoid off-topic discussions. Remember when you update an issue or respond
-  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.
-
-The open source governance for this repository is handled via the [Moby Technical Steering Committee (TSC)](https://github.com/moby/tsc)
-charter. For any concerns with the community process regarding technical contributions,
-please contact the TSC. More information on project governance is available in
-our [project/GOVERNANCE.md](/project/GOVERNANCE.md) document.
-
-### Guideline violations — 3 strikes method
-
-The point of this section is not to find opportunities to punish people, but we
-do need a fair way to deal with people who are making our community suck.
-
-1. First occurrence: We'll give you a friendly, but public reminder that the
-   behavior is inappropriate according to our guidelines.
-
-2. Second occurrence: We will send you a private message with a warning that
-   any additional violations will result in removal from the community.
-
-3. Third occurrence: Depending on the violation, we may need to delete or ban
-   your account.
-
-**Notes:**
-
-* Obvious spammers are banned on first occurrence. If we don't do this, we'll
-  have spam all over the place.
-
-* Violations are forgiven after 6 months of good behavior, and we won't hold a
-  grudge.
-
-* People who commit minor infractions will get some education, rather than
-  hammering them in the 3 strikes process.
-
-* The rules apply equally to everyone in the community, no matter how much
-	you've contributed.
-
-* Extreme violations of a threatening, abusive, destructive or illegal nature
-	will be addressed immediately and are not subject to 3 strikes or forgiveness.
-
-* Contact abuse@docker.com to report abuse or appeal violations. In the case of
-	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.
+Add your name to the AUTHORS file, but make sure the list is sorted and your
+name and email address match your git configuration. The AUTHORS file is
+regenerated occasionally from the git commit history, so a mismatch may result
+in your changes being overwritten.
--- a/398
+++ b/398
@@ -1,398 +0,0 @@
-# syntax=docker/dockerfile:1.2
-
-ARG CROSS="false"
-ARG SYSTEMD="false"
-# IMPORTANT: When updating this please note that stdlib archive/tar pkg is vendored
-ARG GO_VERSION=1.16.15
-ARG DEBIAN_FRONTEND=noninteractive
-ARG VPNKIT_VERSION=0.5.0
-ARG DOCKER_BUILDTAGS="apparmor seccomp"
-
-ARG BASE_DEBIAN_DISTRO="buster"
-ARG GOLANG_IMAGE="golang:${GO_VERSION}-${BASE_DEBIAN_DISTRO}"
-
-FROM ${GOLANG_IMAGE} AS base
-RUN echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache
-ARG APT_MIRROR
-RUN sed -ri "s/(httpredir|deb).debian.org/${APT_MIRROR:-deb.debian.org}/g" /etc/apt/sources.list \
- && sed -ri "s/(security).debian.org/${APT_MIRROR:-security.debian.org}/g" /etc/apt/sources.list
-ENV GO111MODULE=off
-
-FROM base AS criu
-ARG DEBIAN_FRONTEND
-# Install dependency packages specific to criu
-RUN --mount=type=cache,sharing=locked,id=moby-criu-aptlib,target=/var/lib/apt \
-    --mount=type=cache,sharing=locked,id=moby-criu-aptcache,target=/var/cache/apt \
-        apt-get update && apt-get install -y --no-install-recommends \
-            libcap-dev \
-            libnet-dev \
-            libnl-3-dev \
-            libprotobuf-c-dev \
-            libprotobuf-dev \
-            protobuf-c-compiler \
-            protobuf-compiler \
-            python-protobuf
-
-# Install CRIU for checkpoint/restore support
-ARG CRIU_VERSION=3.14
-RUN mkdir -p /usr/src/criu \
-    && curl -sSL https://github.com/checkpoint-restore/criu/archive/v${CRIU_VERSION}.tar.gz | tar -C /usr/src/criu/ -xz --strip-components=1 \
-    && cd /usr/src/criu \
-    && make \
-    && make PREFIX=/build/ install-criu
-
-FROM base AS registry
-WORKDIR /go/src/github.com/docker/distribution
-# Install two versions of the registry. The first one is a recent version that
-# supports both schema 1 and 2 manifests. The second one is an older version that
-# only supports schema1 manifests. This allows integration-cli tests to cover
-# push/pull with both schema1 and schema2 manifests.
-# The old version of the registry is not working on arm64, so installation is
-# skipped on that architecture.
-ENV REGISTRY_COMMIT_SCHEMA1 ec87e9b6971d831f0eff752ddb54fb64693e51cd
-ENV REGISTRY_COMMIT 47a064d4195a9b56133891bbb13620c3ac83a827
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=tmpfs,target=/go/src/ \
-        set -x \
-        && git clone https://github.com/docker/distribution.git . \
-        && git checkout -q "$REGISTRY_COMMIT" \
-        && GOPATH="/go/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
-           go build -buildmode=pie -o /build/registry-v2 github.com/docker/distribution/cmd/registry \
-        && case $(dpkg --print-architecture) in \
-               amd64|armhf|ppc64*|s390x) \
-               git checkout -q "$REGISTRY_COMMIT_SCHEMA1"; \
-               GOPATH="/go/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH"; \
-                   go build -buildmode=pie -o /build/registry-v2-schema1 github.com/docker/distribution/cmd/registry; \
-                ;; \
-           esac
-
-FROM base AS swagger
-WORKDIR $GOPATH/src/github.com/go-swagger/go-swagger
-# Install go-swagger for validating swagger.yaml
-# This is https://github.com/kolyshkin/go-swagger/tree/golang-1.13-fix
-# TODO: move to under moby/ or fix upstream go-swagger to work for us.
-ENV GO_SWAGGER_COMMIT c56166c036004ba7a3a321e5951ba472b9ae298c
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=tmpfs,target=/go/src/ \
-        set -x \
-        && git clone https://github.com/kolyshkin/go-swagger.git . \
-        && git checkout -q "$GO_SWAGGER_COMMIT" \
-        && go build -o /build/swagger github.com/go-swagger/go-swagger/cmd/swagger
-
-FROM debian:${BASE_DEBIAN_DISTRO} AS frozen-images
-ARG DEBIAN_FRONTEND
-RUN --mount=type=cache,sharing=locked,id=moby-frozen-images-aptlib,target=/var/lib/apt \
-    --mount=type=cache,sharing=locked,id=moby-frozen-images-aptcache,target=/var/cache/apt \
-       apt-get update && apt-get install -y --no-install-recommends \
-           ca-certificates \
-           curl \
-           jq
-# Get useful and necessary Hub images so we can "docker load" locally instead of pulling
-COPY contrib/download-frozen-image-v2.sh /
-ARG TARGETARCH
-RUN /download-frozen-image-v2.sh /build \
-        buildpack-deps:buster@sha256:d0abb4b1e5c664828b93e8b6ac84d10bce45ee469999bef88304be04a2709491 \
-        busybox:latest@sha256:95cf004f559831017cdf4628aaf1bb30133677be8702a8c5f2994629f637a209 \
-        busybox:glibc@sha256:1f81263701cddf6402afe9f33fca0266d9fff379e59b1748f33d3072da71ee85 \
-        debian:bullseye@sha256:7190e972ab16aefea4d758ebe42a293f4e5c5be63595f4d03a5b9bf6839a4344 \
-        hello-world:latest@sha256:d58e752213a51785838f9eed2b7a498ffa1cb3aa7f946dda11af39286c3db9a9 \
-        arm32v7/hello-world:latest@sha256:50b8560ad574c779908da71f7ce370c0a2471c098d44d1c8f6b513c5a55eeeb1
-# See also frozenImages in "testutil/environment/protect.go" (which needs to be updated when adding images to this list)
-
-FROM base AS cross-false
-
-FROM --platform=linux/amd64 base AS cross-true
-ARG DEBIAN_FRONTEND
-RUN dpkg --add-architecture arm64
-RUN dpkg --add-architecture armel
-RUN dpkg --add-architecture armhf
-RUN --mount=type=cache,sharing=locked,id=moby-cross-true-aptlib,target=/var/lib/apt \
-    --mount=type=cache,sharing=locked,id=moby-cross-true-aptcache,target=/var/cache/apt \
-        apt-get update && apt-get install -y --no-install-recommends \
-            crossbuild-essential-arm64 \
-            crossbuild-essential-armel \
-            crossbuild-essential-armhf
-
-FROM cross-${CROSS} as dev-base
-
-FROM dev-base AS runtime-dev-cross-false
-ARG DEBIAN_FRONTEND
-RUN echo 'deb http://deb.debian.org/debian buster-backports main' > /etc/apt/sources.list.d/backports.list
-RUN --mount=type=cache,sharing=locked,id=moby-cross-false-aptlib,target=/var/lib/apt \
-    --mount=type=cache,sharing=locked,id=moby-cross-false-aptcache,target=/var/cache/apt \
-        apt-get update && apt-get install -y --no-install-recommends \
-            binutils-mingw-w64 \
-            g++-mingw-w64-x86-64 \
-            libapparmor-dev \
-            libbtrfs-dev \
-            libdevmapper-dev \
-            libseccomp-dev/buster-backports \
-            libsystemd-dev \
-            libudev-dev
-
-FROM --platform=linux/amd64 runtime-dev-cross-false AS runtime-dev-cross-true
-ARG DEBIAN_FRONTEND
-# These crossbuild packages rely on gcc-<arch>, but this doesn't want to install
-# on non-amd64 systems.
-# Additionally, the crossbuild-amd64 is currently only on debian:buster, so
-# other architectures cannnot crossbuild amd64.
-RUN echo 'deb http://deb.debian.org/debian buster-backports main' > /etc/apt/sources.list.d/backports.list
-RUN --mount=type=cache,sharing=locked,id=moby-cross-true-aptlib,target=/var/lib/apt \
-    --mount=type=cache,sharing=locked,id=moby-cross-true-aptcache,target=/var/cache/apt \
-        apt-get update && apt-get install -y --no-install-recommends \
-            libapparmor-dev:arm64 \
-            libapparmor-dev:armel \
-            libapparmor-dev:armhf \
-            libseccomp-dev:arm64/buster-backports \
-            libseccomp-dev:armel/buster-backports \
-            libseccomp-dev:armhf/buster-backports
-
-FROM runtime-dev-cross-${CROSS} AS runtime-dev
-
-FROM base AS tomlv
-ARG TOMLV_COMMIT
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh tomlv
-
-FROM base AS vndr
-ARG VNDR_VERSION
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh vndr
-
-FROM dev-base AS containerd
-ARG DEBIAN_FRONTEND
-RUN --mount=type=cache,sharing=locked,id=moby-containerd-aptlib,target=/var/lib/apt \
-    --mount=type=cache,sharing=locked,id=moby-containerd-aptcache,target=/var/cache/apt \
-        apt-get update && apt-get install -y --no-install-recommends \
-            libbtrfs-dev
-ARG CONTAINERD_VERSION
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh containerd
-
-FROM dev-base AS proxy
-ARG LIBNETWORK_COMMIT
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh proxy
-
-FROM base AS golangci_lint
-ARG GOLANGCI_LINT_VERSION
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh golangci_lint
-
-FROM base AS gotestsum
-ARG GOTESTSUM_VERSION
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh gotestsum
-
-FROM base AS shfmt
-ARG SHFMT_VERSION
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh shfmt
-
-FROM dev-base AS dockercli
-ARG DOCKERCLI_CHANNEL
-ARG DOCKERCLI_VERSION
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh dockercli
-
-FROM runtime-dev AS runc
-ARG RUNC_VERSION
-ARG RUNC_BUILDTAGS
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh runc
-
-FROM dev-base AS tini
-ARG DEBIAN_FRONTEND
-ARG TINI_VERSION
-RUN --mount=type=cache,sharing=locked,id=moby-tini-aptlib,target=/var/lib/apt \
-    --mount=type=cache,sharing=locked,id=moby-tini-aptcache,target=/var/cache/apt \
-        apt-get update && apt-get install -y --no-install-recommends \
-            cmake \
-            vim-common
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh tini
-
-FROM dev-base AS rootlesskit
-ARG ROOTLESSKIT_VERSION
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=bind,src=hack/dockerfile/install,target=/tmp/install \
-        PREFIX=/build /tmp/install/install.sh rootlesskit
-COPY ./contrib/dockerd-rootless.sh /build
-COPY ./contrib/dockerd-rootless-setuptool.sh /build
-
-FROM --platform=amd64 djs55/vpnkit:${VPNKIT_VERSION} AS vpnkit-amd64
-
-FROM --platform=arm64 djs55/vpnkit:${VPNKIT_VERSION} AS vpnkit-arm64
-
-FROM scratch AS vpnkit
-COPY --from=vpnkit-amd64 /vpnkit /build/vpnkit.x86_64
-COPY --from=vpnkit-arm64 /vpnkit /build/vpnkit.aarch64
-
-# TODO: Some of this is only really needed for testing, it would be nice to split this up
-FROM runtime-dev AS dev-systemd-false
-ARG DEBIAN_FRONTEND
-RUN groupadd -r docker
-RUN useradd --create-home --gid docker unprivilegeduser \
- && mkdir -p /home/unprivilegeduser/.local/share/docker \
- && chown -R unprivilegeduser /home/unprivilegeduser
-# Let us use a .bashrc file
-RUN ln -sfv /go/src/github.com/docker/docker/.bashrc ~/.bashrc
-# Activate bash completion and include Docker's completion if mounted with DOCKER_BASH_COMPLETION_PATH
-RUN echo "source /usr/share/bash-completion/bash_completion" >> /etc/bash.bashrc
-RUN ln -s /usr/local/completion/bash/docker /etc/bash_completion.d/docker
-RUN ldconfig
-# This should only install packages that are specifically needed for the dev environment and nothing else
-# Do you really need to add another package here? Can it be done in a different build stage?
-RUN --mount=type=cache,sharing=locked,id=moby-dev-aptlib,target=/var/lib/apt \
-    --mount=type=cache,sharing=locked,id=moby-dev-aptcache,target=/var/cache/apt \
-        apt-get update && apt-get install -y --no-install-recommends \
-            apparmor \
-            aufs-tools \
-            bash-completion \
-            bzip2 \
-            iptables \
-            jq \
-            libcap2-bin \
-            libnet1 \
-            libnl-3-200 \
-            libprotobuf-c1 \
-            net-tools \
-            patch \
-            pigz \
-            python3-pip \
-            python3-setuptools \
-            python3-wheel \
-            sudo \
-            thin-provisioning-tools \
-            uidmap \
-            vim \
-            vim-common \
-            xfsprogs \
-            xz-utils \
-            zip
-
-
-# Switch to use iptables instead of nftables (to match the CI hosts)
-# TODO use some kind of runtime auto-detection instead if/when nftables is supported (https://github.com/moby/moby/issues/26824)
-RUN update-alternatives --set iptables  /usr/sbin/iptables-legacy  || true \
- && update-alternatives --set ip6tables /usr/sbin/ip6tables-legacy || true \
- && update-alternatives --set arptables /usr/sbin/arptables-legacy || true
-
-RUN pip3 install yamllint==1.26.1
-
-COPY --from=dockercli     /build/ /usr/local/cli
-COPY --from=frozen-images /build/ /docker-frozen-images
-COPY --from=swagger       /build/ /usr/local/bin/
-COPY --from=tomlv         /build/ /usr/local/bin/
-COPY --from=tini          /build/ /usr/local/bin/
-COPY --from=registry      /build/ /usr/local/bin/
-COPY --from=criu          /build/ /usr/local/
-COPY --from=vndr          /build/ /usr/local/bin/
-COPY --from=gotestsum     /build/ /usr/local/bin/
-COPY --from=golangci_lint /build/ /usr/local/bin/
-COPY --from=shfmt         /build/ /usr/local/bin/
-COPY --from=runc          /build/ /usr/local/bin/
-COPY --from=containerd    /build/ /usr/local/bin/
-COPY --from=rootlesskit   /build/ /usr/local/bin/
-COPY --from=vpnkit        /build/ /usr/local/bin/
-COPY --from=proxy         /build/ /usr/local/bin/
-ENV PATH=/usr/local/cli:$PATH
-ARG DOCKER_BUILDTAGS
-ENV DOCKER_BUILDTAGS="${DOCKER_BUILDTAGS}"
-WORKDIR /go/src/github.com/docker/docker
-VOLUME /var/lib/docker
-VOLUME /home/unprivilegeduser/.local/share/docker
-# Wrap all commands in the "docker-in-docker" script to allow nested containers
-ENTRYPOINT ["hack/dind"]
-
-FROM dev-systemd-false AS dev-systemd-true
-RUN --mount=type=cache,sharing=locked,id=moby-dev-aptlib,target=/var/lib/apt \
-    --mount=type=cache,sharing=locked,id=moby-dev-aptcache,target=/var/cache/apt \
-        apt-get update && apt-get install -y --no-install-recommends \
-            dbus \
-            dbus-user-session \
-            systemd \
-            systemd-sysv
-RUN mkdir -p hack \
-  && curl -o hack/dind-systemd https://raw.githubusercontent.com/AkihiroSuda/containerized-systemd/b70bac0daeea120456764248164c21684ade7d0d/docker-entrypoint.sh \
-  && chmod +x hack/dind-systemd
-ENTRYPOINT ["hack/dind-systemd"]
-
-FROM dev-systemd-${SYSTEMD} AS dev
-
-FROM runtime-dev AS binary-base
-ARG DOCKER_GITCOMMIT=HEAD
-ENV DOCKER_GITCOMMIT=${DOCKER_GITCOMMIT}
-ARG VERSION
-ENV VERSION=${VERSION}
-ARG PLATFORM
-ENV PLATFORM=${PLATFORM}
-ARG PRODUCT
-ENV PRODUCT=${PRODUCT}
-ARG DEFAULT_PRODUCT_LICENSE
-ENV DEFAULT_PRODUCT_LICENSE=${DEFAULT_PRODUCT_LICENSE}
-ARG DOCKER_BUILDTAGS
-ENV DOCKER_BUILDTAGS="${DOCKER_BUILDTAGS}"
-ENV PREFIX=/build
-# TODO: This is here because hack/make.sh binary copies these extras binaries
-# from $PATH into the bundles dir.
-# It would be nice to handle this in a different way.
-COPY --from=tini        /build/ /usr/local/bin/
-COPY --from=runc        /build/ /usr/local/bin/
-COPY --from=containerd  /build/ /usr/local/bin/
-COPY --from=rootlesskit /build/ /usr/local/bin/
-COPY --from=proxy       /build/ /usr/local/bin/
-COPY --from=vpnkit      /build/ /usr/local/bin/
-WORKDIR /go/src/github.com/docker/docker
-
-FROM binary-base AS build-binary
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=bind,target=/go/src/github.com/docker/docker \
-        hack/make.sh binary
-
-FROM binary-base AS build-dynbinary
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=bind,target=/go/src/github.com/docker/docker \
-        hack/make.sh dynbinary
-
-FROM binary-base AS build-cross
-ARG DOCKER_CROSSPLATFORMS
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=bind,target=/go/src/github.com/docker/docker \
-    --mount=type=tmpfs,target=/go/src/github.com/docker/docker/autogen \
-        hack/make.sh cross
-
-FROM scratch AS binary
-COPY --from=build-binary /build/bundles/ /
-
-FROM scratch AS dynbinary
-COPY --from=build-dynbinary /build/bundles/ /
-
-FROM scratch AS cross
-COPY --from=build-cross /build/bundles/ /
-
-FROM dev AS final
-COPY . /go/src/github.com/docker/docker
--- a/Dockerfile.buildx
+++ b/Dockerfile.buildx
@@ -1,26 +0,0 @@
-ARG GO_VERSION=1.13.15
-ARG BUILDX_COMMIT=v0.5.1
-ARG BUILDX_REPO=https://github.com/docker/buildx.git
-
-FROM golang:${GO_VERSION}-buster AS build
-ARG BUILDX_REPO
-RUN git clone "${BUILDX_REPO}" /buildx
-WORKDIR /buildx
-ARG BUILDX_COMMIT
-RUN git fetch origin "${BUILDX_COMMIT}":build && git checkout build
-ARG GOOS
-ARG GOARCH
-# Keep these essentially no-op var settings for debug purposes.
-# It allows us to see what the GOOS/GOARCH that's being built for is.
-RUN GOOS="${GOOS}" GOARCH="${GOARCH}" BUILDX_COMMIT="${BUILDX_COMMIT}"; \
-    pkg="github.com/docker/buildx"; \
-    ldflags="\
-      -X \"${pkg}/version.Version=$(git describe --tags)\" \
-      -X \"${pkg}/version.Revision=$(git rev-parse --short HEAD)\" \
-      -X \"${pkg}/version.Package=buildx\" \
-    "; \
-    go build -mod=vendor -ldflags "${ldflags}" -o /usr/bin/buildx ./cmd/buildx
-
-FROM golang:${GO_VERSION}-buster
-COPY --from=build /usr/bin/buildx /usr/bin/buildx
-ENTRYPOINT ["/usr/bin/buildx"]
--- a/Dockerfile.e2e
+++ b/Dockerfile.e2e
@@ -1,84 +0,0 @@
-ARG GO_VERSION=1.16.15
-
-FROM golang:${GO_VERSION}-alpine AS base
-ENV GO111MODULE=off
-RUN apk --no-cache add \
-    bash \
-    btrfs-progs-dev \
-    build-base \
-    curl \
-    lvm2-dev \
-    jq
-
-RUN mkdir -p /build/
-RUN mkdir -p /go/src/github.com/docker/docker/
-WORKDIR /go/src/github.com/docker/docker/
-
-FROM base AS frozen-images
-# Get useful and necessary Hub images so we can "docker load" locally instead of pulling
-COPY contrib/download-frozen-image-v2.sh /
-RUN /download-frozen-image-v2.sh /build \
-	buildpack-deps:buster@sha256:d0abb4b1e5c664828b93e8b6ac84d10bce45ee469999bef88304be04a2709491 \
-	busybox:latest@sha256:95cf004f559831017cdf4628aaf1bb30133677be8702a8c5f2994629f637a209 \
-	busybox:glibc@sha256:1f81263701cddf6402afe9f33fca0266d9fff379e59b1748f33d3072da71ee85 \
-	debian:bullseye@sha256:7190e972ab16aefea4d758ebe42a293f4e5c5be63595f4d03a5b9bf6839a4344 \
-	hello-world:latest@sha256:d58e752213a51785838f9eed2b7a498ffa1cb3aa7f946dda11af39286c3db9a9
-# See also frozenImages in "testutil/environment/protect.go" (which needs to be updated when adding images to this list)
-
-FROM base AS dockercli
-ENV INSTALL_BINARY_NAME=dockercli
-COPY hack/dockerfile/install/install.sh ./install.sh
-COPY hack/dockerfile/install/$INSTALL_BINARY_NAME.installer ./
-RUN PREFIX=/build ./install.sh $INSTALL_BINARY_NAME
-
-# Build DockerSuite.TestBuild* dependency
-FROM base AS contrib
-COPY contrib/syscall-test           /build/syscall-test
-COPY contrib/httpserver/Dockerfile  /build/httpserver/Dockerfile
-COPY contrib/httpserver             contrib/httpserver
-RUN CGO_ENABLED=0 go build -buildmode=pie -o /build/httpserver/httpserver github.com/docker/docker/contrib/httpserver
-
-# Build the integration tests and copy the resulting binaries to /build/tests
-FROM base AS builder
-
-# Set tag and add sources
-COPY . .
-# Copy test sources tests that use assert can print errors
-RUN mkdir -p /build${PWD} && find integration integration-cli -name \*_test.go -exec cp --parents '{}' /build${PWD} \;
-# Build and install test binaries
-ARG DOCKER_GITCOMMIT=undefined
-RUN hack/make.sh build-integration-test-binary
-RUN mkdir -p /build/tests && find . -name test.main -exec cp --parents '{}' /build/tests \;
-
-## Generate testing image
-FROM alpine:3.10 as runner
-
-ENV DOCKER_REMOTE_DAEMON=1
-ENV DOCKER_INTEGRATION_DAEMON_DEST=/
-ENTRYPOINT ["/scripts/run.sh"]
-
-# Add an unprivileged user to be used for tests which need it
-RUN addgroup docker && adduser -D -G docker unprivilegeduser -s /bin/ash
-
-# GNU tar is used for generating the emptyfs image
-RUN apk --no-cache add \
-    bash \
-    ca-certificates \
-    g++ \
-    git \
-    iptables \
-    pigz \
-    tar \
-    xz
-
-COPY hack/test/e2e-run.sh       /scripts/run.sh
-COPY hack/make/.ensure-emptyfs  /scripts/ensure-emptyfs.sh
-
-COPY integration/testdata       /tests/integration/testdata
-COPY integration/build/testdata /tests/integration/build/testdata
-COPY integration-cli/fixtures   /tests/integration-cli/fixtures
-
-COPY --from=frozen-images /build/ /docker-frozen-images
-COPY --from=dockercli     /build/ /usr/bin/
-COPY --from=contrib       /build/ /tests/contrib/
-COPY --from=builder       /build/ /
--- a/Dockerfile.simple
+++ b/Dockerfile.simple
@@ -1,53 +0,0 @@
-# docker build -t docker:simple -f Dockerfile.simple .
-# docker run --rm docker:simple hack/make.sh dynbinary
-# docker run --rm --privileged docker:simple hack/dind hack/make.sh test-unit
-# docker run --rm --privileged -v /var/lib/docker docker:simple hack/dind hack/make.sh dynbinary test-integration
-
-# This represents the bare minimum required to build and test Docker.
-
-ARG GO_VERSION=1.16.15
-
-FROM golang:${GO_VERSION}-buster
-ENV GO111MODULE=off
-
-# allow replacing httpredir or deb mirror
-ARG APT_MIRROR=deb.debian.org
-RUN sed -ri "s/(httpredir|deb).debian.org/$APT_MIRROR/g" /etc/apt/sources.list
-
-# Compile and runtime deps
-# https://github.com/docker/docker/blob/master/project/PACKAGERS.md#build-dependencies
-# https://github.com/docker/docker/blob/master/project/PACKAGERS.md#runtime-dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-		build-essential \
-		curl \
-		cmake \
-		gcc \
-		git \
-		libapparmor-dev \
-		libbtrfs-dev \
-		libdevmapper-dev \
-		libseccomp-dev \
-		ca-certificates \
-		e2fsprogs \
-		iptables \
-		pkg-config \
-		pigz \
-		procps \
-		xfsprogs \
-		xz-utils \
-		\
-		aufs-tools \
-		vim-common \
-	&& rm -rf /var/lib/apt/lists/*
-
-# Install runc, containerd, tini and docker-proxy
-# Please edit hack/dockerfile/install/<name>.installer to update them.
-COPY hack/dockerfile/install hack/dockerfile/install
-RUN for i in runc containerd tini proxy dockercli; \
-		do hack/dockerfile/install/install.sh $i; \
-	done
-ENV PATH=/usr/local/cli:$PATH
-
-ENV AUTO_GOPATH 1
-WORKDIR /usr/src/docker
-COPY . /usr/src/docker
--- a/Dockerfile.windows
+++ b/Dockerfile.windows
@@ -1,286 +0,0 @@
-# escape=`
-
-# -----------------------------------------------------------------------------------------
-# This file describes the standard way to build Docker in a container on Windows
-# Server 2016 or Windows 10.
-#
-# Maintainer: @jhowardmsft
-# -----------------------------------------------------------------------------------------
-
-
-# Prerequisites:
-# --------------
-#
-# 1. Windows Server 2016 or Windows 10 with all Windows updates applied. The major 
-#    build number must be at least 14393. This can be confirmed, for example, by 
-#    running the following from an elevated PowerShell prompt - this sample output 
-#    is from a fully up to date machine as at mid-November 2016:
-#
-#    >> PS C:\> $(gin).WindowsBuildLabEx
-#    >> 14393.447.amd64fre.rs1_release_inmarket.161102-0100
-#
-# 2. Git for Windows (or another git client) must be installed. https://git-scm.com/download/win.
-#
-# 3. The machine must be configured to run containers. For example, by following
-#    the quick start guidance at https://msdn.microsoft.com/en-us/virtualization/windowscontainers/quick_start/quick_start or
-#    https://github.com/docker/labs/blob/master/windows/windows-containers/Setup.md
-#
-# 4. If building in a Hyper-V VM: For Windows Server 2016 using Windows Server
-#    containers as the default option, it is recommended you have at least 1GB 
-#    of memory assigned; For Windows 10 where Hyper-V Containers are employed, you
-#    should have at least 4GB of memory assigned. Note also, to run Hyper-V 
-#    containers in a VM, it is necessary to configure the VM for nested virtualization.
-
-# -----------------------------------------------------------------------------------------
-
-
-# Usage:
-# -----
-#
-#  The following steps should be run from an (elevated*) Windows PowerShell prompt. 
-#
-#  (*In a default installation of containers on Windows following the quick-start guidance at
-#    https://msdn.microsoft.com/en-us/virtualization/windowscontainers/quick_start/quick_start,
-#    the docker.exe client must run elevated to be able to connect to the daemon).
-#
-# 1. Clone the sources from github.com:
-#
-#    >>   git clone https://github.com/docker/docker.git C:\gopath\src\github.com\docker\docker
-#    >>   Cloning into 'C:\gopath\src\github.com\docker\docker'...
-#    >>   remote: Counting objects: 186216, done.
-#    >>   remote: Compressing objects: 100% (21/21), done.
-#    >>   remote: Total 186216 (delta 5), reused 0 (delta 0), pack-reused 186195
-#    >>   Receiving objects: 100% (186216/186216), 104.32 MiB | 8.18 MiB/s, done.
-#    >>   Resolving deltas: 100% (123139/123139), done.
-#    >>   Checking connectivity... done.
-#    >>   Checking out files: 100% (3912/3912), done.
-#    >>   PS C:\>
-#
-#
-# 2. Change directory to the cloned docker sources:
-#
-#    >>   cd C:\gopath\src\github.com\docker\docker 
-#
-#
-# 3. Build a docker image with the components required to build the docker binaries from source
-#    by running one of the following:
-#
-#    >>   docker build -t nativebuildimage -f Dockerfile.windows .          
-#    >>   docker build -t nativebuildimage -f Dockerfile.windows -m 2GB .    (if using Hyper-V containers)
-#
-#
-# 4. Build the docker executable binaries by running one of the following:
-#
-#    >>   $DOCKER_GITCOMMIT=(git rev-parse --short HEAD)
-#    >>   docker run --name binaries -e DOCKER_GITCOMMIT=$DOCKER_GITCOMMIT nativebuildimage hack\make.ps1 -Binary
-#    >>   docker run --name binaries -e DOCKER_GITCOMMIT=$DOCKER_GITCOMMIT -m 2GB nativebuildimage hack\make.ps1 -Binary    (if using Hyper-V containers)
-#
-#
-# 5. Copy the binaries out of the container, replacing HostPath with an appropriate destination 
-#    folder on the host system where you want the binaries to be located.
-#
-#    >>   docker cp binaries:C:\gopath\src\github.com\docker\docker\bundles\docker.exe C:\HostPath\docker.exe
-#    >>   docker cp binaries:C:\gopath\src\github.com\docker\docker\bundles\dockerd.exe C:\HostPath\dockerd.exe
-#
-#
-# 6. (Optional) Remove the interim container holding the built executable binaries:
-#
-#    >>    docker rm binaries
-#
-#
-# 7. (Optional) Remove the image used for the container in which the executable
-#    binaries are build. Tip - it may be useful to keep this image around if you need to
-#    build multiple times. Then you can take advantage of the builder cache to have an
-#    image which has all the components required to build the binaries already installed.
-#
-#    >>    docker rmi nativebuildimage
-#
-
-# -----------------------------------------------------------------------------------------
-
-
-#  The validation tests can only run directly on the host. This is because they calculate
-#  information from the git repo, but the .git directory is not passed into the image as
-#  it is excluded via .dockerignore. Run the following from a Windows PowerShell prompt
-#  (elevation is not required): (Note Go must be installed to run these tests)
-#
-#    >>   hack\make.ps1 -DCO -PkgImports -GoFormat
-
-
-# -----------------------------------------------------------------------------------------
-
-
-#  To run unit tests, ensure you have created the nativebuildimage above. Then run one of
-#  the following from an (elevated) Windows PowerShell prompt:
-#
-#    >>   docker run --rm nativebuildimage hack\make.ps1 -TestUnit
-#    >>   docker run --rm -m 2GB nativebuildimage hack\make.ps1 -TestUnit    (if using Hyper-V containers)
-
-
-# -----------------------------------------------------------------------------------------
-
-
-#  To run unit tests and binary build, ensure you have created the nativebuildimage above. Then 
-#  run one of the following from an (elevated) Windows PowerShell prompt:
-#
-#    >>   docker run nativebuildimage hack\make.ps1 -All
-#    >>   docker run -m 2GB nativebuildimage hack\make.ps1 -All    (if using Hyper-V containers)
-
-# -----------------------------------------------------------------------------------------
-
-
-# Important notes:
-# ---------------
-#
-# Don't attempt to use a bind mount to pass a local directory as the bundles target
-# directory. It does not work (golang attempts for follow a mapped folder incorrectly).
-# Instead, use docker cp as per the example.
-#
-# go.zip is not removed from the image as it is used by the Windows CI servers
-# to ensure the host and image are running consistent versions of go.
-#
-# Nanoserver support is a work in progress. Although the image will build if the 
-# FROM statement is updated, it will not work when running autogen through hack\make.ps1. 
-# It is suspected that the required GCC utilities (eg gcc, windres, windmc) silently
-# quit due to the use of console hooks which are not available.
-#
-# The docker integration tests do not currently run in a container on Windows, predominantly
-# due to Windows not supporting privileged mode, so anything using a volume would fail.
-# They (along with the rest of the docker CI suite) can be run using 
-# https://github.com/kevpar/docker-w2wCIScripts/blob/master/runCI/Invoke-DockerCI.ps1.
-#
-# -----------------------------------------------------------------------------------------
-
-
-# The number of build steps below are explicitly minimised to improve performance.
-
-# Extremely important - do not change the following line to reference a "specific" image, 
-# such as `mcr.microsoft.com/windows/servercore:ltsc2019`. If using this Dockerfile in process
-# isolated containers, the kernel of the host must match the container image, and hence
-# would fail between Windows Server 2016 (aka RS1) and Windows Server 2019 (aka RS5).
-# It is expected that the image `microsoft/windowsservercore:latest` is present, and matches
-# the hosts kernel version before doing a build. 
-FROM microsoft/windowsservercore
-
-# Use PowerShell as the default shell
-SHELL ["powershell", "-Command", "$ErrorActionPreference = 'Stop'; $ProgressPreference = 'SilentlyContinue';"]
-
-ARG GO_VERSION=1.16.15
-ARG GOTESTSUM_VERSION=v1.7.0
-
-# Environment variable notes:
-#  - GO_VERSION must be consistent with 'Dockerfile' used by Linux.
-#  - FROM_DOCKERFILE is used for detection of building within a container.
-ENV GO_VERSION=${GO_VERSION} `
-    GIT_VERSION=2.11.1 `
-    GOPATH=C:\gopath `
-    GO111MODULE=off `
-    FROM_DOCKERFILE=1 `
-    GOTESTSUM_VERSION=${GOTESTSUM_VERSION}
-
-RUN `
-  Function Test-Nano() { `
-    $EditionId = (Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion' -Name 'EditionID').EditionId; `
-    return (($EditionId -eq 'ServerStandardNano') -or ($EditionId -eq 'ServerDataCenterNano') -or ($EditionId -eq 'NanoServer')); `
-  }`
-  `
-  Function Download-File([string] $source, [string] $target) { `
-    if (Test-Nano) { `
-      $handler = New-Object System.Net.Http.HttpClientHandler; `
-      $client = New-Object System.Net.Http.HttpClient($handler); `
-      $client.Timeout = New-Object System.TimeSpan(0, 30, 0); `
-      $cancelTokenSource = [System.Threading.CancellationTokenSource]::new(); `
-      $responseMsg = $client.GetAsync([System.Uri]::new($source), $cancelTokenSource.Token); `
-      $responseMsg.Wait(); `
-      if (!$responseMsg.IsCanceled) { `
-        $response = $responseMsg.Result; `
-        if ($response.IsSuccessStatusCode) { `
-          $downloadedFileStream = [System.IO.FileStream]::new($target, [System.IO.FileMode]::Create, [System.IO.FileAccess]::Write); `
-          $copyStreamOp = $response.Content.CopyToAsync($downloadedFileStream); `
-          $copyStreamOp.Wait(); `
-          $downloadedFileStream.Close(); `
-          if ($copyStreamOp.Exception -ne $null) { throw $copyStreamOp.Exception } `
-        } `
-      } else { `
-      Throw ("Failed to download " + $source) `
-      }`
-    } else { `
-      [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; `
-      $webClient = New-Object System.Net.WebClient; `
-      $webClient.DownloadFile($source, $target); `
-    } `
-  } `
-  `
-  setx /M PATH $('C:\git\cmd;C:\git\usr\bin;'+$Env:PATH+';C:\gcc\bin;C:\go\bin'); `
-  `
-  Write-Host INFO: Downloading git...; `
-  $location='https://www.nuget.org/api/v2/package/GitForWindows/'+$Env:GIT_VERSION; `
-  Download-File $location C:\gitsetup.zip; `
-  `
-  Write-Host INFO: Downloading go...; `
-  $dlGoVersion=$Env:GO_VERSION -replace '\.0$',''; `
-  Download-File "https://golang.org/dl/go${dlGoVersion}.windows-amd64.zip" C:\go.zip; `
-  `
-  Write-Host INFO: Downloading compiler 1 of 3...; `
-  Download-File https://raw.githubusercontent.com/moby/docker-tdmgcc/master/gcc.zip C:\gcc.zip; `
-  `
-  Write-Host INFO: Downloading compiler 2 of 3...; `
-  Download-File https://raw.githubusercontent.com/moby/docker-tdmgcc/master/runtime.zip C:\runtime.zip; `
-  `
-  Write-Host INFO: Downloading compiler 3 of 3...; `
-  Download-File https://raw.githubusercontent.com/moby/docker-tdmgcc/master/binutils.zip C:\binutils.zip; `
-  `
-  Write-Host INFO: Extracting git...; `
-  Expand-Archive C:\gitsetup.zip C:\git-tmp; `
-  New-Item -Type Directory C:\git | Out-Null; `
-  Move-Item C:\git-tmp\tools\* C:\git\.; `
-  Remove-Item -Recurse -Force C:\git-tmp; `
-  `
-  Write-Host INFO: Expanding go...; `
-  Expand-Archive C:\go.zip -DestinationPath C:\; `
-  `
-  Write-Host INFO: Expanding compiler 1 of 3...; `
-  Expand-Archive C:\gcc.zip -DestinationPath C:\gcc -Force; `
-  Write-Host INFO: Expanding compiler 2 of 3...; `
-  Expand-Archive C:\runtime.zip -DestinationPath C:\gcc -Force; `
-  Write-Host INFO: Expanding compiler 3 of 3...; `
-  Expand-Archive C:\binutils.zip -DestinationPath C:\gcc -Force; `
-  `
-  Write-Host INFO: Removing downloaded files...; `
-  Remove-Item C:\gcc.zip; `
-  Remove-Item C:\runtime.zip; `
-  Remove-Item C:\binutils.zip; `
-  Remove-Item C:\gitsetup.zip; `
-  `
-  # Ensure all directories exist that we will require below....
-  $srcDir = """$Env:GOPATH`\src\github.com\docker\docker\bundles"""; `
-  Write-Host INFO: Ensuring existence of directory $srcDir...; `
-  New-Item -Force -ItemType Directory -Path $srcDir | Out-Null; `
-  `
-  Write-Host INFO: Configuring git core.autocrlf...; `
-  C:\git\cmd\git config --global core.autocrlf true;
-
-RUN `
-  Function Install-GoTestSum() { `
-    $Env:GO111MODULE = 'on'; `
-    $tmpGobin = "${Env:GOBIN_TMP}"; `
-    $Env:GOBIN = """${Env:GOPATH}`\bin"""; `
-    Write-Host "INFO: Installing gotestsum version $Env:GOTESTSUM_VERSION in $Env:GOBIN"; `
-    &go install "gotest.tools/gotestsum@${Env:GOTESTSUM_VERSION}"; `
-    $Env:GOBIN = "${tmpGobin}"; `
-    $Env:GO111MODULE = 'off'; `
-    if ($LASTEXITCODE -ne 0) {  `
-      Throw '"gotestsum install failed..."'; `
-    } `
-  } `
-  `
-  Install-GoTestSum
-
-# Make PowerShell the default entrypoint
-ENTRYPOINT ["powershell.exe"]
-
-# Set the working directory to the location of the sources
-WORKDIR ${GOPATH}\src\github.com\docker\docker
-
-# Copy the sources into the container
-COPY . .
--- a/1115
+++ b/1115
--- a/17
+++ b/17
@@ -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,24 @@

   END OF TERMS AND CONDITIONS

-   Copyright 2013-2018 Docker, Inc.
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]

   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/494
+++ b/494
@@ -1,494 +0,0 @@
-# Moby maintainers file
-#
-# This file describes the maintainer groups within the moby/moby project.
-# More detail on Moby project governance is available in the
-# project/GOVERNANCE.md file found in this repository.
-#
-# It is structured to be consumable by both humans and programs.
-# To extract its contents programmatically, use any TOML-compliant
-# parser.
-#
-# TODO(estesp): This file should not necessarily depend on docker/opensource
-# This file is compiled into the MAINTAINERS file in docker/opensource.
-#
-[Org]
-
-	[Org."Core maintainers"]
-
-	# The Core maintainers are the ghostbusters of the project: when there's a problem others
-	# can't solve, they show up and fix it with bizarre devices and weaponry.
-	# They have final say on technical implementation and coding style.
-	# They are ultimately responsible for quality in all its forms: usability polish,
-	# bugfixes, performance, stability, etc. When ownership  can cleanly be passed to
-	# a subsystem, they are responsible for doing so and holding the
-	# subsystem maintainers accountable. If ownership is unclear, they are the de facto owners.
-
-		people = [
-			"akihirosuda",
-			"anusha",
-			"coolljt0725",
-			"cpuguy83",
-			"crosbymichael",
-			"estesp",
-			"johnstep",
-			"justincormack",
-			"kolyshkin",
-			"lowenna",
-			"mhbauer",
-			"runcom",
-			"stevvooe",
-			"thajeztah",
-			"tianon",
-			"tibor",
-			"tonistiigi",
-			"unclejack",
-			"vdemeester",
-			"vieux",
-			"yongtang"
-		]
-
-	[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 = [
-			"alexellis",
-			"andrewhsu",
-			"fntlnz",
-			"gianarb",
-			"olljanat",
-			"programmerq",
-			"ripcurld",
-			"samwhited",
-			"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 = [
-			# Aaron Lehmann was a maintainer for swarmkit, the registry, and the engine,
-			# and contributed many improvements, features, and bugfixes in those areas,
-			# among which "automated service rollbacks", templated secrets and configs,
-			# and resumable image layer downloads.
-			"aaronlehmann",
-
-			# Harald Albers is the mastermind behind the bash completion scripts for the
-			# Docker CLI. The completion scripts moved to the Docker CLI repository, so
-			# you can now find him perform his magic in the https://github.com/docker/cli repository.
-			"albers",
-
-			# Andrea Luzzardi started contributing to the Docker codebase in the "dotCloud"
-			# era, even before it was called "Docker". He is one of the architects of both
-			# Swarm and SwarmKit, and its integration into the Docker engine.
-			"aluzzardi",
-			
-			# David Calavera contributed many features to Docker, such as an improved
-			# event system, dynamic configuration reloading, volume plugins, fancy
-			# new templating options, and an external client credential store. As a
-			# maintainer, David was release captain for Docker 1.8, and competing
-			# with Jess Frazelle to be "top dream killer".
-			# David is now doing amazing stuff as CTO for https://www.netlify.com,
-			# and tweets as @calavera.
-			"calavera",
-
-			# Before becoming a maintainer, Daniel Nephin was a core contributor
-			# to "Fig" (now known as Docker Compose). As a maintainer for both the
-			# Engine and Docker CLI, Daniel contributed many features, among which
-			# the `docker stack` commands, allowing users to deploy their Docker
-			# Compose projects as a Swarm service.
-			"dnephin",
-
-			# Doug Davis contributed many features and fixes for the classic builder,
-			# such as "wildcard" copy, the dockerignore file, custom paths/names
-			# for the Dockerfile, as well as enhancements to the API and documentation.
-			# Follow Doug on Twitter, where he tweets as @duginabox.
-			"duglin",
-
-			# 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",
-
-			# Evan Hazlett is the creator of the Shipyard and Interlock open source projects,
-			# and the author of "Orca", which became the foundation of Docker Universal Control
-			# Plane (UCP). As a maintainer, Evan helped integrating SwarmKit (secrets, tasks)
-			# into the Docker engine.
-			"ehazlett",
-
-			# Arnaud Porterie (AKA "icecrime") was in charge of maintaining the maintainers.
-			# As a maintainer, he made life easier for contributors to the Docker open-source
-			# projects, bringing order in the chaos by designing a triage- and review workflow
-			# using labels (see https://icecrime.net/technology/a-structured-approach-to-labeling/),
-			# and automating the hell out of things with his buddies GordonTheTurtle and Poule
-			# (a chicken!).
-			# 
-			# A lesser-known fact is that he created the first commit in the libnetwork repository
-			# even though he didn't know anything about it. Some say, he's now selling stuff on
-			# the internet ;-)
-			"icecrime",
-
-			# After a false start with his first PR being rejected, James Turnbull became a frequent
-			# contributor to the documentation, and became a docs maintainer on December 5, 2013. As
-			# a maintainer, James lifted the docs to a higher standard, and introduced the community
-			# guidelines ("three strikes"). James is currently changing the world as CTO of https://www.empatico.org,
-			# meanwhile authoring various books that are worth checking out. You can find him on Twitter,
-			# rambling as @kartar, and although no longer active as a maintainer, he's always "game" to
-			# help out reviewing docs PRs, so you may still see him around in the repository.
-			"jamtur01",
-
-			# 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!").
-			# 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/jessfraz (a must-try).
-			"jessfraz",
-
-			# Alexander Morozov contributed many features to Docker, worked on the premise of 
-			# what later became containerd (and worked on that too), and made a "stupid" Go
-			# vendor tool specifically for docker/docker needs: vndr (https://github.com/LK4D4/vndr).
-			# Not many know that Alexander is a master negotiator, being able to change course
-			# of action with a single "Nope, we're not gonna do that".
-			"lk4d4",
-
-			# Madhu Venugopal was part of the SocketPlane team that joined Docker.
-			# As a maintainer, he was working with Jana for the Container Network
-			# Model (CNM) implemented through libnetwork, and the "routing mesh" powering
-			# Swarm mode networking.
-			"mavenugo",
-
-			# As a maintainer, Kenfe-Mickaël Laventure worked on the container runtime,
-			# integrating containerd 1.0 with the daemon, and adding support for custom
-			# OCI runtimes, as well as implementing the `docker prune` subcommands,
-			# which was a welcome feature to be added. You can keep up with Mickaél on
-			# Twitter (@kmlaventure).
-			"mlaventure",
-
-			# As a docs maintainer, Mary Anthony contributed greatly to the Docker
-			# docs. She wrote the Docker Contributor Guide and Getting Started
-			# Guides. She helped create a doc build system independent of
-			# docker/docker project, and implemented a new docs.docker.com theme and
-			# nav for 2015 Dockercon. Fun fact: the most inherited layer in DockerHub
-			# public repositories was originally referenced in
-			# maryatdocker/docker-whale back in May 2015.
-			"moxiegirl",
-
-			# Jana Radhakrishnan was part of the SocketPlane team that joined Docker.
-			# As a maintainer, he was the lead architect for the Container Network
-			# Model (CNM) implemented through libnetwork, and the "routing mesh" powering
-			# Swarm mode networking.
-			#
-			# Jana started new adventures in networking, but you can find him tweeting as @mrjana,
-			# coding on GitHub https://github.com/mrjana, and he may be hiding on the Docker Community
-			# slack channel :-)
-			"mrjana",
-
-			# Sven Dowideit became a well known person in the Docker ecosphere, building
-			# boot2docker, and became a regular contributor to the project, starting as
-			# early as October 2013 (https://github.com/docker/docker/pull/2119), to become
-			# a maintainer less than two months later (https://github.com/docker/docker/pull/3061).
-			#
-			# As a maintainer, Sven took on the task to convert the documentation from
-			# ReStructuredText to Markdown, migrate to Hugo for generating the docs, and
-			# writing tooling for building, testing, and publishing them.
-			#
-			# If you're not in the occasion to visit "the Australian office", you
-			# can keep up with Sven on Twitter (@SvenDowideit), his blog http://fosiki.com,
-			# and of course on GitHub.
-			"sven",
-
-			# 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.
-			"vbatts",
-
-			# 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"
-		]
-
-[people]
-
-# A reference list of all people associated with the project.
-# All other sections should refer to people by their canonical key
-# in the people section.
-
-	# ADD YOURSELF HERE IN ALPHABETICAL ORDER
-
-	[people.aaronlehmann]
-	Name = "Aaron Lehmann"
-	Email = "aaron.lehmann@docker.com"
-	GitHub = "aaronlehmann"
-
-	[people.alexellis]
-	Name = "Alex Ellis"
-	Email = "alexellis2@gmail.com"
-	GitHub = "alexellis"
-
-	[people.akihirosuda]
-	Name = "Akihiro Suda"
-	Email = "akihiro.suda.cz@hco.ntt.co.jp"
-	GitHub = "AkihiroSuda"
-
-	[people.aluzzardi]
-	Name = "Andrea Luzzardi"
-	Email = "al@docker.com"
-	GitHub = "aluzzardi"
-
-	[people.albers]
-	Name = "Harald Albers"
-	Email = "github@albersweb.de"
-	GitHub = "albers"
-
-	[people.andrewhsu]
-	Name = "Andrew Hsu"
-	Email = "andrewhsu@docker.com"
-	GitHub = "andrewhsu"
-
-	[people.anusha]
-	Name = "Anusha Ragunathan"
-	Email = "anusha@docker.com"
-	GitHub = "anusha-ragunathan"
-
-	[people.calavera]
-	Name = "David Calavera"
-	Email = "david.calavera@gmail.com"
-	GitHub = "calavera"
-
-	[people.coolljt0725]
-	Name = "Lei Jitang"
-	Email = "leijitang@huawei.com"
-	GitHub = "coolljt0725"
-
-	[people.cpuguy83]
-	Name = "Brian Goff"
-	Email = "cpuguy83@gmail.com"
-	GitHub = "cpuguy83"
-
-	[people.crosbymichael]
-	Name = "Michael Crosby"
-	Email = "crosbymichael@gmail.com"
-	GitHub = "crosbymichael"
-
-	[people.dnephin]
-	Name = "Daniel Nephin"
-	Email = "dnephin@gmail.com"
-	GitHub = "dnephin"
-
-	[people.duglin]
-	Name = "Doug Davis"
-	Email = "dug@us.ibm.com"
-	GitHub = "duglin"
-
-	[people.ehazlett]
-	Name = "Evan Hazlett"
-	Email = "ejhazlett@gmail.com"
-	GitHub = "ehazlett"
-
-	[people.erikh]
-	Name = "Erik Hollensbe"
-	Email = "erik@docker.com"
-	GitHub = "erikh"
-
-	[people.estesp]
-	Name = "Phil Estes"
-	Email = "estesp@linux.vnet.ibm.com"
-	GitHub = "estesp"
-
-	[people.fntlnz]
-	Name = "Lorenzo Fontana"
-	Email = "fontanalorenz@gmail.com"
-	GitHub = "fntlnz"
-
-	[people.gianarb]
-	Name = "Gianluca Arbezzano"
-	Email = "ga@thumpflow.com"
-	GitHub = "gianarb"
-
-	[people.icecrime]
-	Name = "Arnaud Porterie"
-	Email = "icecrime@gmail.com"
-	GitHub = "icecrime"
-
-	[people.jamtur01]
-	Name = "James Turnbull"
-	Email = "james@lovedthanlost.net"
-	GitHub = "jamtur01"
-
-	[people.jessfraz]
-	Name = "Jessie Frazelle"
-	Email = "jess@linux.com"
-	GitHub = "jessfraz"
-
-	[people.johnstep]
-	Name = "John Stephens"
-	Email = "johnstep@docker.com"
-	GitHub = "johnstep"
-
-	[people.justincormack]
-	Name = "Justin Cormack"
-	Email = "justin.cormack@docker.com"
-	GitHub = "justincormack"
-
-	[people.kolyshkin]
-	Name = "Kir Kolyshkin"
-	Email = "kolyshkin@gmail.com"
-	GitHub = "kolyshkin"
-
-	[people.lk4d4]
-	Name = "Alexander Morozov"
-	Email = "lk4d4@docker.com"
-	GitHub = "lk4d4"
-
-	[people.lowenna]
-	Name = "John Howard"
-	Email = "github@lowenna.com"
-	GitHub = "lowenna"
-
-	[people.mavenugo]
-	Name = "Madhu Venugopal"
-	Email = "madhu@docker.com"
-	GitHub = "mavenugo"
-
-	[people.mhbauer]
-	Name = "Morgan Bauer"
-	Email = "mbauer@us.ibm.com"
-	GitHub = "mhbauer"
-
-	[people.mlaventure]
-	Name = "Kenfe-Mickaël Laventure"
-	Email = "mickael.laventure@gmail.com"
-	GitHub = "mlaventure"
-
-	[people.moxiegirl]
-	Name = "Mary Anthony"
-	Email = "mary.anthony@docker.com"
-	GitHub = "moxiegirl"
-
-	[people.mrjana]
-	Name = "Jana Radhakrishnan"
-	Email = "mrjana@docker.com"
-	GitHub = "mrjana"
-
-	[people.olljanat]
-	Name = "Olli Janatuinen"
-	Email = "olli.janatuinen@gmail.com"
-	GitHub = "olljanat"
-
-	[people.programmerq]
-	Name = "Jeff Anderson"
-	Email = "jeff@docker.com"
-	GitHub = "programmerq"
-
-	[people.ripcurld]
-	Name = "Boaz Shuster"
-	Email = "ripcurld.github@gmail.com"
-	GitHub = "ripcurld"
-
-	[people.runcom]
-	Name = "Antonio Murdaca"
-	Email = "runcom@redhat.com"
-	GitHub = "runcom"
-
-	[people.samwhited]
-	Name = "Sam Whited"
-	Email = "sam@samwhited.com"
-	GitHub = "samwhited"
-
-	[people.shykes]
-	Name = "Solomon Hykes"
-	Email = "solomon@docker.com"
-	GitHub = "shykes"
-
-	[people.stevvooe]
-	Name = "Stephen Day"
-	Email = "stephen.day@docker.com"
-	GitHub = "stevvooe"
-
-	[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"
-	GitHub = "tianon"
-
-	[people.tibor]
-	Name = "Tibor Vass"
-	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.vishh]
-	Name = "Vishnu Kannan"
-	Email = "vishnuk@google.com"
-	GitHub = "vishh"
-
-	[people.yongtang]
-	Name = "Yong Tang"
-	Email = "yong.tang.github@outlook.com"
-	GitHub = "yongtang"
--- a/358
+++ b/358
@@ -1,294 +1,78 @@
-.PHONY: all binary dynbinary build cross help install manpages run shell test test-docker-py test-integration test-unit validate win
+DOCKER_PACKAGE := github.com/dotcloud/docker
+RELEASE_VERSION := $(shell git tag | grep -E "v[0-9\.]+$$" | sort -nr | head -n 1)
+SRCRELEASE := docker-$(RELEASE_VERSION)
+BINRELEASE := docker-$(RELEASE_VERSION).tgz

-ifdef USE_BUILDX
-BUILDX ?= $(shell command -v buildx)
-BUILDX ?= $(shell command -v docker-buildx)
-DOCKER_BUILDX_CLI_PLUGIN_PATH ?= ~/.docker/cli-plugins/docker-buildx
-BUILDX ?= $(shell if [ -x "$(DOCKER_BUILDX_CLI_PLUGIN_PATH)" ]; then echo $(DOCKER_BUILDX_CLI_PLUGIN_PATH); fi)
+GIT_ROOT := $(shell git rev-parse --show-toplevel)
+BUILD_DIR := $(CURDIR)/.gopath
+
+GOPATH ?= $(BUILD_DIR)
+export GOPATH
+
+GO_OPTIONS ?=
+ifeq ($(VERBOSE), 1)
+GO_OPTIONS += -v
 endif

-ifndef USE_BUILDX
-DOCKER_BUILDKIT := 1
-export DOCKER_BUILDKIT
+GIT_COMMIT = $(shell git rev-parse --short HEAD)
+GIT_STATUS = $(shell test -n "`git status --porcelain`" && echo "+CHANGES")
+
+BUILD_OPTIONS = -ldflags "-X main.GIT_COMMIT $(GIT_COMMIT)$(GIT_STATUS)"
+
+SRC_DIR := $(GOPATH)/src
+
+DOCKER_DIR := $(SRC_DIR)/$(DOCKER_PACKAGE)
+DOCKER_MAIN := $(DOCKER_DIR)/docker
+
+DOCKER_BIN_RELATIVE := bin/docker
+DOCKER_BIN := $(CURDIR)/$(DOCKER_BIN_RELATIVE)
+
+.PHONY: all clean test hack release srcrelease $(BINRELEASE) $(SRCRELEASE) $(DOCKER_BIN) $(DOCKER_DIR)
+
+all: $(DOCKER_BIN)
+
+$(DOCKER_BIN): $(DOCKER_DIR)
+	@mkdir -p  $(dir $@)
+	@(cd $(DOCKER_MAIN); go build $(GO_OPTIONS) $(BUILD_OPTIONS) -o $@)
+	@echo $(DOCKER_BIN_RELATIVE) is created.
+
+$(DOCKER_DIR):
+	@mkdir -p $(dir $@)
+	@rm -f $@
+	@ln -sf $(CURDIR)/ $@
+	@(cd $(DOCKER_MAIN); go get $(GO_OPTIONS))
+
+whichrelease:
+	echo $(RELEASE_VERSION)
+
+release: $(BINRELEASE)
+srcrelease: $(SRCRELEASE)
+deps: $(DOCKER_DIR)
+
+# A clean checkout of $RELEASE_VERSION, with vendored dependencies
+$(SRCRELEASE):
+	rm -fr $(SRCRELEASE)
+	git clone $(GIT_ROOT) $(SRCRELEASE)
+	cd $(SRCRELEASE); git checkout -q $(RELEASE_VERSION)
+
+# A binary release ready to be uploaded to a mirror
+$(BINRELEASE): $(SRCRELEASE)
+	rm -f $(BINRELEASE)
+	cd $(SRCRELEASE); make; cp -R bin docker-$(RELEASE_VERSION); tar -f ../$(BINRELEASE) -zv -c docker-$(RELEASE_VERSION)
+
+clean:
+	@rm -rf $(dir $(DOCKER_BIN))
+ifeq ($(GOPATH), $(BUILD_DIR))
+	@rm -rf $(BUILD_DIR)
+else ifneq ($(DOCKER_DIR), $(realpath $(DOCKER_DIR)))
+	@rm -f $(DOCKER_DIR)
 endif

-BUILDX ?= bundles/buildx
-DOCKER ?= docker
+test: all
+	@(cd $(DOCKER_DIR); sudo -E go test $(GO_OPTIONS))

-# 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/.*: //'))
-export DOCKER_GRAPHDRIVER
+fmt:
+	@gofmt -s -l -w .

-# get OS/Arch of docker engine
-DOCKER_OSARCH := $(shell bash -c 'source hack/make/.detect-daemon-osarch && echo $${DOCKER_ENGINE_OSARCH}')
-DOCKERFILE := $(shell bash -c 'source hack/make/.detect-daemon-osarch && echo $${DOCKERFILE}')
-
-DOCKER_GITCOMMIT := $(shell git rev-parse --short HEAD || echo unsupported)
-export DOCKER_GITCOMMIT
-
-# allow overriding the repository and branch that validation scripts are running
-# against these are used in hack/validate/.validate to check what changed in the PR.
-export VALIDATE_REPO
-export VALIDATE_BRANCH
-export VALIDATE_ORIGIN_BRANCH
-
-# env vars passed through directly to Docker's build scripts
-# to allow things like `make KEEPBUNDLE=1 binary` easily
-# `project/PACKAGERS.md` have some limited documentation of some of these
-#
-# DOCKER_LDFLAGS can be used to pass additional parameters to -ldflags
-# option of "go build". For example, a built-in graphdriver priority list
-# can be changed during build time like this:
-#
-# make DOCKER_LDFLAGS="-X github.com/docker/docker/daemon/graphdriver.priority=overlay2,devicemapper" dynbinary
-#
-DOCKER_ENVS := \
-	-e DOCKER_CROSSPLATFORMS \
-	-e BUILD_APT_MIRROR \
-	-e BUILDFLAGS \
-	-e KEEPBUNDLE \
-	-e DOCKER_BUILD_ARGS \
-	-e DOCKER_BUILD_GOGC \
-	-e DOCKER_BUILD_OPTS \
-	-e DOCKER_BUILD_PKGS \
-	-e DOCKER_BUILDKIT \
-	-e DOCKER_BASH_COMPLETION_PATH \
-	-e DOCKER_CLI_PATH \
-	-e DOCKER_DEBUG \
-	-e DOCKER_EXPERIMENTAL \
-	-e DOCKER_GITCOMMIT \
-	-e DOCKER_GRAPHDRIVER \
-	-e DOCKER_LDFLAGS \
-	-e DOCKER_PORT \
-	-e DOCKER_REMAP_ROOT \
-	-e DOCKER_ROOTLESS \
-	-e DOCKER_STORAGE_OPTS \
-	-e DOCKER_TEST_HOST \
-	-e DOCKER_USERLANDPROXY \
-	-e DOCKERD_ARGS \
-	-e TEST_FORCE_VALIDATE \
-	-e TEST_INTEGRATION_DIR \
-	-e TEST_SKIP_INTEGRATION \
-	-e TEST_SKIP_INTEGRATION_CLI \
-	-e TESTDEBUG \
-	-e TESTDIRS \
-	-e TESTFLAGS \
-	-e TESTFLAGS_INTEGRATION \
-	-e TESTFLAGS_INTEGRATION_CLI \
-	-e TEST_FILTER \
-	-e TIMEOUT \
-	-e VALIDATE_REPO \
-	-e VALIDATE_BRANCH \
-	-e VALIDATE_ORIGIN_BRANCH \
-	-e HTTP_PROXY \
-	-e HTTPS_PROXY \
-	-e NO_PROXY \
-	-e http_proxy \
-	-e https_proxy \
-	-e no_proxy \
-	-e VERSION \
-	-e PLATFORM \
-	-e DEFAULT_PRODUCT_LICENSE \
-	-e PRODUCT
-# note: we _cannot_ add "-e DOCKER_BUILDTAGS" here because even if it's unset in the shell, that would shadow the "ENV DOCKER_BUILDTAGS" set in our Dockerfile, which is very important for our official builds
-
-# to allow `make BIND_DIR=. shell` or `make BIND_DIR= test`
-# (default to no bind mount if DOCKER_HOST is set)
-# note: BINDDIR is supported for backwards-compatibility here
-BIND_DIR := $(if $(BINDDIR),$(BINDDIR),$(if $(DOCKER_HOST),,bundles))
-
-# DOCKER_MOUNT can be overriden, but use at your own risk!
-ifndef DOCKER_MOUNT
-DOCKER_MOUNT := $(if $(BIND_DIR),-v "$(CURDIR)/$(BIND_DIR):/go/src/github.com/docker/docker/$(BIND_DIR)")
-DOCKER_MOUNT := $(if $(DOCKER_BINDDIR_MOUNT_OPTS),$(DOCKER_MOUNT):$(DOCKER_BINDDIR_MOUNT_OPTS),$(DOCKER_MOUNT))
-
-# 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) -v "$(CURDIR)/.git:/go/src/github.com/docker/docker/.git"
-
-DOCKER_MOUNT_CACHE := -v docker-dev-cache:/root/.cache
-DOCKER_MOUNT_CLI := $(if $(DOCKER_CLI_PATH),-v $(shell dirname $(DOCKER_CLI_PATH)):/usr/local/cli,)
-DOCKER_MOUNT_BASH_COMPLETION := $(if $(DOCKER_BASH_COMPLETION_PATH),-v $(shell dirname $(DOCKER_BASH_COMPLETION_PATH)):/usr/local/completion/bash,)
-DOCKER_MOUNT := $(DOCKER_MOUNT) $(DOCKER_MOUNT_CACHE) $(DOCKER_MOUNT_CLI) $(DOCKER_MOUNT_BASH_COMPLETION)
-endif # ifndef DOCKER_MOUNT
-
-# This allows to set the docker-dev container name
-DOCKER_CONTAINER_NAME := $(if $(CONTAINER_NAME),--name $(CONTAINER_NAME),)
-
-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_PORT_FORWARD := $(if $(DOCKER_PORT),-p "$(DOCKER_PORT)",)
-
-DOCKER_FLAGS := $(DOCKER) run --rm -i --privileged $(DOCKER_CONTAINER_NAME) $(DOCKER_ENVS) $(DOCKER_MOUNT) $(DOCKER_PORT_FORWARD)
-BUILD_APT_MIRROR := $(if $(DOCKER_BUILD_APT_MIRROR),--build-arg APT_MIRROR=$(DOCKER_BUILD_APT_MIRROR))
-export BUILD_APT_MIRROR
-
-SWAGGER_DOCS_PORT ?= 9000
-
-define \n
-
-
-endef
-
-# 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_DOCKER := $(DOCKER_FLAGS) "$(DOCKER_IMAGE)"
-
-DOCKER_BUILD_ARGS += --build-arg=GO_VERSION
-ifdef DOCKER_SYSTEMD
-DOCKER_BUILD_ARGS += --build-arg=SYSTEMD=true
-endif
-
-BUILD_OPTS := ${BUILD_APT_MIRROR} ${DOCKER_BUILD_ARGS} ${DOCKER_BUILD_OPTS} -f "$(DOCKERFILE)"
-ifdef USE_BUILDX
-BUILD_OPTS += $(BUILDX_BUILD_EXTRA_OPTS)
-BUILD_CMD := $(BUILDX) build
-else
-BUILD_CMD := $(DOCKER) build
-endif
-
-# This is used for the legacy "build" target and anything still depending on it
-BUILD_CROSS =
-ifdef DOCKER_CROSS
-BUILD_CROSS = --build-arg CROSS=$(DOCKER_CROSS)
-endif
-ifdef DOCKER_CROSSPLATFORMS
-BUILD_CROSS = --build-arg CROSS=true
-endif
-
-VERSION_AUTOGEN_ARGS = --build-arg VERSION --build-arg DOCKER_GITCOMMIT --build-arg PRODUCT --build-arg PLATFORM --build-arg DEFAULT_PRODUCT_LICENSE
-
-default: binary
-
-all: build ## validate all checks, build linux binaries, run all tests,\ncross build non-linux binaries, and generate archives
-	$(DOCKER_RUN_DOCKER) bash -c 'hack/validate/default && hack/make.sh'
-
-# This is only used to work around read-only bind mounts of the source code into
-# binary build targets. We end up mounting a tmpfs over autogen which allows us
-# to write build-time generated assets even though the source is mounted read-only
-# ...But in order to do so, this dir needs to already exist.
-autogen:
-	mkdir -p autogen
-
-binary: buildx autogen ## build statically linked linux binaries
-	$(BUILD_CMD) $(BUILD_OPTS) --output=bundles/ --target=$@ $(VERSION_AUTOGEN_ARGS) .
-
-dynbinary: buildx autogen ## build dynamically linked linux binaries
-	$(BUILD_CMD) $(BUILD_OPTS) --output=bundles/ --target=$@ $(VERSION_AUTOGEN_ARGS) .
-
-cross: BUILD_OPTS += --build-arg CROSS=true --build-arg DOCKER_CROSSPLATFORMS
-cross: buildx autogen ## cross build the binaries for darwin, freebsd and\nwindows
-	$(BUILD_CMD) $(BUILD_OPTS) --output=bundles/ --target=$@ $(VERSION_AUTOGEN_ARGS) .
-
-bundles:
-	mkdir bundles
-
-.PHONY: clean
-clean: clean-cache
-
-.PHONY: clean-cache
-clean-cache:
-	docker volume rm -f docker-dev-cache
-
-help: ## this help
-	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z0-9_-]+:.*?## / {gsub("\\\\n",sprintf("\n%22c",""), $$2);printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
-
-install: ## install the linux binaries
-	KEEPBUNDLE=1 hack/make.sh install-binary
-
-run: build ## run the docker daemon in a container
-	$(DOCKER_RUN_DOCKER) sh -c "KEEPBUNDLE=1 hack/make.sh install-binary run"
- 
-.PHONY: build
-ifeq ($(BIND_DIR), .)
-build: shell_target := --target=dev
-else
-build: shell_target := --target=final
-endif
-ifdef USE_BUILDX
-build: buildx_load := --load
-endif
-build: buildx
-	$(BUILD_CMD) $(BUILD_OPTS) $(shell_target) $(buildx_load) $(BUILD_CROSS) -t "$(DOCKER_IMAGE)" .
-
-shell: build  ## start a shell inside the build env
-	$(DOCKER_RUN_DOCKER) bash
-
-test: build test-unit ## run the unit, integration and docker-py tests
-	$(DOCKER_RUN_DOCKER) hack/make.sh dynbinary cross test-integration 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: test-integration ## (DEPRECATED) use test-integration
-
-ifneq ($(and $(TEST_SKIP_INTEGRATION),$(TEST_SKIP_INTEGRATION_CLI)),)
-test-integration:
-	@echo Both integrations suites skipped per environment variables
-else
-test-integration: build ## run the integration tests
-	$(DOCKER_RUN_DOCKER) hack/make.sh dynbinary test-integration
-endif
-
-test-integration-flaky: build ## run the stress test for all new integration tests
-	$(DOCKER_RUN_DOCKER) hack/make.sh dynbinary test-integration-flaky
-
-test-unit: build ## run the unit tests
-	$(DOCKER_RUN_DOCKER) hack/test/unit
-
-validate: build ## validate DCO, Seccomp profile generation, gofmt,\n./pkg/ isolation, golint, tests, tomls, go vet and vendor
-	$(DOCKER_RUN_DOCKER) hack/validate/all
-
-win: build ## cross build the binary for windows
-	$(DOCKER_RUN_DOCKER) DOCKER_CROSSPLATFORMS=windows/amd64 hack/make.sh cross
-
-.PHONY: swagger-gen
-swagger-gen:
-	docker run --rm -v $(PWD):/go/src/github.com/docker/docker \
-		-w /go/src/github.com/docker/docker \
-		--entrypoint hack/generate-swagger-api.sh \
-		-e GOPATH=/go \
-		quay.io/goswagger/swagger:0.7.4
-
-.PHONY: swagger-docs
-swagger-docs: ## preview the API documentation
-	@echo "API docs preview will be running at http://localhost:$(SWAGGER_DOCS_PORT)"
-	@docker run --rm -v $(PWD)/api/swagger.yaml:/usr/share/nginx/html/swagger.yaml \
-		-e 'REDOC_OPTIONS=hide-hostname="true" lazy-rendering' \
-		-p $(SWAGGER_DOCS_PORT):80 \
-		bfirsh/redoc:1.6.2
-
-.PHONY: buildx
-ifdef USE_BUILDX
-ifeq ($(BUILDX), bundles/buildx)
-buildx: bundles/buildx ## build buildx cli tool
-endif
-endif
-
-# This intentionally is not using the `--output` flag from the docker CLI, which
-# is a buildkit option. The idea here being that if buildx is being used, it's
-# because buildkit is not supported natively
-bundles/buildx: bundles ## build buildx CLI tool
-	docker build -f $${BUILDX_DOCKERFILE:-Dockerfile.buildx} -t "moby-buildx:$${BUILDX_COMMIT:-latest}" \
-		--build-arg BUILDX_COMMIT \
-		--build-arg BUILDX_REPO \
-		--build-arg GOOS=$$(if [ -n "$(GOOS)" ]; then echo $(GOOS); else go env GOHOSTOS || uname | awk '{print tolower($$0)}' || true; fi) \
-		--build-arg GOARCH=$$(if [ -n "$(GOARCH)" ]; then echo $(GOARCH); else go env GOHOSTARCH || true; fi) \
-		.
-
-	id=$$(docker create moby-buildx:$${BUILDX_COMMIT:-latest}); \
-	if [ -n "$${id}" ]; then \
-		docker cp $${id}:/usr/bin/buildx $@ \
-		&& touch $@; \
-		docker rm -f $${id}; \
-	fi
-
-	$@ version
+hack:
+	cd $(CURDIR)/buildbot && vagrant up
--- a/19
+++ b/19
@@ -1,19 +1,6 @@
 Docker
-Copyright 2012-2017 Docker, Inc.
+Copyright 2012-2013 dotCloud, inc.

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

-This product contains software (https://github.com/creack/pty) developed
-by Keith Rarick, licensed under the MIT License.
-
-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.
-It is your responsibility to ensure that your use and/or transfer does not
-violate applicable laws.
-
-For more information, please see https://www.bis.doc.gov
-
-See also https://www.apache.org/dev/crypto.html and/or seek legal counsel.
+This product contains software (https://github.com/kr/pty) developed by Keith Rarick, licensed under the MIT License.
--- a/README.md
+++ b/README.md
@@ -1,57 +1,317 @@
-The Moby Project
-================
+Docker: the Linux container runtime
+===================================

-![Moby Project logo](docs/static_files/moby-project-logo.png "The Moby Project")
+Docker complements LXC with a high-level API which operates at the process level. It runs unix processes with strong guarantees of isolation and repeatability across servers.

-Moby is an open-source project created by Docker to enable and accelerate software containerization.
+Docker is a great building block for automating distributed systems: large-scale web deployments, database clusters, continuous deployment systems, private PaaS, service-oriented architectures, etc.

-It provides a "Lego set" of toolkit components, the framework for assembling them into custom container-based systems, and a place for all container enthusiasts and professionals to experiment and exchange ideas.
-Components include container build tools, a container registry, orchestration tools, a runtime and more, and these can be used as building blocks in conjunction with other tools and projects.
+![Docker L](docs/sources/static_files/lego_docker.jpg "Docker")

-## Principles
+* *Heterogeneous payloads*: any combination of binaries, libraries, configuration files, scripts, virtualenvs, jars, gems, tarballs, you name it. No more juggling between domain-specific tools. Docker can deploy and run them all.

-Moby is an open project guided by strong principles, aiming to be modular, flexible and without too strong an opinion on user experience.
-It is open to the community to help set its direction.
+* *Any server*: docker can run on any x64 machine with a modern linux kernel - whether it's a laptop, a bare metal server or a VM. This makes it perfect for multi-cloud deployments.

- Modular: the project includes lots of components that have well-defined functions and APIs that work together.
- Batteries included but swappable: Moby includes enough components to build fully featured container system, but its modular architecture ensures that most of the components can be swapped by different implementations.
- Usable security: Moby provides secure defaults without compromising usability.
- Developer focused: The APIs are intended to be functional and useful to build powerful tools.
-They are not necessarily intended as end user tools but as components aimed at developers.
-Documentation and UX is aimed at developers not end users.
+* *Isolation*: docker isolates processes from each other and from the underlying host, using lightweight containers.

-## Audience
+* *Repeatability*: because containers are isolated in their own filesystem, they behave the same regardless of where, when, and alongside what they run.

-The Moby Project is intended for engineers, integrators and enthusiasts looking to modify, hack, fix, experiment, invent and build systems based on containers.
-It is not for people looking for a commercially supported system, but for people who want to work and learn with open source code.

-## Relationship with Docker
+Notable features
+-----------------

-The components and tools in the Moby Project are initially the open source components that Docker and the community have built for the Docker Project.
-New projects can be added if they fit with the community goals. Docker is committed to using Moby as the upstream for the Docker Product.
-However, other projects are also encouraged to use Moby as an upstream, and to reuse the components in diverse ways, and all these uses will be treated in the same way. External maintainers and contributors are welcomed.
+* Filesystem isolation: each process container runs in a completely separate root filesystem.

-The Moby project is not intended as a location for support or feature requests for Docker products, but as a place for contributors to work on open source code, fix bugs, and make the code more useful.
-The releases are supported by the maintainers, community and users, on a best efforts basis only, and are not intended for customers who want enterprise or commercial support; Docker EE is the appropriate product for these use cases.
+* Resource isolation: system resources like cpu and memory can be allocated differently to each process container, using cgroups.

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

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

-*Brought to you courtesy of our legal counsel. For more context,
-please see the [NOTICE](https://github.com/moby/moby/blob/master/NOTICE) document in this repo.*
+* Logging: the standard streams (stdout/stderr/stdin) of each process container are collected and logged for real-time or batch retrieval.

-Use and transfer of Moby may be subject to certain restrictions by the
-United States and other governments.
+* Change management: changes to a container's filesystem can be committed into a new image and re-used to create more containers. No templating or manual configuration required.

-It is your responsibility to ensure that your use and/or transfer does not
-violate applicable laws.
+* Interactive shell: docker can allocate a pseudo-tty and attach to the standard input of any container, for example to run a throwaway interactive shell.
+
+Install instructions
+==================
+
+Quick install on Ubuntu 12.04 and 12.10
+---------------------------------------
+
+```bash
+curl get.docker.io | sh -x
+```
+
+Binary installs
+----------------
+
+Docker supports the following binary installation methods.
+Note that some methods are community contributions and not yet officially supported.
+
+* [Ubuntu 12.04 and 12.10 (officially supported)](http://docs.docker.io/en/latest/installation/ubuntulinux/)
+* [Arch Linux](http://docs.docker.io/en/latest/installation/archlinux/)
+* [MacOS X (with Vagrant)](http://docs.docker.io/en/latest/installation/macos/)
+* [Windows (with Vagrant)](http://docs.docker.io/en/latest/installation/windows/)
+* [Amazon EC2 (with Vagrant)](http://docs.docker.io/en/latest/installation/amazon/)
+
+Installing from source
+----------------------
+
+1. Make sure you have a [Go language](http://golang.org/doc/install) compiler and [git](http://git-scm.com) installed.
+
+2. Checkout the source code
+
+   ```bash
+   git clone http://github.com/dotcloud/docker
+   ```
+
+3. Build the docker binary
+
+   ```bash
+   cd docker
+   make VERBOSE=1
+   sudo cp ./bin/docker /usr/local/bin/docker
+   ```
+
+Usage examples
+==============
+
+First run the docker daemon
+---------------------------
+
+All the examples assume your machine is running the docker daemon. To run the docker daemon in the background, simply type:
+
+```bash
+# On a production system you want this running in an init script
+sudo docker -d &
+```
+
+Now you can run docker in client mode: all commands will be forwarded to the docker daemon, so the client can run from any account.
+
+```bash
+# Now you can run docker commands from any account.
+docker help
+```
+
+
+Throwaway shell in a base ubuntu image
+--------------------------------------
+
+```bash
+docker pull ubuntu:12.10
+
+# Run an interactive shell, allocate a tty, attach stdin and stdout
+# To detach the tty without exiting the shell, use the escape sequence Ctrl-p + Ctrl-q
+docker run -i -t ubuntu:12.10 /bin/bash
+```
+
+Starting a long-running worker process
+--------------------------------------
+
+```bash
+# Start a very useful long-running process
+JOB=$(docker run -d ubuntu /bin/sh -c "while true; do echo Hello world; sleep 1; done")
+
+# Collect the output of the job so far
+docker logs $JOB
+
+# Kill the job
+docker kill $JOB
+```
+
+Running an irc bouncer
+----------------------
+
+```bash
+BOUNCER_ID=$(docker run -d -p 6667 -u irc shykes/znc $USER $PASSWORD)
+echo "Configure your irc client to connect to port $(docker port $BOUNCER_ID 6667) of this machine"
+```
+
+Running Redis
+-------------
+
+```bash
+REDIS_ID=$(docker run -d -p 6379 shykes/redis redis-server)
+echo "Configure your redis client to connect to port $(docker port $REDIS_ID 6379) of this machine"
+```
+
+Share your own image!
+---------------------
+
+```bash
+CONTAINER=$(docker run -d ubuntu:12.10 apt-get install -y curl)
+docker commit -m "Installed curl" $CONTAINER $USER/betterbase
+docker push $USER/betterbase
+```
+
+A list of publicly available images is [available here](https://github.com/dotcloud/docker/wiki/Public-docker-images).
+
+Expose a service on a TCP port
+------------------------------
+
+```bash
+# Expose port 4444 of this container, and tell netcat to listen on it
+JOB=$(docker run -d -p 4444 base /bin/nc -l -p 4444)
+
+# Which public port is NATed to my container?
+PORT=$(docker port $JOB 4444)
+
+# Connect to the public port via the host's public address
+# Please note that because of how routing works connecting to localhost or 127.0.0.1 $PORT will not work.
+IP=$(ifconfig eth0 | perl -n -e 'if (m/inet addr:([\d\.]+)/g) { print $1 }')
+echo hello world | nc $IP $PORT
+
+# Verify that the network connection worked
+echo "Daemon received: $(docker logs $JOB)"
+```
+
+Under the hood
+--------------
+
+Under the hood, Docker is built on the following components:
+
+
+* The [cgroup](http://blog.dotcloud.com/kernel-secrets-from-the-paas-garage-part-24-c) and [namespacing](http://blog.dotcloud.com/under-the-hood-linux-kernels-on-dotcloud-part) capabilities of the Linux kernel;
+
+* [AUFS](http://aufs.sourceforge.net/aufs.html), a powerful union filesystem with copy-on-write capabilities;
+
+* The [Go](http://golang.org) programming language;
+
+* [lxc](http://lxc.sourceforge.net/), a set of convenience scripts to simplify the creation of linux containers.
+
+
+
+Contributing to Docker
+======================
+
+Want to hack on Docker? Awesome! There are instructions to get you started on the website: http://docs.docker.io/en/latest/contributing/contributing/
+
+They are probably not perfect, please let us know if anything feels wrong or incomplete.
+
+
+Note
+----
+
+We also keep the documentation in this repository. The website documentation is generated using sphinx using these sources.
+Please find it under docs/sources/ and read more about it https://github.com/dotcloud/docker/master/docs/README.md
+
+Please feel free to fix / update the documentation and send us pull requests. More tutorials are also welcome.
+
+
+Setting up a dev environment
+----------------------------
+
+Instructions that have been verified to work on Ubuntu 12.10,
+
+```bash
+sudo apt-get -y install lxc wget bsdtar curl golang git
+
+export GOPATH=~/go/
+export PATH=$GOPATH/bin:$PATH
+
+mkdir -p $GOPATH/src/github.com/dotcloud
+cd $GOPATH/src/github.com/dotcloud
+git clone git@github.com:dotcloud/docker.git
+cd docker
+
+go get -v github.com/dotcloud/docker/...
+go install -v github.com/dotcloud/docker/...
+```
+
+Then run the docker daemon,
+
+```bash
+sudo $GOPATH/bin/docker -d
+```
+
+Run the `go install` command (above) to recompile docker.
+
+
+What is a Standard Container?
+=============================
+
+Docker defines a unit of software delivery called a Standard Container. The goal of a Standard Container is to encapsulate a software component and all its dependencies in
+a format that is self-describing and portable, so that any compliant runtime can run it without extra dependencies, regardless of the underlying machine and the contents of the container.
+
+The spec for Standard Containers is currently a work in progress, but it is very straightforward. It mostly defines 1) an image format, 2) a set of standard operations, and 3) an execution environment.
+
+A great analogy for this is the shipping container. Just like Standard Containers are a fundamental unit of software delivery, shipping containers (http://bricks.argz.com/ins/7823-1/12) are a fundamental unit of physical delivery.
+
+### 1. STANDARD OPERATIONS
+
+Just like shipping containers, Standard Containers define a set of STANDARD OPERATIONS. Shipping containers can be lifted, stacked, locked, loaded, unloaded and labelled. Similarly, standard containers can be started, stopped, copied, snapshotted, downloaded, uploaded and tagged.
+
+
+### 2. CONTENT-AGNOSTIC
+
+Just like shipping containers, Standard Containers are CONTENT-AGNOSTIC: all standard operations have the same effect regardless of the contents. A shipping container will be stacked in exactly the same way whether it contains Vietnamese powder coffee or spare Maserati parts. Similarly, Standard Containers are started or uploaded in the same way whether they contain a postgres database, a php application with its dependencies and application server, or Java build artifacts.
+
+
+### 3. INFRASTRUCTURE-AGNOSTIC
+
+Both types of containers are INFRASTRUCTURE-AGNOSTIC: they can be transported to thousands of facilities around the world, and manipulated by a wide variety of equipment. A shipping container can be packed in a factory in Ukraine, transported by truck to the nearest routing center, stacked onto a train, loaded into a German boat by an Australian-built crane, stored in a warehouse at a US facility, etc. Similarly, a standard container can be bundled on my laptop, uploaded to S3, downloaded, run and snapshotted by a build server at Equinix in Virginia, uploaded to 10 staging servers in a home-made Openstack cluster, then sent to 30 production instances across 3 EC2 regions.
+
+
+### 4. DESIGNED FOR AUTOMATION
+
+Because they offer the same standard operations regardless of content and infrastructure, Standard Containers, just like their physical counterpart, are extremely well-suited for automation. In fact, you could say automation is their secret weapon.
+
+Many things that once required time-consuming and error-prone human effort can now be programmed. Before shipping containers, a bag of powder coffee was hauled, dragged, dropped, rolled and stacked by 10 different people in 10 different locations by the time it reached its destination. 1 out of 50 disappeared. 1 out of 20 was damaged. The process was slow, inefficient and cost a fortune - and was entirely different depending on the facility and the type of goods.
+
+Similarly, before Standard Containers, by the time a software component ran in production, it had been individually built, configured, bundled, documented, patched, vendored, templated, tweaked and instrumented by 10 different people on 10 different computers. Builds failed, libraries conflicted, mirrors crashed, post-it notes were lost, logs were misplaced, cluster updates were half-broken. The process was slow, inefficient and cost a fortune - and was entirely different depending on the language and infrastructure provider.
+
+
+### 5. INDUSTRIAL-GRADE DELIVERY
+
+There are 17 million shipping containers in existence, packed with every physical good imaginable. Every single one of them can be loaded on the same boats, by the same cranes, in the same facilities, and sent anywhere in the World with incredible efficiency. It is embarrassing to think that a 30 ton shipment of coffee can safely travel half-way across the World in *less time* than it takes a software team to deliver its code from one datacenter to another sitting 10 miles away.
+
+With Standard Containers we can put an end to that embarrassment, by making INDUSTRIAL-GRADE DELIVERY of software a reality.
+
+
+
+
+Standard Container Specification
+--------------------------------
+
+(TODO)
+
+### Image format
+
+
+### Standard operations
+
+* Copy
+* Run
+* Stop
+* Wait
+* Commit
+* Attach standard streams
+* List filesystem changes
+* ...
+
+### Execution environment
+
+#### Root filesystem
+
+#### Environment variables
+
+#### Process arguments
+
+#### Networking
+
+#### Process namespacing
+
+#### Resource limits
+
+#### Process monitoring
+
+#### Logging
+
+#### Signals
+
+#### Pseudo-terminal allocation
+
+#### Security

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

-Licensing
-=========
-Moby is licensed under the Apache License, Version 2.0. See
-[LICENSE](https://github.com/moby/moby/blob/master/LICENSE) for the full
-license text.
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -1,117 +0,0 @@
-Moby Project 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 Moby contributors to understand where the project is going, and
-help determine if a contribution could be conflicting with some longer term plans.
-
-The fact that a feature isn't listed here doesn't mean that a patch for it will automatically be
-refused! We are always happy to receive patches for new cool features we haven't thought about,
-or didn't judge to be a priority. Please however understand that such patches might take longer
-for us to review.
-
-### How can I help?
-
-Short term objectives are listed in
-[Issues](https://github.com/moby/moby/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 work on it to avoid duplicating effort! Similarly, if a maintainer is already
-assigned on an issue you'd like to participate in, pinging him on 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 Moby Project: 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, it is best to discuss with the maintainers on an
-issue, in the Slack channel, or in person at the Moby Summits that happen every few months.
-
-# 1. Features and refactoring
-
-## 1.1 Runtime improvements
-
-Over time we have accumulated a lot of functionality in the container runtime
-aspect of Moby while also growing in other areas. Much of the container runtime
-pieces are now duplicated work available in other, lower level components such
-as [containerd](https://containerd.io).
-
-Moby currently only utilizes containerd for basic runtime state management, e.g. starting
-and stopping a container, which is what the pre-containerd 1.0 daemon provided.
-Now that containerd is a full-fledged container runtime which supports full
-container life-cycle management, we would like to start relying more on containerd
-and removing the bits in Moby which are now duplicated. This will necessitate
-a significant effort to refactor and even remove large parts of Moby's codebase.
-
-Tracking issues:
-
- [#38043](https://github.com/moby/moby/issues/38043) Proposal: containerd image integration
-
-## 1.2 Image Builder
-
-Work is ongoing to integrate [BuildKit](https://github.com/moby/buildkit) into
-Moby and replace the "v0" build implementation. Buildkit offers better cache
-management, parallelizable build steps, and better extensibility while also
-keeping builds portable, a chief tenent of Moby's builder.
-
-Upon completion of this effort, users will have a builder that performs better
-while also being more extensible, enabling users to provide their own custom
-syntax which can be either Dockerfile-like or something completely different.
-
-See [buildpacks on buildkit](https://github.com/tonistiigi/buildkit-pack) as an
-example of this extensibility.
-
-New features for the builder and Dockerfile should be implemented first in the
-BuildKit backend using an external Dockerfile implementation from the container
-images. This allows everyone to test and evaluate the feature without upgrading
-their daemon. New features should go to the experimental channel first, and can be
-part of the `docker/dockerfile:experimental` image. From there they graduate to
-`docker/dockerfile:latest` and binary releases. The Dockerfile frontend source
-code is temporarily located at
-[https://github.com/moby/buildkit/tree/master/frontend/dockerfile](https://github.com/moby/buildkit/tree/master/frontend/dockerfile)
-with separate new features defined with go build tags.
-
-Tracking issues:
-
- [#32925](https://github.com/moby/moby/issues/32925) discussion: builder future: buildkit
-
-## 1.3 Rootless Mode
-
-Running the daemon requires elevated privileges for many tasks. We would like to
-support running the daemon as a normal, unprivileged user without requiring `suid`
-binaries.
-
-Tracking issues:
-
- [#37375](https://github.com/moby/moby/issues/37375) Proposal: allow running `dockerd` as an unprivileged user (aka rootless mode)
-
-## 1.4 Testing
-
-Moby has many tests, both unit and integration. Moby needs more tests which can
-cover the full spectrum functionality and edge cases out there.
-
-Tests in the `integration-cli` folder should also be migrated into (both in
-location and style) the `integration` folder. These newer tests are simpler to
-run in isolation, simpler to read, simpler to write, and more fully exercise the
-API. Meanwhile tests of the docker CLI should generally live in docker/cli.
-
-Tracking issues:
-
- [#32866](https://github.com/moby/moby/issues/32866) Replace integration-cli suite with API test suite
-
-## 1.5 Internal decoupling
-
-A lot of work has been done in trying to decouple Moby internals. This process of creating
-standalone projects with a well defined function that attract a dedicated community should continue.
-As well as integrating `containerd` we would like to integrate [BuildKit](https://github.com/moby/buildkit)
-as the next standalone component.
-We see gRPC as the natural communication layer between decoupled components.
-
-In addition to pushing out large components into other projects, much of the
-internal code structure, and in particular the
-["Daemon"](https://godoc.org/github.com/docker/docker/daemon#Daemon) object,
-should be split into smaller, more manageable, and more testable components.
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,9 +0,0 @@
-# Reporting security issues
-
-The Moby maintainers take security seriously. If you discover a security issue, please bring it to their attention right away!
-
-### Reporting a Vulnerability
-
-Please **DO NOT** file a public issue, instead send your report privately to security@docker.com.
-
-Security reports are greatly appreciated and we will publicly thank you for it, although we keep your name confidential if you request it. We also like to send gifts—if you're into 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.
--- a/SPECS/data-volumes.md
+++ b/SPECS/data-volumes.md
@@ -0,0 +1,71 @@
+
+## Spec for data volumes
+
+Spec owner: Solomon Hykes <solomon@dotcloud.com>
+
+Data volumes (issue #111) are a much-requested feature which trigger much discussion and debate. Below is the current authoritative spec for implementing data volumes.
+This spec will be deprecated once the feature is fully implemented.
+
+Discussion, requests, trolls, demands, offerings, threats and other forms of supplications concerning this spec should be addressed to Solomon here: https://github.com/dotcloud/docker/issues/111
+
+
+### 1. Creating data volumes
+
+At container creation, parts of a container's filesystem can be mounted as separate data volumes. Volumes are defined with the -v flag.
+
+For example:
+
+```bash
+$ docker run -v /var/lib/postgres -v /var/log postgres /usr/bin/postgres
+```
+
+In this example, a new container is created from the 'postgres' image. At the same time, docker creates 2 new data volumes: one will be mapped to the container at /var/lib/postgres, the other at /var/log.
+
+2 important notes:
+
+1) Volumes don't have top-level names. At no point does the user provide a name, or is a name given to him. Volumes are identified by the path at which they are mounted inside their container.
+
+2) The user doesn't choose the source of the volume. Docker only mounts volumes it created itself, in the same way that it only runs containers that it created itself. That is by design.
+
+
+### 2. Sharing data volumes
+
+Instead of creating its own volumes, a container can share another container's volumes. For example:
+
+```bash
+$ docker run --volumes-from $OTHER_CONTAINER_ID postgres /usr/local/bin/postgres-backup
+```
+
+In this example, a new container is created from the 'postgres' example. At the same time, docker will *re-use* the 2 data volumes created in the previous example. One volume will be mounted on the /var/lib/postgres of *both* containers, and the other will be mounted on the /var/log of both containers.
+
+### 3. Under the hood
+
+Docker stores volumes in /var/lib/docker/volumes. Each volume receives a globally unique ID at creation, and is stored at /var/lib/docker/volumes/ID.
+
+At creation, volumes are attached to a single container - the source of truth for this mapping will be the container's configuration.
+
+Mounting a volume consists of calling "mount --bind" from the volume's directory to the appropriate sub-directory of the container mountpoint. This may be done by Docker itself, or farmed out to lxc (which supports mount-binding) if possible.
+
+
+### 4. Backups, transfers and other volume operations
+
+Volumes sometimes need to be backed up, transfered between hosts, synchronized, etc. These operations typically are application-specific or site-specific, eg. rsync vs. S3 upload vs. replication vs...
+
+Rather than attempting to implement all these scenarios directly, Docker will allow for custom implementations using an extension mechanism.
+
+### 5. Custom volume handlers
+
+Docker allows for arbitrary code to be executed against a container's volumes, to implement any custom action: backup, transfer, synchronization across hosts, etc.
+
+Here's an example:
+
+```bash
+$ DB=$(docker run -d -v /var/lib/postgres -v /var/log postgres /usr/bin/postgres)
+
+$ BACKUP_JOB=$(docker run -d --volumes-from $DB shykes/backuper /usr/local/bin/backup-postgres --s3creds=$S3CREDS)
+
+$ docker wait $BACKUP_JOB
+```
+
+Congratulations, you just implemented a custom volume handler, using Docker's built-in ability to 1) execute arbitrary code and 2) share volumes between containers.
+
--- a/TESTING.md
+++ b/TESTING.md
@@ -1,126 +0,0 @@
-# Testing
-
-This document contains the Moby code testing guidelines. It should answer any 
-questions you may have as an aspiring Moby contributor.
-
-## Test suites
-
-Moby has two test suites (and one legacy test suite):
-
-* Unit tests - use standard `go test` and
-  [gotest.tools/assert](https://godoc.org/gotest.tools/assert) assertions. They are located in
-  the package they test. Unit tests should be fast and test only their own 
-  package.
-* API integration tests - use standard `go test` and
-  [gotest.tools/assert](https://godoc.org/gotest.tools/assert) assertions. They are located in
-  `./integration/<component>` directories, where `component` is: container,
-  image, volume, etc. These tests perform HTTP requests to an API endpoint and
-  check the HTTP response and daemon state after the call.
-
-The legacy test suite `integration-cli/` is deprecated. No new tests will be 
-added to this suite. Any tests in this suite which require updates should be 
-ported to either the unit test suite or the new API integration test suite.
-
-## Writing new tests
-
-Most code changes will fall into one of the following categories.
-
-### Writing tests for new features
-
-New code should be covered by unit tests. If the code is difficult to test with
-unit tests, then that is a good sign that it should be refactored to make it
-easier to reuse and maintain. Consider accepting unexported interfaces instead
-of structs so that fakes can be provided for dependencies.
-
-If the new feature includes a completely new API endpoint then a new API 
-integration test should be added to cover the success case of that endpoint.
-
-If the new feature does not include a completely new API endpoint consider 
-adding the new API fields to the existing test for that endpoint. A new 
-integration test should **not** be added for every new API field or API error 
-case. Error cases should be handled by unit tests.
-
-### Writing tests for bug fixes
-
-Bugs fixes should include a unit test case which exercises the bug.
-
-A bug fix may also include new assertions in existing integration tests for the
-API endpoint.
-
-### Writing new integration tests
-
-Note the `integration-cli` tests are deprecated; new tests will be rejected by
-the CI.
-
-Instead, implement new tests under `integration/`.
-
-### Integration tests environment considerations
-
-When adding new tests or modifying existing tests under `integration/`, testing
-environment should be properly considered. `skip.If` from 
-[gotest.tools/skip](https://godoc.org/gotest.tools/skip) can be used to make the 
-test run conditionally. Full testing environment conditions can be found at 
-[environment.go](https://github.com/moby/moby/blob/6b6eeed03b963a27085ea670f40cd5ff8a61f32e/testutil/environment/environment.go)
-
-Here is a quick example. If the test needs to interact with a docker daemon on 
-the same host, the following condition should be checked within the test code
-
-```go
-skip.If(t, testEnv.IsRemoteDaemon())
-// your integration test code
-```
-
-If a remote daemon is detected, the test will be skipped.
-
-## Running tests
-
-### Unit Tests
-
-To run the unit test suite:
-
-```
-make test-unit
-```
-
-or `hack/test/unit` from inside a `BINDDIR=. make shell` container or properly
-configured environment.
-
-The following environment variables may be used to run a subset of tests:
-
-* `TESTDIRS` - paths to directories to be tested, defaults to `./...`
-* `TESTFLAGS` - flags passed to `go test`, to run tests which match a pattern
-  use `TESTFLAGS="-test.run TestNameOrPrefix"`
-
-### Integration Tests
-
-To run the integration test suite:
-
-```
-make test-integration
-```
-
-This make target runs both the "integration" suite and the "integration-cli"
-suite.
-
-You can specify which integration test dirs to build and run by specifying
-the list of dirs in the TEST_INTEGRATION_DIR environment variable.
-
-You can also explicitly skip either suite by setting (any value) in
-TEST_SKIP_INTEGRATION and/or TEST_SKIP_INTEGRATION_CLI environment variables.
-
-Flags specific to each suite can be set in the TESTFLAGS_INTEGRATION and
-TESTFLAGS_INTEGRATION_CLI environment variables.
-
-If all you want is to specify a test filter to run, you can set the
-`TEST_FILTER` environment variable. This ends up getting passed directly to `go
-test -run` (or `go test -check-f`, depending on the test suite). It will also
-automatically set the other above mentioned environment variables accordingly.
-
-### Go Version
-
-You can change a version of golang used for building stuff that is being tested
-by setting `GO_VERSION` variable, for example:
-
-```
-make GO_VERSION=1.12.8 test
-```
--- a/VENDORING.md
+++ b/VENDORING.md
@@ -1,46 +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 [Semantic Versioning](http://semver.org) policies:
-
-"Given a version number MAJOR.MINOR.PATCH, increment the:
-
-   1. MAJOR version when you make incompatible API changes,
-   2. MINOR version when you add functionality in a backwards-compatible manner, and
-   3. 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/82
+++ b/82
@@ -0,0 +1,82 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+def v10(config)
+  config.vm.box = 'precise64'
+  config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
+
+  # Install ubuntu packaging dependencies and create ubuntu packages
+  config.vm.provision :shell, :inline => "echo 'deb http://ppa.launchpad.net/dotcloud/lxc-docker/ubuntu precise main' >>/etc/apt/sources.list"
+  config.vm.provision :shell, :inline => 'export DEBIAN_FRONTEND=noninteractive; apt-get -qq update; apt-get install -qq -y --force-yes lxc-docker'
+end
+
+Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|
+  v10(config)
+end
+
+Vagrant::VERSION >= "1.1.0" and Vagrant.configure("1") do |config|
+  v10(config)
+end
+
+Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|
+  config.vm.provider :aws do |aws|
+    config.vm.box = "dummy"
+    config.vm.box_url = "https://github.com/mitchellh/vagrant-aws/raw/master/dummy.box"
+    aws.access_key_id = ENV["AWS_ACCESS_KEY_ID"]
+    aws.secret_access_key =     ENV["AWS_SECRET_ACCESS_KEY"]
+    aws.keypair_name = ENV["AWS_KEYPAIR_NAME"]
+    aws.ssh_private_key_path = ENV["AWS_SSH_PRIVKEY"]
+    aws.region = "us-east-1"
+    aws.ami = "ami-d0f89fb9"
+    aws.ssh_username = "ubuntu"
+    aws.instance_type = "t1.micro"
+  end
+
+  config.vm.provider :rackspace do |rs|
+    config.vm.box = "dummy"
+    config.vm.box_url = "https://github.com/mitchellh/vagrant-rackspace/raw/master/dummy.box"
+    config.ssh.private_key_path = ENV["RS_PRIVATE_KEY"]
+    rs.username = ENV["RS_USERNAME"]
+    rs.api_key  = ENV["RS_API_KEY"]
+    rs.public_key_path = ENV["RS_PUBLIC_KEY"]
+    rs.flavor   = /512MB/
+    rs.image    = /Ubuntu/
+  end
+
+  config.vm.provider :virtualbox do |vb|
+    config.vm.box = 'precise64'
+    config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
+  end
+end
+
+Vagrant::VERSION >= "1.2.0" and Vagrant.configure("2") do |config|
+  config.vm.provider :aws do |aws, override|
+    config.vm.box = "dummy"
+    config.vm.box_url = "https://github.com/mitchellh/vagrant-aws/raw/master/dummy.box"
+    aws.access_key_id = ENV["AWS_ACCESS_KEY_ID"]
+    aws.secret_access_key = ENV["AWS_SECRET_ACCESS_KEY"]
+    aws.keypair_name = ENV["AWS_KEYPAIR_NAME"]
+    override.ssh.private_key_path = ENV["AWS_SSH_PRIVKEY"]
+    override.ssh.username = "ubuntu"
+    aws.region = "us-east-1"
+    aws.ami = "ami-d0f89fb9"
+    aws.instance_type = "t1.micro"
+  end
+
+  config.vm.provider :rackspace do |rs|
+    config.vm.box = "dummy"
+    config.vm.box_url = "https://github.com/mitchellh/vagrant-rackspace/raw/master/dummy.box"
+    config.ssh.private_key_path = ENV["RS_PRIVATE_KEY"]
+    rs.username = ENV["RS_USERNAME"]
+    rs.api_key  = ENV["RS_API_KEY"]
+    rs.public_key_path = ENV["RS_PUBLIC_KEY"]
+    rs.flavor   = /512MB/
+    rs.image    = /Ubuntu/
+  end
+
+  config.vm.provider :virtualbox do |vb|
+    config.vm.box = 'precise64'
+    config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
+  end
+
+end
--- a/api/README.md
+++ b/api/README.md
@@ -1,42 +0,0 @@
-# Working on the Engine API
-
-The Engine API is an HTTP API used by the command-line client to communicate with the daemon. It can also be used by third-party software to control the daemon.
-
-It consists of various components in this repository:
-
- `api/swagger.yaml` A Swagger definition of the API.
- `api/types/` Types shared by both the client and server, representing various objects, options, responses, etc. Most are written manually, but some are automatically generated from the Swagger definition. See [#27919](https://github.com/docker/docker/issues/27919) for progress on this.
- `cli/` The command-line client.
- `client/` The Go client used by the command-line client. It can also be used by third-party Go programs.
- `daemon/` The daemon, which serves the API.
-
-## Swagger definition
-
-The API is defined by the [Swagger](http://swagger.io/specification/) definition in `api/swagger.yaml`. This definition can be used to:
-
-1. Automatically generate documentation.
-2. Automatically generate the Go server and client. (A work-in-progress.)
-3. Provide a machine readable version of the API for introspecting what it can do, automatically generating clients for other languages, etc.
-
-## Updating the API documentation
-
-The API documentation is generated entirely from `api/swagger.yaml`. If you make updates to the API, edit this file to represent the change in the documentation.
-
-The file is split into two main sections:
-
- `definitions`, which defines re-usable objects used in requests and responses
- `paths`, which defines the API endpoints (and some inline objects which don't need to be reusable)
-
-To make an edit, first look for the endpoint you want to edit under `paths`, then make the required edits. Endpoints may reference reusable objects with `$ref`, which can be found in the `definitions` section.
-
-There is hopefully enough example material in the file for you to copy a similar pattern from elsewhere in the file (e.g. adding new fields or endpoints), but for the full reference, see the [Swagger specification](https://github.com/docker/docker/issues/27919).
-
-`swagger.yaml` is validated by `hack/validate/swagger` to ensure it is a valid Swagger definition. This is useful when making edits to ensure you are doing the right thing.
-
-## Viewing the API documentation
-
-When you make edits to `swagger.yaml`, you may want to check the generated API documentation to ensure it renders correctly.
-
-Run `make swagger-docs` and a preview will be running at `http://localhost`. Some of the styling may be incorrect, but you'll be able to ensure that it is generating the correct documentation.
-
-The production documentation is generated by vendoring `swagger.yaml` into [docker/docker.github.io](https://github.com/docker/docker.github.io).
--- a/api/common.go
+++ b/api/common.go
@@ -1,11 +0,0 @@
-package api // import "github.com/docker/docker/api"
-
-// Common constants for daemon and client.
-const (
-	// DefaultVersion of Current REST API
-	DefaultVersion = "1.41"
-
-	// NoBaseImageSpecifier is the symbol used by the FROM
-	// command to specify that no base image is to be used.
-	NoBaseImageSpecifier = "scratch"
-)
--- a/api/common_unix.go
+++ b/api/common_unix.go
@@ -1,6 +0,0 @@
-// +build !windows
-
-package api // import "github.com/docker/docker/api"
-
-// MinVersion represents Minimum REST API version supported
-const MinVersion = "1.12"
--- a/api/common_windows.go
+++ b/api/common_windows.go
@@ -1,8 +0,0 @@
-package api // import "github.com/docker/docker/api"
-
-// MinVersion represents Minimum REST API version supported
-// Technically the first daemon API version released on Windows is v1.25 in
-// engine version 1.13. However, some clients are explicitly using downlevel
-// APIs (e.g. docker-compose v2.1 file format) and that is just too restrictive.
-// Hence also allowing 1.24 on Windows.
-const MinVersion string = "1.24"
--- a/api/server/backend/build/backend.go
+++ b/api/server/backend/build/backend.go
@@ -1,130 +0,0 @@
-package build // import "github.com/docker/docker/api/server/backend/build"
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-
-	"github.com/docker/distribution/reference"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/backend"
-	"github.com/docker/docker/api/types/events"
-	"github.com/docker/docker/builder"
-	buildkit "github.com/docker/docker/builder/builder-next"
-	daemonevents "github.com/docker/docker/daemon/events"
-	"github.com/docker/docker/image"
-	"github.com/docker/docker/pkg/stringid"
-	"github.com/pkg/errors"
-	"google.golang.org/grpc"
-)
-
-// ImageComponent provides an interface for working with images
-type ImageComponent interface {
-	SquashImage(from string, to string) (string, error)
-	TagImageWithReference(image.ID, reference.Named) error
-}
-
-// Builder defines interface for running a build
-type Builder interface {
-	Build(context.Context, backend.BuildConfig) (*builder.Result, error)
-}
-
-// Backend provides build functionality to the API router
-type Backend struct {
-	builder        Builder
-	imageComponent ImageComponent
-	buildkit       *buildkit.Builder
-	eventsService  *daemonevents.Events
-}
-
-// NewBackend creates a new build backend from components
-func NewBackend(components ImageComponent, builder Builder, buildkit *buildkit.Builder, es *daemonevents.Events) (*Backend, error) {
-	return &Backend{imageComponent: components, builder: builder, buildkit: buildkit, eventsService: es}, nil
-}
-
-// RegisterGRPC registers buildkit controller to the grpc server.
-func (b *Backend) RegisterGRPC(s *grpc.Server) {
-	if b.buildkit != nil {
-		b.buildkit.RegisterGRPC(s)
-	}
-}
-
-// Build builds an image from a Source
-func (b *Backend) Build(ctx context.Context, config backend.BuildConfig) (string, error) {
-	options := config.Options
-	useBuildKit := options.Version == types.BuilderBuildKit
-
-	tagger, err := NewTagger(b.imageComponent, config.ProgressWriter.StdoutFormatter, options.Tags)
-	if err != nil {
-		return "", err
-	}
-
-	var build *builder.Result
-	if useBuildKit {
-		build, err = b.buildkit.Build(ctx, config)
-		if err != nil {
-			return "", err
-		}
-	} else {
-		build, err = b.builder.Build(ctx, config)
-		if err != nil {
-			return "", err
-		}
-	}
-
-	if build == nil {
-		return "", nil
-	}
-
-	var imageID = build.ImageID
-	if options.Squash {
-		if imageID, err = squashBuild(build, b.imageComponent); err != nil {
-			return "", err
-		}
-		if config.ProgressWriter.AuxFormatter != nil {
-			if err = config.ProgressWriter.AuxFormatter.Emit("moby.image.id", types.BuildResult{ID: imageID}); err != nil {
-				return "", err
-			}
-		}
-	}
-
-	if !useBuildKit {
-		stdout := config.ProgressWriter.StdoutFormatter
-		fmt.Fprintf(stdout, "Successfully built %s\n", stringid.TruncateID(imageID))
-	}
-	if imageID != "" {
-		err = tagger.TagImages(image.ID(imageID))
-	}
-	return imageID, err
-}
-
-// PruneCache removes all cached build sources
-func (b *Backend) PruneCache(ctx context.Context, opts types.BuildCachePruneOptions) (*types.BuildCachePruneReport, error) {
-	buildCacheSize, cacheIDs, err := b.buildkit.Prune(ctx, opts)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to prune build cache")
-	}
-	b.eventsService.Log("prune", events.BuilderEventType, events.Actor{
-		Attributes: map[string]string{
-			"reclaimed": strconv.FormatInt(buildCacheSize, 10),
-		},
-	})
-	return &types.BuildCachePruneReport{SpaceReclaimed: uint64(buildCacheSize), CachesDeleted: cacheIDs}, nil
-}
-
-// Cancel cancels the build by ID
-func (b *Backend) Cancel(ctx context.Context, id string) error {
-	return b.buildkit.Cancel(ctx, id)
-}
-
-func squashBuild(build *builder.Result, imageComponent ImageComponent) (string, error) {
-	var fromID string
-	if build.FromImage != nil {
-		fromID = build.FromImage.ImageID()
-	}
-	imageID, err := imageComponent.SquashImage(build.ImageID, fromID)
-	if err != nil {
-		return "", errors.Wrap(err, "error squashing image")
-	}
-	return imageID, nil
-}
--- a/api/server/backend/build/tag.go
+++ b/api/server/backend/build/tag.go
@@ -1,77 +0,0 @@
-package build // import "github.com/docker/docker/api/server/backend/build"
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/docker/distribution/reference"
-	"github.com/docker/docker/image"
-	"github.com/pkg/errors"
-)
-
-// Tagger is responsible for tagging an image created by a builder
-type Tagger struct {
-	imageComponent ImageComponent
-	stdout         io.Writer
-	repoAndTags    []reference.Named
-}
-
-// NewTagger returns a new Tagger for tagging the images of a build.
-// If any of the names are invalid tags an error is returned.
-func NewTagger(backend ImageComponent, stdout io.Writer, names []string) (*Tagger, error) {
-	reposAndTags, err := sanitizeRepoAndTags(names)
-	if err != nil {
-		return nil, err
-	}
-	return &Tagger{
-		imageComponent: backend,
-		stdout:         stdout,
-		repoAndTags:    reposAndTags,
-	}, nil
-}
-
-// TagImages creates image tags for the imageID
-func (bt *Tagger) TagImages(imageID image.ID) error {
-	for _, rt := range bt.repoAndTags {
-		if err := bt.imageComponent.TagImageWithReference(imageID, rt); err != nil {
-			return err
-		}
-		fmt.Fprintf(bt.stdout, "Successfully tagged %s\n", reference.FamiliarString(rt))
-	}
-	return nil
-}
-
-// sanitizeRepoAndTags parses the raw "t" parameter received from the client
-// to a slice of repoAndTag.
-// It also validates each repoName and tag.
-func sanitizeRepoAndTags(names []string) ([]reference.Named, error) {
-	var (
-		repoAndTags []reference.Named
-		// This map is used for deduplicating the "-t" parameter.
-		uniqNames = make(map[string]struct{})
-	)
-	for _, repo := range names {
-		if repo == "" {
-			continue
-		}
-
-		ref, err := reference.ParseNormalizedNamed(repo)
-		if err != nil {
-			return nil, err
-		}
-
-		if _, isCanonical := ref.(reference.Canonical); isCanonical {
-			return nil, errors.New("build tag cannot contain a digest")
-		}
-
-		ref = reference.TagNameOnly(ref)
-
-		nameWithTag := ref.String()
-
-		if _, exists := uniqNames[nameWithTag]; !exists {
-			uniqNames[nameWithTag] = struct{}{}
-			repoAndTags = append(repoAndTags, ref)
-		}
-	}
-	return repoAndTags, nil
-}
--- a/api/server/httputils/decoder.go
+++ b/api/server/httputils/decoder.go
@@ -1,16 +0,0 @@
-package httputils // import "github.com/docker/docker/api/server/httputils"
-
-import (
-	"io"
-
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/network"
-)
-
-// ContainerDecoder specifies how
-// to translate an io.Reader into
-// container configuration.
-type ContainerDecoder interface {
-	DecodeConfig(src io.Reader) (*container.Config, *container.HostConfig, *network.NetworkingConfig, error)
-	DecodeHostConfig(src io.Reader) (*container.HostConfig, error)
-}
--- a/api/server/httputils/errors_deprecated.go
+++ b/api/server/httputils/errors_deprecated.go
@@ -1,9 +0,0 @@
-package httputils // import "github.com/docker/docker/api/server/httputils"
-import "github.com/docker/docker/errdefs"
-
-// GetHTTPErrorStatusCode retrieves status code from error message.
-//
-// Deprecated: use errdefs.GetHTTPErrorStatusCode
-func GetHTTPErrorStatusCode(err error) int {
-	return errdefs.GetHTTPErrorStatusCode(err)
-}
--- a/api/server/httputils/form.go
+++ b/api/server/httputils/form.go
@@ -1,76 +0,0 @@
-package httputils // import "github.com/docker/docker/api/server/httputils"
-
-import (
-	"net/http"
-	"strconv"
-	"strings"
-)
-
-// BoolValue transforms a form value in different formats into a boolean type.
-func BoolValue(r *http.Request, k string) bool {
-	s := strings.ToLower(strings.TrimSpace(r.FormValue(k)))
-	return !(s == "" || s == "0" || s == "no" || s == "false" || s == "none")
-}
-
-// BoolValueOrDefault returns the default bool passed if the query param is
-// missing, otherwise it's just a proxy to boolValue above.
-func BoolValueOrDefault(r *http.Request, k string, d bool) bool {
-	if _, ok := r.Form[k]; !ok {
-		return d
-	}
-	return BoolValue(r, k)
-}
-
-// Int64ValueOrZero parses a form value into an int64 type.
-// It returns 0 if the parsing fails.
-func Int64ValueOrZero(r *http.Request, k string) int64 {
-	val, err := Int64ValueOrDefault(r, k, 0)
-	if err != nil {
-		return 0
-	}
-	return val
-}
-
-// Int64ValueOrDefault parses a form value into an int64 type. If there is an
-// error, returns the error. If there is no value returns the default value.
-func Int64ValueOrDefault(r *http.Request, field string, def int64) (int64, error) {
-	if r.Form.Get(field) != "" {
-		value, err := strconv.ParseInt(r.Form.Get(field), 10, 64)
-		return value, err
-	}
-	return def, nil
-}
-
-// ArchiveOptions stores archive information for different operations.
-type ArchiveOptions struct {
-	Name string
-	Path string
-}
-
-type badParameterError struct {
-	param string
-}
-
-func (e badParameterError) Error() string {
-	return "bad parameter: " + e.param + "cannot be empty"
-}
-
-func (e badParameterError) InvalidParameter() {}
-
-// ArchiveFormValues parses form values and turns them into ArchiveOptions.
-// It fails if the archive name and path are not in the request.
-func ArchiveFormValues(r *http.Request, vars map[string]string) (ArchiveOptions, error) {
-	if err := ParseForm(r); err != nil {
-		return ArchiveOptions{}, err
-	}
-
-	name := vars["name"]
-	if name == "" {
-		return ArchiveOptions{}, badParameterError{"name"}
-	}
-	path := r.Form.Get("path")
-	if path == "" {
-		return ArchiveOptions{}, badParameterError{"path"}
-	}
-	return ArchiveOptions{name, path}, nil
-}
--- a/api/server/httputils/form_test.go
+++ b/api/server/httputils/form_test.go
@@ -1,105 +0,0 @@
-package httputils // import "github.com/docker/docker/api/server/httputils"
-
-import (
-	"net/http"
-	"net/url"
-	"testing"
-)
-
-func TestBoolValue(t *testing.T) {
-	cases := map[string]bool{
-		"":      false,
-		"0":     false,
-		"no":    false,
-		"false": false,
-		"none":  false,
-		"1":     true,
-		"yes":   true,
-		"true":  true,
-		"one":   true,
-		"100":   true,
-	}
-
-	for c, e := range cases {
-		v := url.Values{}
-		v.Set("test", c)
-		r, _ := http.NewRequest(http.MethodPost, "", nil)
-		r.Form = v
-
-		a := BoolValue(r, "test")
-		if a != e {
-			t.Fatalf("Value: %s, expected: %v, actual: %v", c, e, a)
-		}
-	}
-}
-
-func TestBoolValueOrDefault(t *testing.T) {
-	r, _ := http.NewRequest(http.MethodGet, "", nil)
-	if !BoolValueOrDefault(r, "queryparam", true) {
-		t.Fatal("Expected to get true default value, got false")
-	}
-
-	v := url.Values{}
-	v.Set("param", "")
-	r, _ = http.NewRequest(http.MethodGet, "", nil)
-	r.Form = v
-	if BoolValueOrDefault(r, "param", true) {
-		t.Fatal("Expected not to get true")
-	}
-}
-
-func TestInt64ValueOrZero(t *testing.T) {
-	cases := map[string]int64{
-		"":     0,
-		"asdf": 0,
-		"0":    0,
-		"1":    1,
-	}
-
-	for c, e := range cases {
-		v := url.Values{}
-		v.Set("test", c)
-		r, _ := http.NewRequest(http.MethodPost, "", nil)
-		r.Form = v
-
-		a := Int64ValueOrZero(r, "test")
-		if a != e {
-			t.Fatalf("Value: %s, expected: %v, actual: %v", c, e, a)
-		}
-	}
-}
-
-func TestInt64ValueOrDefault(t *testing.T) {
-	cases := map[string]int64{
-		"":   -1,
-		"-1": -1,
-		"42": 42,
-	}
-
-	for c, e := range cases {
-		v := url.Values{}
-		v.Set("test", c)
-		r, _ := http.NewRequest(http.MethodPost, "", nil)
-		r.Form = v
-
-		a, err := Int64ValueOrDefault(r, "test", -1)
-		if a != e {
-			t.Fatalf("Value: %s, expected: %v, actual: %v", c, e, a)
-		}
-		if err != nil {
-			t.Fatalf("Error should be nil, but received: %s", err)
-		}
-	}
-}
-
-func TestInt64ValueOrDefaultWithError(t *testing.T) {
-	v := url.Values{}
-	v.Set("test", "invalid")
-	r, _ := http.NewRequest(http.MethodPost, "", nil)
-	r.Form = v
-
-	_, err := Int64ValueOrDefault(r, "test", -1)
-	if err == nil {
-		t.Fatal("Expected an error.")
-	}
-}
--- a/api/server/httputils/httputils.go
+++ b/api/server/httputils/httputils.go
@@ -1,124 +0,0 @@
-package httputils // import "github.com/docker/docker/api/server/httputils"
-
-import (
-	"context"
-	"io"
-	"mime"
-	"net/http"
-	"strings"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/versions"
-	"github.com/docker/docker/errdefs"
-	"github.com/gorilla/mux"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	"google.golang.org/grpc/status"
-)
-
-// APIVersionKey is the client's requested API version.
-type APIVersionKey struct{}
-
-// APIFunc is an adapter to allow the use of ordinary functions as Docker API endpoints.
-// Any function that has the appropriate signature can be registered as an API endpoint (e.g. getVersion).
-type APIFunc func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error
-
-// HijackConnection interrupts the http response writer to get the
-// underlying connection and operate with it.
-func HijackConnection(w http.ResponseWriter) (io.ReadCloser, io.Writer, error) {
-	conn, _, err := w.(http.Hijacker).Hijack()
-	if err != nil {
-		return nil, nil, err
-	}
-	// Flush the options to make sure the client sets the raw mode
-	_, _ = conn.Write([]byte{})
-	return conn, conn, nil
-}
-
-// CloseStreams ensures that a list for http streams are properly closed.
-func CloseStreams(streams ...interface{}) {
-	for _, stream := range streams {
-		if tcpc, ok := stream.(interface {
-			CloseWrite() error
-		}); ok {
-			_ = tcpc.CloseWrite()
-		} else if closer, ok := stream.(io.Closer); ok {
-			_ = closer.Close()
-		}
-	}
-}
-
-// CheckForJSON makes sure that the request's Content-Type is application/json.
-func CheckForJSON(r *http.Request) error {
-	ct := r.Header.Get("Content-Type")
-
-	// No Content-Type header is ok as long as there's no Body
-	if ct == "" {
-		if r.Body == nil || r.ContentLength == 0 {
-			return nil
-		}
-	}
-
-	// Otherwise it better be json
-	if matchesContentType(ct, "application/json") {
-		return nil
-	}
-	return errdefs.InvalidParameter(errors.Errorf("Content-Type specified (%s) must be 'application/json'", ct))
-}
-
-// ParseForm ensures the request form is parsed even with invalid content types.
-// If we don't do this, POST method without Content-type (even with empty body) will fail.
-func ParseForm(r *http.Request) error {
-	if r == nil {
-		return nil
-	}
-	if err := r.ParseForm(); err != nil && !strings.HasPrefix(err.Error(), "mime:") {
-		return errdefs.InvalidParameter(err)
-	}
-	return nil
-}
-
-// VersionFromContext returns an API version from the context using APIVersionKey.
-// It panics if the context value does not have version.Version type.
-func VersionFromContext(ctx context.Context) string {
-	if ctx == nil {
-		return ""
-	}
-
-	if val := ctx.Value(APIVersionKey{}); val != nil {
-		return val.(string)
-	}
-
-	return ""
-}
-
-// MakeErrorHandler makes an HTTP handler that decodes a Docker error and
-// returns it in the response.
-func MakeErrorHandler(err error) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		statusCode := errdefs.GetHTTPErrorStatusCode(err)
-		vars := mux.Vars(r)
-		if apiVersionSupportsJSONErrors(vars["version"]) {
-			response := &types.ErrorResponse{
-				Message: err.Error(),
-			}
-			_ = WriteJSON(w, statusCode, response)
-		} else {
-			http.Error(w, status.Convert(err).Message(), statusCode)
-		}
-	}
-}
-
-func apiVersionSupportsJSONErrors(version string) bool {
-	const firstAPIVersionWithJSONErrors = "1.23"
-	return version == "" || versions.GreaterThan(version, firstAPIVersionWithJSONErrors)
-}
-
-// matchesContentType validates the content type against the expected one
-func matchesContentType(contentType, expectedType string) bool {
-	mimetype, _, err := mime.ParseMediaType(contentType)
-	if err != nil {
-		logrus.Errorf("Error parsing media type: %s error: %v", contentType, err)
-	}
-	return err == nil && mimetype == expectedType
-}
--- a/api/server/httputils/httputils_test.go
+++ b/api/server/httputils/httputils_test.go
@@ -1,18 +0,0 @@
-package httputils // import "github.com/docker/docker/api/server/httputils"
-
-import "testing"
-
-// matchesContentType
-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/server/httputils/httputils_write_json.go
+++ b/api/server/httputils/httputils_write_json.go
@@ -1,15 +0,0 @@
-package httputils // import "github.com/docker/docker/api/server/httputils"
-
-import (
-	"encoding/json"
-	"net/http"
-)
-
-// WriteJSON writes the value v to the http response stream as json with standard json encoding.
-func WriteJSON(w http.ResponseWriter, code int, v interface{}) error {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(code)
-	enc := json.NewEncoder(w)
-	enc.SetEscapeHTML(false)
-	return enc.Encode(v)
-}
--- a/api/server/httputils/write_log_stream.go
+++ b/api/server/httputils/write_log_stream.go
@@ -1,84 +0,0 @@
-package httputils // import "github.com/docker/docker/api/server/httputils"
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net/url"
-	"sort"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/backend"
-	"github.com/docker/docker/pkg/ioutils"
-	"github.com/docker/docker/pkg/jsonmessage"
-	"github.com/docker/docker/pkg/stdcopy"
-)
-
-// WriteLogStream writes an encoded byte stream of log messages from the
-// messages channel, multiplexing them with a stdcopy.Writer if mux is true
-func WriteLogStream(_ context.Context, w io.Writer, msgs <-chan *backend.LogMessage, config *types.ContainerLogsOptions, mux bool) {
-	wf := ioutils.NewWriteFlusher(w)
-	defer wf.Close()
-
-	wf.Flush()
-
-	outStream := io.Writer(wf)
-	errStream := outStream
-	sysErrStream := errStream
-	if mux {
-		sysErrStream = stdcopy.NewStdWriter(outStream, stdcopy.Systemerr)
-		errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
-		outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
-	}
-
-	for {
-		msg, ok := <-msgs
-		if !ok {
-			return
-		}
-		// check if the message contains an error. if so, write that error
-		// and exit
-		if msg.Err != nil {
-			fmt.Fprintf(sysErrStream, "Error grabbing logs: %v\n", msg.Err)
-			continue
-		}
-		logLine := msg.Line
-		if config.Details {
-			logLine = append(attrsByteSlice(msg.Attrs), ' ')
-			logLine = append(logLine, msg.Line...)
-		}
-		if config.Timestamps {
-			logLine = append([]byte(msg.Timestamp.Format(jsonmessage.RFC3339NanoFixed)+" "), logLine...)
-		}
-		if msg.Source == "stdout" && config.ShowStdout {
-			_, _ = outStream.Write(logLine)
-		}
-		if msg.Source == "stderr" && config.ShowStderr {
-			_, _ = errStream.Write(logLine)
-		}
-	}
-}
-
-type byKey []backend.LogAttr
-
-func (b byKey) Len() int           { return len(b) }
-func (b byKey) Less(i, j int) bool { return b[i].Key < b[j].Key }
-func (b byKey) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
-
-func attrsByteSlice(a []backend.LogAttr) []byte {
-	// Note this sorts "a" in-place. That is fine here - nothing else is
-	// going to use Attrs or care about the order.
-	sort.Sort(byKey(a))
-
-	var ret []byte
-	for i, pair := range a {
-		k, v := url.QueryEscape(pair.Key), url.QueryEscape(pair.Value)
-		ret = append(ret, []byte(k)...)
-		ret = append(ret, '=')
-		ret = append(ret, []byte(v)...)
-		if i != len(a)-1 {
-			ret = append(ret, ',')
-		}
-	}
-	return ret
-}
--- a/api/server/middleware.go
+++ b/api/server/middleware.go
@@ -1,24 +0,0 @@
-package server // import "github.com/docker/docker/api/server"
-
-import (
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/server/middleware"
-	"github.com/sirupsen/logrus"
-)
-
-// handlerWithGlobalMiddlewares wraps the handler function for a request with
-// the server's global middlewares. The order of the middlewares is backwards,
-// meaning that the first in the list will be evaluated last.
-func (s *Server) handlerWithGlobalMiddlewares(handler httputils.APIFunc) httputils.APIFunc {
-	next := handler
-
-	for _, m := range s.middlewares {
-		next = m.WrapHandler(next)
-	}
-
-	if s.cfg.Logging && logrus.GetLevel() == logrus.DebugLevel {
-		next = middleware.DebugRequestMiddleware(next)
-	}
-
-	return next
-}
--- a/api/server/middleware/cors.go
+++ b/api/server/middleware/cors.go
@@ -1,37 +0,0 @@
-package middleware // import "github.com/docker/docker/api/server/middleware"
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/sirupsen/logrus"
-)
-
-// CORSMiddleware injects CORS headers to each request
-// when it's configured.
-type CORSMiddleware struct {
-	defaultHeaders string
-}
-
-// NewCORSMiddleware creates a new CORSMiddleware with default headers.
-func NewCORSMiddleware(d string) CORSMiddleware {
-	return CORSMiddleware{defaultHeaders: d}
-}
-
-// WrapHandler returns a new handler function wrapping the previous one in the request chain.
-func (c CORSMiddleware) WrapHandler(handler func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error) func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	return func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-		// If "api-cors-header" is not given, but "api-enable-cors" is true, we set cors to "*"
-		// otherwise, all head values will be passed to HTTP handler
-		corsHeaders := c.defaultHeaders
-		if corsHeaders == "" {
-			corsHeaders = "*"
-		}
-
-		logrus.Debugf("CORS header is enabled and set to: %s", corsHeaders)
-		w.Header().Add("Access-Control-Allow-Origin", corsHeaders)
-		w.Header().Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, X-Registry-Auth")
-		w.Header().Add("Access-Control-Allow-Methods", "HEAD, GET, POST, DELETE, PUT, OPTIONS")
-		return handler(ctx, w, r, vars)
-	}
-}
--- a/api/server/middleware/debug.go
+++ b/api/server/middleware/debug.go
@@ -1,90 +0,0 @@
-package middleware // import "github.com/docker/docker/api/server/middleware"
-
-import (
-	"bufio"
-	"context"
-	"encoding/json"
-	"io"
-	"net/http"
-	"strings"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/pkg/ioutils"
-	"github.com/sirupsen/logrus"
-)
-
-// DebugRequestMiddleware dumps the request to logger
-func DebugRequestMiddleware(handler func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error) func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	return func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-		logrus.Debugf("Calling %s %s", r.Method, r.RequestURI)
-
-		if r.Method != http.MethodPost {
-			return handler(ctx, w, r, vars)
-		}
-		if err := httputils.CheckForJSON(r); err != nil {
-			return handler(ctx, w, r, vars)
-		}
-		maxBodySize := 4096 // 4KB
-		if r.ContentLength > int64(maxBodySize) {
-			return handler(ctx, w, r, vars)
-		}
-
-		body := r.Body
-		bufReader := bufio.NewReaderSize(body, maxBodySize)
-		r.Body = ioutils.NewReadCloserWrapper(bufReader, func() error { return body.Close() })
-
-		b, err := bufReader.Peek(maxBodySize)
-		if err != io.EOF {
-			// either there was an error reading, or the buffer is full (in which case the request is too large)
-			return handler(ctx, w, r, vars)
-		}
-
-		var postForm map[string]interface{}
-		if err := json.Unmarshal(b, &postForm); err == nil {
-			maskSecretKeys(postForm)
-			formStr, errMarshal := json.Marshal(postForm)
-			if errMarshal == nil {
-				logrus.Debugf("form data: %s", string(formStr))
-			} else {
-				logrus.Debugf("form data: %q", postForm)
-			}
-		}
-
-		return handler(ctx, w, r, vars)
-	}
-}
-
-func maskSecretKeys(inp interface{}) {
-	if arr, ok := inp.([]interface{}); ok {
-		for _, f := range arr {
-			maskSecretKeys(f)
-		}
-		return
-	}
-
-	if form, ok := inp.(map[string]interface{}); ok {
-		scrub := []string{
-			// Note: The Data field contains the base64-encoded secret in 'secret'
-			// and 'config' create and update requests. Currently, no other POST
-			// API endpoints use a data field, so we scrub this field unconditionally.
-			// Change this handling to be conditional if a new endpoint is added
-			// in future where this field should not be scrubbed.
-			"data",
-			"jointoken",
-			"password",
-			"secret",
-			"signingcakey",
-			"unlockkey",
-		}
-	loop0:
-		for k, v := range form {
-			for _, m := range scrub {
-				if strings.EqualFold(m, k) {
-					form[k] = "*****"
-					continue loop0
-				}
-			}
-			maskSecretKeys(v)
-		}
-	}
-}
--- a/api/server/middleware/debug_test.go
+++ b/api/server/middleware/debug_test.go
@@ -1,75 +0,0 @@
-package middleware // import "github.com/docker/docker/api/server/middleware"
-
-import (
-	"testing"
-
-	"gotest.tools/v3/assert"
-	is "gotest.tools/v3/assert/cmp"
-)
-
-func TestMaskSecretKeys(t *testing.T) {
-	tests := []struct {
-		doc      string
-		input    map[string]interface{}
-		expected map[string]interface{}
-	}{
-		{
-			doc:      "secret/config create and update requests",
-			input:    map[string]interface{}{"Data": "foo", "Name": "name", "Labels": map[string]interface{}{}},
-			expected: map[string]interface{}{"Data": "*****", "Name": "name", "Labels": map[string]interface{}{}},
-		},
-		{
-			doc: "masking other fields (recursively)",
-			input: map[string]interface{}{
-				"password":     "pass",
-				"secret":       "secret",
-				"jointoken":    "jointoken",
-				"unlockkey":    "unlockkey",
-				"signingcakey": "signingcakey",
-				"other": map[string]interface{}{
-					"password":     "pass",
-					"secret":       "secret",
-					"jointoken":    "jointoken",
-					"unlockkey":    "unlockkey",
-					"signingcakey": "signingcakey",
-				},
-			},
-			expected: map[string]interface{}{
-				"password":     "*****",
-				"secret":       "*****",
-				"jointoken":    "*****",
-				"unlockkey":    "*****",
-				"signingcakey": "*****",
-				"other": map[string]interface{}{
-					"password":     "*****",
-					"secret":       "*****",
-					"jointoken":    "*****",
-					"unlockkey":    "*****",
-					"signingcakey": "*****",
-				},
-			},
-		},
-		{
-			doc: "case insensitive field matching",
-			input: map[string]interface{}{
-				"PASSWORD": "pass",
-				"other": map[string]interface{}{
-					"PASSWORD": "pass",
-				},
-			},
-			expected: map[string]interface{}{
-				"PASSWORD": "*****",
-				"other": map[string]interface{}{
-					"PASSWORD": "*****",
-				},
-			},
-		},
-	}
-
-	for _, testcase := range tests {
-		t.Run(testcase.doc, func(t *testing.T) {
-			maskSecretKeys(testcase.input)
-			assert.Check(t, is.DeepEqual(testcase.expected, testcase.input))
-		})
-	}
-}
--- a/api/server/middleware/experimental.go
+++ b/api/server/middleware/experimental.go
@@ -1,28 +0,0 @@
-package middleware // import "github.com/docker/docker/api/server/middleware"
-
-import (
-	"context"
-	"net/http"
-)
-
-// ExperimentalMiddleware is a the middleware in charge of adding the
-// 'Docker-Experimental' header to every outgoing request
-type ExperimentalMiddleware struct {
-	experimental string
-}
-
-// NewExperimentalMiddleware creates a new ExperimentalMiddleware
-func NewExperimentalMiddleware(experimentalEnabled bool) ExperimentalMiddleware {
-	if experimentalEnabled {
-		return ExperimentalMiddleware{"true"}
-	}
-	return ExperimentalMiddleware{"false"}
-}
-
-// WrapHandler returns a new handler function wrapping the previous one in the request chain.
-func (e ExperimentalMiddleware) WrapHandler(handler func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error) func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	return func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-		w.Header().Set("Docker-Experimental", e.experimental)
-		return handler(ctx, w, r, vars)
-	}
-}
--- a/api/server/middleware/middleware.go
+++ b/api/server/middleware/middleware.go
@@ -1,12 +0,0 @@
-package middleware // import "github.com/docker/docker/api/server/middleware"
-
-import (
-	"context"
-	"net/http"
-)
-
-// Middleware is an interface to allow the use of ordinary functions as Docker API filters.
-// Any struct that has the appropriate signature can be registered as a middleware.
-type Middleware interface {
-	WrapHandler(func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error) func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error
-}
--- a/api/server/middleware/version.go
+++ b/api/server/middleware/version.go
@@ -1,65 +0,0 @@
-package middleware // import "github.com/docker/docker/api/server/middleware"
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"runtime"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types/versions"
-)
-
-// VersionMiddleware is a middleware that
-// validates the client and server versions.
-type VersionMiddleware struct {
-	serverVersion  string
-	defaultVersion string
-	minVersion     string
-}
-
-// NewVersionMiddleware creates a new VersionMiddleware
-// with the default versions.
-func NewVersionMiddleware(s, d, m string) VersionMiddleware {
-	return VersionMiddleware{
-		serverVersion:  s,
-		defaultVersion: d,
-		minVersion:     m,
-	}
-}
-
-type versionUnsupportedError struct {
-	version, minVersion, maxVersion string
-}
-
-func (e versionUnsupportedError) Error() string {
-	if e.minVersion != "" {
-		return fmt.Sprintf("client version %s is too old. Minimum supported API version is %s, please upgrade your client to a newer version", e.version, e.minVersion)
-	}
-	return fmt.Sprintf("client version %s is too new. Maximum supported API version is %s", e.version, e.maxVersion)
-}
-
-func (e versionUnsupportedError) InvalidParameter() {}
-
-// WrapHandler returns a new handler function wrapping the previous one in the request chain.
-func (v VersionMiddleware) WrapHandler(handler func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error) func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	return func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-		w.Header().Set("Server", fmt.Sprintf("Docker/%s (%s)", v.serverVersion, runtime.GOOS))
-		w.Header().Set("API-Version", v.defaultVersion)
-		w.Header().Set("OSType", runtime.GOOS)
-
-		apiVersion := vars["version"]
-		if apiVersion == "" {
-			apiVersion = v.defaultVersion
-		}
-		if versions.LessThan(apiVersion, v.minVersion) {
-			return versionUnsupportedError{version: apiVersion, minVersion: v.minVersion}
-		}
-		if versions.GreaterThan(apiVersion, v.defaultVersion) {
-			return versionUnsupportedError{version: apiVersion, maxVersion: v.defaultVersion}
-		}
-		ctx = context.WithValue(ctx, httputils.APIVersionKey{}, apiVersion)
-		return handler(ctx, w, r, vars)
-	}
-
-}
--- a/api/server/middleware/version_test.go
+++ b/api/server/middleware/version_test.go
@@ -1,92 +0,0 @@
-package middleware // import "github.com/docker/docker/api/server/middleware"
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"runtime"
-	"testing"
-
-	"github.com/docker/docker/api/server/httputils"
-	"gotest.tools/v3/assert"
-	is "gotest.tools/v3/assert/cmp"
-)
-
-func TestVersionMiddlewareVersion(t *testing.T) {
-	defaultVersion := "1.10.0"
-	minVersion := "1.2.0"
-	expectedVersion := defaultVersion
-	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-		v := httputils.VersionFromContext(ctx)
-		assert.Check(t, is.Equal(expectedVersion, v))
-		return nil
-	}
-
-	m := NewVersionMiddleware(defaultVersion, defaultVersion, minVersion)
-	h := m.WrapHandler(handler)
-
-	req, _ := http.NewRequest(http.MethodGet, "/containers/json", nil)
-	resp := httptest.NewRecorder()
-	ctx := context.Background()
-
-	tests := []struct {
-		reqVersion      string
-		expectedVersion string
-		errString       string
-	}{
-		{
-			expectedVersion: "1.10.0",
-		},
-		{
-			reqVersion:      "1.9.0",
-			expectedVersion: "1.9.0",
-		},
-		{
-			reqVersion: "0.1",
-			errString:  "client version 0.1 is too old. Minimum supported API version is 1.2.0, please upgrade your client to a newer version",
-		},
-		{
-			reqVersion: "9999.9999",
-			errString:  "client version 9999.9999 is too new. Maximum supported API version is 1.10.0",
-		},
-	}
-
-	for _, test := range tests {
-		expectedVersion = test.expectedVersion
-
-		err := h(ctx, resp, req, map[string]string{"version": test.reqVersion})
-
-		if test.errString != "" {
-			assert.Check(t, is.Error(err, test.errString))
-		} else {
-			assert.Check(t, err)
-		}
-	}
-}
-
-func TestVersionMiddlewareWithErrorsReturnsHeaders(t *testing.T) {
-	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-		v := httputils.VersionFromContext(ctx)
-		assert.Check(t, len(v) != 0)
-		return nil
-	}
-
-	defaultVersion := "1.10.0"
-	minVersion := "1.2.0"
-	m := NewVersionMiddleware(defaultVersion, defaultVersion, minVersion)
-	h := m.WrapHandler(handler)
-
-	req, _ := http.NewRequest(http.MethodGet, "/containers/json", nil)
-	resp := httptest.NewRecorder()
-	ctx := context.Background()
-
-	vars := map[string]string{"version": "0.1"}
-	err := h(ctx, resp, req, vars)
-	assert.Check(t, is.ErrorContains(err, ""))
-
-	hdr := resp.Result().Header
-	assert.Check(t, is.Contains(hdr.Get("Server"), "Docker/"+defaultVersion))
-	assert.Check(t, is.Contains(hdr.Get("Server"), runtime.GOOS))
-	assert.Check(t, is.Equal(hdr.Get("API-Version"), defaultVersion))
-	assert.Check(t, is.Equal(hdr.Get("OSType"), runtime.GOOS))
-}
--- a/api/server/router/build/backend.go
+++ b/api/server/router/build/backend.go
@@ -1,24 +0,0 @@
-package build // import "github.com/docker/docker/api/server/router/build"
-
-import (
-	"context"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/backend"
-)
-
-// Backend abstracts an image builder whose only purpose is to build an image referenced by an imageID.
-type Backend interface {
-	// Build a Docker image returning the id of the image
-	// TODO: make this return a reference instead of string
-	Build(context.Context, backend.BuildConfig) (string, error)
-
-	// Prune build cache
-	PruneCache(context.Context, types.BuildCachePruneOptions) (*types.BuildCachePruneReport, error)
-
-	Cancel(context.Context, string) error
-}
-
-type experimentalProvider interface {
-	HasExperimental() bool
-}
--- a/api/server/router/build/build.go
+++ b/api/server/router/build/build.go
@@ -1,53 +0,0 @@
-package build // import "github.com/docker/docker/api/server/router/build"
-
-import (
-	"github.com/docker/docker/api/server/router"
-	"github.com/docker/docker/api/types"
-)
-
-// buildRouter is a router to talk with the build controller
-type buildRouter struct {
-	backend  Backend
-	daemon   experimentalProvider
-	routes   []router.Route
-	features *map[string]bool
-}
-
-// NewRouter initializes a new build router
-func NewRouter(b Backend, d experimentalProvider, features *map[string]bool) router.Router {
-	r := &buildRouter{
-		backend:  b,
-		daemon:   d,
-		features: features,
-	}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routers to the build controller
-func (r *buildRouter) Routes() []router.Route {
-	return r.routes
-}
-
-func (r *buildRouter) initRoutes() {
-	r.routes = []router.Route{
-		router.NewPostRoute("/build", r.postBuild),
-		router.NewPostRoute("/build/prune", r.postPrune),
-		router.NewPostRoute("/build/cancel", r.postCancel),
-	}
-}
-
-// BuilderVersion derives the default docker builder version from the config
-// Note: it is valid to have BuilderVersion unset which means it is up to the
-// client to choose which builder to use.
-func BuilderVersion(features map[string]bool) types.BuilderVersion {
-	var bv types.BuilderVersion
-	if v, ok := features["buildkit"]; ok {
-		if v {
-			bv = types.BuilderBuildKit
-		} else {
-			bv = types.BuilderV1
-		}
-	}
-	return bv
-}
--- a/api/server/router/build/build_routes.go
+++ b/api/server/router/build/build_routes.go
@@ -1,440 +0,0 @@
-package build // import "github.com/docker/docker/api/server/router/build"
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/backend"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/versions"
-	"github.com/docker/docker/errdefs"
-	"github.com/docker/docker/pkg/ioutils"
-	"github.com/docker/docker/pkg/progress"
-	"github.com/docker/docker/pkg/streamformatter"
-	units "github.com/docker/go-units"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-)
-
-type invalidIsolationError string
-
-func (e invalidIsolationError) Error() string {
-	return fmt.Sprintf("Unsupported isolation: %q", string(e))
-}
-
-func (e invalidIsolationError) InvalidParameter() {}
-
-func newImageBuildOptions(ctx context.Context, r *http.Request) (*types.ImageBuildOptions, error) {
-	options := &types.ImageBuildOptions{
-		Version:        types.BuilderV1, // Builder V1 is the default, but can be overridden
-		Dockerfile:     r.FormValue("dockerfile"),
-		SuppressOutput: httputils.BoolValue(r, "q"),
-		NoCache:        httputils.BoolValue(r, "nocache"),
-		ForceRemove:    httputils.BoolValue(r, "forcerm"),
-		MemorySwap:     httputils.Int64ValueOrZero(r, "memswap"),
-		Memory:         httputils.Int64ValueOrZero(r, "memory"),
-		CPUShares:      httputils.Int64ValueOrZero(r, "cpushares"),
-		CPUPeriod:      httputils.Int64ValueOrZero(r, "cpuperiod"),
-		CPUQuota:       httputils.Int64ValueOrZero(r, "cpuquota"),
-		CPUSetCPUs:     r.FormValue("cpusetcpus"),
-		CPUSetMems:     r.FormValue("cpusetmems"),
-		CgroupParent:   r.FormValue("cgroupparent"),
-		NetworkMode:    r.FormValue("networkmode"),
-		Tags:           r.Form["t"],
-		ExtraHosts:     r.Form["extrahosts"],
-		SecurityOpt:    r.Form["securityopt"],
-		Squash:         httputils.BoolValue(r, "squash"),
-		Target:         r.FormValue("target"),
-		RemoteContext:  r.FormValue("remote"),
-		SessionID:      r.FormValue("session"),
-		BuildID:        r.FormValue("buildid"),
-	}
-
-	if runtime.GOOS != "windows" && options.SecurityOpt != nil {
-		return nil, errdefs.InvalidParameter(errors.New("The daemon on this platform does not support setting security options on build"))
-	}
-
-	version := httputils.VersionFromContext(ctx)
-	if httputils.BoolValue(r, "forcerm") && versions.GreaterThanOrEqualTo(version, "1.12") {
-		options.Remove = true
-	} else if r.FormValue("rm") == "" && versions.GreaterThanOrEqualTo(version, "1.12") {
-		options.Remove = true
-	} else {
-		options.Remove = httputils.BoolValue(r, "rm")
-	}
-	if httputils.BoolValue(r, "pull") && versions.GreaterThanOrEqualTo(version, "1.16") {
-		options.PullParent = true
-	}
-	if versions.GreaterThanOrEqualTo(version, "1.32") {
-		options.Platform = r.FormValue("platform")
-	}
-	if versions.GreaterThanOrEqualTo(version, "1.40") {
-		outputsJSON := r.FormValue("outputs")
-		if outputsJSON != "" {
-			var outputs []types.ImageBuildOutput
-			if err := json.Unmarshal([]byte(outputsJSON), &outputs); err != nil {
-				return nil, err
-			}
-			options.Outputs = outputs
-		}
-	}
-
-	if s := r.Form.Get("shmsize"); s != "" {
-		shmSize, err := strconv.ParseInt(s, 10, 64)
-		if err != nil {
-			return nil, err
-		}
-		options.ShmSize = shmSize
-	}
-
-	if i := r.FormValue("isolation"); i != "" {
-		options.Isolation = container.Isolation(i)
-		if !options.Isolation.IsValid() {
-			return nil, invalidIsolationError(options.Isolation)
-		}
-	}
-
-	if ulimitsJSON := r.FormValue("ulimits"); ulimitsJSON != "" {
-		var buildUlimits = []*units.Ulimit{}
-		if err := json.Unmarshal([]byte(ulimitsJSON), &buildUlimits); err != nil {
-			return nil, errors.Wrap(errdefs.InvalidParameter(err), "error reading ulimit settings")
-		}
-		options.Ulimits = buildUlimits
-	}
-
-	// Note that there are two ways a --build-arg might appear in the
-	// json of the query param:
-	//     "foo":"bar"
-	// and "foo":nil
-	// The first is the normal case, ie. --build-arg foo=bar
-	// or  --build-arg foo
-	// where foo's value was picked up from an env var.
-	// The second ("foo":nil) is where they put --build-arg foo
-	// but "foo" isn't set as an env var. In that case we can't just drop
-	// the fact they mentioned it, we need to pass that along to the builder
-	// so that it can print a warning about "foo" being unused if there is
-	// no "ARG foo" in the Dockerfile.
-	if buildArgsJSON := r.FormValue("buildargs"); buildArgsJSON != "" {
-		var buildArgs = map[string]*string{}
-		if err := json.Unmarshal([]byte(buildArgsJSON), &buildArgs); err != nil {
-			return nil, errors.Wrap(errdefs.InvalidParameter(err), "error reading build args")
-		}
-		options.BuildArgs = buildArgs
-	}
-
-	if labelsJSON := r.FormValue("labels"); labelsJSON != "" {
-		var labels = map[string]string{}
-		if err := json.Unmarshal([]byte(labelsJSON), &labels); err != nil {
-			return nil, errors.Wrap(errdefs.InvalidParameter(err), "error reading labels")
-		}
-		options.Labels = labels
-	}
-
-	if cacheFromJSON := r.FormValue("cachefrom"); cacheFromJSON != "" {
-		var cacheFrom = []string{}
-		if err := json.Unmarshal([]byte(cacheFromJSON), &cacheFrom); err != nil {
-			return nil, err
-		}
-		options.CacheFrom = cacheFrom
-	}
-
-	if bv := r.FormValue("version"); bv != "" {
-		v, err := parseVersion(bv)
-		if err != nil {
-			return nil, err
-		}
-		options.Version = v
-	}
-
-	return options, nil
-}
-
-func parseVersion(s string) (types.BuilderVersion, error) {
-	switch types.BuilderVersion(s) {
-	case types.BuilderV1:
-		return types.BuilderV1, nil
-	case types.BuilderBuildKit:
-		return types.BuilderBuildKit, nil
-	default:
-		return "", errors.Errorf("invalid version %q", s)
-	}
-}
-
-func (br *buildRouter) postPrune(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	fltrs, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return errors.Wrap(err, "could not parse filters")
-	}
-	ksfv := r.FormValue("keep-storage")
-	if ksfv == "" {
-		ksfv = "0"
-	}
-	ks, err := strconv.Atoi(ksfv)
-	if err != nil {
-		return errors.Wrapf(err, "keep-storage is in bytes and expects an integer, got %v", ksfv)
-	}
-
-	opts := types.BuildCachePruneOptions{
-		All:         httputils.BoolValue(r, "all"),
-		Filters:     fltrs,
-		KeepStorage: int64(ks),
-	}
-
-	report, err := br.backend.PruneCache(ctx, opts)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, report)
-}
-
-func (br *buildRouter) postCancel(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	w.Header().Set("Content-Type", "application/json")
-
-	id := r.FormValue("id")
-	if id == "" {
-		return errors.Errorf("build ID not provided")
-	}
-
-	return br.backend.Cancel(ctx, id)
-}
-
-func (br *buildRouter) postBuild(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var (
-		notVerboseBuffer = bytes.NewBuffer(nil)
-		version          = httputils.VersionFromContext(ctx)
-	)
-
-	w.Header().Set("Content-Type", "application/json")
-
-	body := r.Body
-	var ww io.Writer = w
-	if body != nil {
-		// there is a possibility that output is written before request body
-		// has been fully read so we need to protect against it.
-		// this can be removed when
-		// https://github.com/golang/go/issues/15527
-		// https://github.com/golang/go/issues/22209
-		// has been fixed
-		body, ww = wrapOutputBufferedUntilRequestRead(body, ww)
-	}
-
-	output := ioutils.NewWriteFlusher(ww)
-	defer func() { _ = output.Close() }()
-
-	errf := func(err error) error {
-
-		if httputils.BoolValue(r, "q") && notVerboseBuffer.Len() > 0 {
-			_, _ = output.Write(notVerboseBuffer.Bytes())
-		}
-
-		// Do not write the error in the http output if it's still empty.
-		// This prevents from writing a 200(OK) when there is an internal error.
-		if !output.Flushed() {
-			return err
-		}
-		_, err = output.Write(streamformatter.FormatError(err))
-		if err != nil {
-			logrus.Warnf("could not write error response: %v", err)
-		}
-		return nil
-	}
-
-	buildOptions, err := newImageBuildOptions(ctx, r)
-	if err != nil {
-		return errf(err)
-	}
-	buildOptions.AuthConfigs = getAuthConfigs(r.Header)
-
-	if buildOptions.Squash && !br.daemon.HasExperimental() {
-		return errdefs.InvalidParameter(errors.New("squash is only supported with experimental mode"))
-	}
-
-	out := io.Writer(output)
-	if buildOptions.SuppressOutput {
-		out = notVerboseBuffer
-	}
-
-	// Currently, only used if context is from a remote url.
-	// Look at code in DetectContextFromRemoteURL for more information.
-	createProgressReader := func(in io.ReadCloser) io.ReadCloser {
-		progressOutput := streamformatter.NewJSONProgressOutput(out, true)
-		return progress.NewProgressReader(in, progressOutput, r.ContentLength, "Downloading context", buildOptions.RemoteContext)
-	}
-
-	wantAux := versions.GreaterThanOrEqualTo(version, "1.30")
-
-	imgID, err := br.backend.Build(ctx, backend.BuildConfig{
-		Source:         body,
-		Options:        buildOptions,
-		ProgressWriter: buildProgressWriter(out, wantAux, createProgressReader),
-	})
-	if err != nil {
-		return errf(err)
-	}
-
-	// 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 buildOptions.SuppressOutput {
-		_, _ = fmt.Fprintln(streamformatter.NewStdoutWriter(output), imgID)
-	}
-	return nil
-}
-
-func getAuthConfigs(header http.Header) map[string]types.AuthConfig {
-	authConfigs := map[string]types.AuthConfig{}
-	authConfigsEncoded := header.Get("X-Registry-Config")
-
-	if authConfigsEncoded == "" {
-		return authConfigs
-	}
-
-	authConfigsJSON := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authConfigsEncoded))
-	// Pulling an image does not error when no auth is provided so to remain
-	// consistent with the existing api decode errors are ignored
-	_ = json.NewDecoder(authConfigsJSON).Decode(&authConfigs)
-	return authConfigs
-}
-
-type syncWriter struct {
-	w  io.Writer
-	mu sync.Mutex
-}
-
-func (s *syncWriter) Write(b []byte) (count int, err error) {
-	s.mu.Lock()
-	count, err = s.w.Write(b)
-	s.mu.Unlock()
-	return
-}
-
-func buildProgressWriter(out io.Writer, wantAux bool, createProgressReader func(io.ReadCloser) io.ReadCloser) backend.ProgressWriter {
-	out = &syncWriter{w: out}
-
-	var aux *streamformatter.AuxFormatter
-	if wantAux {
-		aux = &streamformatter.AuxFormatter{Writer: out}
-	}
-
-	return backend.ProgressWriter{
-		Output:             out,
-		StdoutFormatter:    streamformatter.NewStdoutWriter(out),
-		StderrFormatter:    streamformatter.NewStderrWriter(out),
-		AuxFormatter:       aux,
-		ProgressReaderFunc: createProgressReader,
-	}
-}
-
-type flusher interface {
-	Flush()
-}
-
-func wrapOutputBufferedUntilRequestRead(rc io.ReadCloser, out io.Writer) (io.ReadCloser, io.Writer) {
-	var fl flusher = &ioutils.NopFlusher{}
-	if f, ok := out.(flusher); ok {
-		fl = f
-	}
-
-	w := &wcf{
-		buf:     bytes.NewBuffer(nil),
-		Writer:  out,
-		flusher: fl,
-	}
-	r := bufio.NewReader(rc)
-	_, err := r.Peek(1)
-	if err != nil {
-		return rc, out
-	}
-	rc = &rcNotifier{
-		Reader: r,
-		Closer: rc,
-		notify: w.notify,
-	}
-	return rc, w
-}
-
-type rcNotifier struct {
-	io.Reader
-	io.Closer
-	notify func()
-}
-
-func (r *rcNotifier) Read(b []byte) (int, error) {
-	n, err := r.Reader.Read(b)
-	if err != nil {
-		r.notify()
-	}
-	return n, err
-}
-
-func (r *rcNotifier) Close() error {
-	r.notify()
-	return r.Closer.Close()
-}
-
-type wcf struct {
-	io.Writer
-	flusher
-	mu      sync.Mutex
-	ready   bool
-	buf     *bytes.Buffer
-	flushed bool
-}
-
-func (w *wcf) Flush() {
-	w.mu.Lock()
-	w.flushed = true
-	if !w.ready {
-		w.mu.Unlock()
-		return
-	}
-	w.mu.Unlock()
-	w.flusher.Flush()
-}
-
-func (w *wcf) Flushed() bool {
-	w.mu.Lock()
-	b := w.flushed
-	w.mu.Unlock()
-	return b
-}
-
-func (w *wcf) Write(b []byte) (int, error) {
-	w.mu.Lock()
-	if !w.ready {
-		n, err := w.buf.Write(b)
-		w.mu.Unlock()
-		return n, err
-	}
-	w.mu.Unlock()
-	return w.Writer.Write(b)
-}
-
-func (w *wcf) notify() {
-	w.mu.Lock()
-	if !w.ready {
-		if w.buf.Len() > 0 {
-			_, _ = io.Copy(w.Writer, w.buf)
-		}
-		if w.flushed {
-			w.flusher.Flush()
-		}
-		w.ready = true
-	}
-	w.mu.Unlock()
-}
--- a/api/server/router/checkpoint/backend.go
+++ b/api/server/router/checkpoint/backend.go
@@ -1,10 +0,0 @@
-package checkpoint // import "github.com/docker/docker/api/server/router/checkpoint"
-
-import "github.com/docker/docker/api/types"
-
-// Backend for Checkpoint
-type Backend interface {
-	CheckpointCreate(container string, config types.CheckpointCreateOptions) error
-	CheckpointDelete(container string, config types.CheckpointDeleteOptions) error
-	CheckpointList(container string, config types.CheckpointListOptions) ([]types.Checkpoint, error)
-}
--- a/api/server/router/checkpoint/checkpoint.go
+++ b/api/server/router/checkpoint/checkpoint.go
@@ -1,36 +0,0 @@
-package checkpoint // import "github.com/docker/docker/api/server/router/checkpoint"
-
-import (
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/server/router"
-)
-
-// checkpointRouter is a router to talk with the checkpoint controller
-type checkpointRouter struct {
-	backend Backend
-	decoder httputils.ContainerDecoder
-	routes  []router.Route
-}
-
-// NewRouter initializes a new checkpoint router
-func NewRouter(b Backend, decoder httputils.ContainerDecoder) router.Router {
-	r := &checkpointRouter{
-		backend: b,
-		decoder: decoder,
-	}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routers to the checkpoint controller
-func (r *checkpointRouter) Routes() []router.Route {
-	return r.routes
-}
-
-func (r *checkpointRouter) initRoutes() {
-	r.routes = []router.Route{
-		router.NewGetRoute("/containers/{name:.*}/checkpoints", r.getContainerCheckpoints, router.Experimental),
-		router.NewPostRoute("/containers/{name:.*}/checkpoints", r.postContainerCheckpoint, router.Experimental),
-		router.NewDeleteRoute("/containers/{name}/checkpoints/{checkpoint}", r.deleteContainerCheckpoint, router.Experimental),
-	}
-}
--- a/api/server/router/checkpoint/checkpoint_routes.go
+++ b/api/server/router/checkpoint/checkpoint_routes.go
@@ -1,65 +0,0 @@
-package checkpoint // import "github.com/docker/docker/api/server/router/checkpoint"
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types"
-)
-
-func (s *checkpointRouter) postContainerCheckpoint(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	var options types.CheckpointCreateOptions
-
-	decoder := json.NewDecoder(r.Body)
-	if err := decoder.Decode(&options); err != nil {
-		return err
-	}
-
-	err := s.backend.CheckpointCreate(vars["name"], options)
-	if err != nil {
-		return err
-	}
-
-	w.WriteHeader(http.StatusCreated)
-	return nil
-}
-
-func (s *checkpointRouter) getContainerCheckpoints(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	checkpoints, err := s.backend.CheckpointList(vars["name"], types.CheckpointListOptions{
-		CheckpointDir: r.Form.Get("dir"),
-	})
-
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, checkpoints)
-}
-
-func (s *checkpointRouter) deleteContainerCheckpoint(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	err := s.backend.CheckpointDelete(vars["name"], types.CheckpointDeleteOptions{
-		CheckpointDir: r.Form.Get("dir"),
-		CheckpointID:  vars["checkpoint"],
-	})
-
-	if err != nil {
-		return err
-	}
-
-	w.WriteHeader(http.StatusNoContent)
-	return nil
-}
--- a/api/server/router/container/backend.go
+++ b/api/server/router/container/backend.go
@@ -1,83 +0,0 @@
-package container // import "github.com/docker/docker/api/server/router/container"
-
-import (
-	"context"
-	"io"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/backend"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/filters"
-	containerpkg "github.com/docker/docker/container"
-	"github.com/docker/docker/pkg/archive"
-)
-
-// execBackend includes functions to implement to provide exec functionality.
-type execBackend interface {
-	ContainerExecCreate(name string, config *types.ExecConfig) (string, error)
-	ContainerExecInspect(id string) (*backend.ExecInspect, error)
-	ContainerExecResize(name string, height, width int) error
-	ContainerExecStart(ctx context.Context, name string, stdin io.Reader, stdout io.Writer, stderr io.Writer) error
-	ExecExists(name string) (bool, error)
-}
-
-// copyBackend includes functions to implement to provide container copy functionality.
-type copyBackend interface {
-	ContainerArchivePath(name string, path string) (content io.ReadCloser, stat *types.ContainerPathStat, err error)
-	ContainerCopy(name string, res string) (io.ReadCloser, error)
-	ContainerExport(name string, out io.Writer) error
-	ContainerExtractToDir(name, path string, copyUIDGID, noOverwriteDirNonDir bool, content io.Reader) error
-	ContainerStatPath(name string, path string) (stat *types.ContainerPathStat, err error)
-}
-
-// stateBackend includes functions to implement to provide container state lifecycle functionality.
-type stateBackend interface {
-	ContainerCreate(config types.ContainerCreateConfig) (container.ContainerCreateCreatedBody, error)
-	ContainerKill(name string, sig uint64) error
-	ContainerPause(name string) error
-	ContainerRename(oldName, newName string) error
-	ContainerResize(name string, height, width int) error
-	ContainerRestart(name string, seconds *int) error
-	ContainerRm(name string, config *types.ContainerRmConfig) error
-	ContainerStart(name string, hostConfig *container.HostConfig, checkpoint string, checkpointDir string) error
-	ContainerStop(name string, seconds *int) error
-	ContainerUnpause(name string) error
-	ContainerUpdate(name string, hostConfig *container.HostConfig) (container.ContainerUpdateOKBody, error)
-	ContainerWait(ctx context.Context, name string, condition containerpkg.WaitCondition) (<-chan containerpkg.StateStatus, error)
-}
-
-// monitorBackend includes functions to implement to provide containers monitoring functionality.
-type monitorBackend interface {
-	ContainerChanges(name string) ([]archive.Change, error)
-	ContainerInspect(name string, size bool, version string) (interface{}, error)
-	ContainerLogs(ctx context.Context, name string, config *types.ContainerLogsOptions) (msgs <-chan *backend.LogMessage, tty bool, err error)
-	ContainerStats(ctx context.Context, name string, config *backend.ContainerStatsConfig) error
-	ContainerTop(name string, psArgs string) (*container.ContainerTopOKBody, error)
-
-	Containers(config *types.ContainerListOptions) ([]*types.Container, error)
-}
-
-// attachBackend includes function to implement to provide container attaching functionality.
-type attachBackend interface {
-	ContainerAttach(name string, c *backend.ContainerAttachConfig) error
-}
-
-// systemBackend includes functions to implement to provide system wide containers functionality
-type systemBackend interface {
-	ContainersPrune(ctx context.Context, pruneFilters filters.Args) (*types.ContainersPruneReport, error)
-}
-
-type commitBackend interface {
-	CreateImageFromContainer(name string, config *backend.CreateImageConfig) (imageID string, err error)
-}
-
-// Backend is all the methods that need to be implemented to provide container specific functionality.
-type Backend interface {
-	commitBackend
-	execBackend
-	copyBackend
-	stateBackend
-	monitorBackend
-	attachBackend
-	systemBackend
-}
--- a/api/server/router/container/container.go
+++ b/api/server/router/container/container.go
@@ -1,72 +0,0 @@
-package container // import "github.com/docker/docker/api/server/router/container"
-
-import (
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/server/router"
-)
-
-// containerRouter is a router to talk with the container controller
-type containerRouter struct {
-	backend Backend
-	decoder httputils.ContainerDecoder
-	routes  []router.Route
-	cgroup2 bool
-}
-
-// NewRouter initializes a new container router
-func NewRouter(b Backend, decoder httputils.ContainerDecoder, cgroup2 bool) router.Router {
-	r := &containerRouter{
-		backend: b,
-		decoder: decoder,
-		cgroup2: cgroup2,
-	}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routes to the container controller
-func (r *containerRouter) Routes() []router.Route {
-	return r.routes
-}
-
-// initRoutes initializes the routes in container router
-func (r *containerRouter) initRoutes() {
-	r.routes = []router.Route{
-		// HEAD
-		router.NewHeadRoute("/containers/{name:.*}/archive", r.headContainersArchive),
-		// GET
-		router.NewGetRoute("/containers/json", r.getContainersJSON),
-		router.NewGetRoute("/containers/{name:.*}/export", r.getContainersExport),
-		router.NewGetRoute("/containers/{name:.*}/changes", r.getContainersChanges),
-		router.NewGetRoute("/containers/{name:.*}/json", r.getContainersByName),
-		router.NewGetRoute("/containers/{name:.*}/top", r.getContainersTop),
-		router.NewGetRoute("/containers/{name:.*}/logs", r.getContainersLogs),
-		router.NewGetRoute("/containers/{name:.*}/stats", r.getContainersStats),
-		router.NewGetRoute("/containers/{name:.*}/attach/ws", r.wsContainersAttach),
-		router.NewGetRoute("/exec/{id:.*}/json", r.getExecByID),
-		router.NewGetRoute("/containers/{name:.*}/archive", r.getContainersArchive),
-		// POST
-		router.NewPostRoute("/containers/create", r.postContainersCreate),
-		router.NewPostRoute("/containers/{name:.*}/kill", r.postContainersKill),
-		router.NewPostRoute("/containers/{name:.*}/pause", r.postContainersPause),
-		router.NewPostRoute("/containers/{name:.*}/unpause", r.postContainersUnpause),
-		router.NewPostRoute("/containers/{name:.*}/restart", r.postContainersRestart),
-		router.NewPostRoute("/containers/{name:.*}/start", r.postContainersStart),
-		router.NewPostRoute("/containers/{name:.*}/stop", r.postContainersStop),
-		router.NewPostRoute("/containers/{name:.*}/wait", r.postContainersWait),
-		router.NewPostRoute("/containers/{name:.*}/resize", r.postContainersResize),
-		router.NewPostRoute("/containers/{name:.*}/attach", r.postContainersAttach),
-		router.NewPostRoute("/containers/{name:.*}/copy", r.postContainersCopy), // Deprecated since 1.8, Errors out since 1.12
-		router.NewPostRoute("/containers/{name:.*}/exec", r.postContainerExecCreate),
-		router.NewPostRoute("/exec/{name:.*}/start", r.postContainerExecStart),
-		router.NewPostRoute("/exec/{name:.*}/resize", r.postContainerExecResize),
-		router.NewPostRoute("/containers/{name:.*}/rename", r.postContainerRename),
-		router.NewPostRoute("/containers/{name:.*}/update", r.postContainerUpdate),
-		router.NewPostRoute("/containers/prune", r.postContainersPrune),
-		router.NewPostRoute("/commit", r.postCommit),
-		// PUT
-		router.NewPutRoute("/containers/{name:.*}/archive", r.putContainersArchive),
-		// DELETE
-		router.NewDeleteRoute("/containers/{name:.*}", r.deleteContainers),
-	}
-}
--- a/api/server/router/container/container_routes.go
+++ b/api/server/router/container/container_routes.go
@@ -1,717 +0,0 @@
-package container // import "github.com/docker/docker/api/server/router/container"
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strconv"
-	"syscall"
-
-	"github.com/containerd/containerd/platforms"
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/backend"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/versions"
-	containerpkg "github.com/docker/docker/container"
-	"github.com/docker/docker/errdefs"
-	"github.com/docker/docker/pkg/ioutils"
-	"github.com/docker/docker/pkg/signal"
-	specs "github.com/opencontainers/image-spec/specs-go/v1"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	"golang.org/x/net/websocket"
-)
-
-func (s *containerRouter) postCommit(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	if err := httputils.CheckForJSON(r); err != nil {
-		return err
-	}
-
-	// TODO: remove pause arg, and always pause in backend
-	pause := httputils.BoolValue(r, "pause")
-	version := httputils.VersionFromContext(ctx)
-	if r.FormValue("pause") == "" && versions.GreaterThanOrEqualTo(version, "1.13") {
-		pause = true
-	}
-
-	config, _, _, err := s.decoder.DecodeConfig(r.Body)
-	if err != nil && err != io.EOF { // Do not fail if body is empty.
-		return err
-	}
-
-	commitCfg := &backend.CreateImageConfig{
-		Pause:   pause,
-		Repo:    r.Form.Get("repo"),
-		Tag:     r.Form.Get("tag"),
-		Author:  r.Form.Get("author"),
-		Comment: r.Form.Get("comment"),
-		Config:  config,
-		Changes: r.Form["changes"],
-	}
-
-	imgID, err := s.backend.CreateImageFromContainer(r.Form.Get("container"), commitCfg)
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusCreated, &types.IDResponse{ID: imgID})
-}
-
-func (s *containerRouter) getContainersJSON(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	filter, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	config := &types.ContainerListOptions{
-		All:     httputils.BoolValue(r, "all"),
-		Size:    httputils.BoolValue(r, "size"),
-		Since:   r.Form.Get("since"),
-		Before:  r.Form.Get("before"),
-		Filters: filter,
-	}
-
-	if tmpLimit := r.Form.Get("limit"); tmpLimit != "" {
-		limit, err := strconv.Atoi(tmpLimit)
-		if err != nil {
-			return err
-		}
-		config.Limit = limit
-	}
-
-	containers, err := s.backend.Containers(config)
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, containers)
-}
-
-func (s *containerRouter) getContainersStats(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	stream := httputils.BoolValueOrDefault(r, "stream", true)
-	if !stream {
-		w.Header().Set("Content-Type", "application/json")
-	}
-	var oneShot bool
-	if versions.GreaterThanOrEqualTo(httputils.VersionFromContext(ctx), "1.41") {
-		oneShot = httputils.BoolValueOrDefault(r, "one-shot", false)
-	}
-
-	config := &backend.ContainerStatsConfig{
-		Stream:    stream,
-		OneShot:   oneShot,
-		OutStream: w,
-		Version:   httputils.VersionFromContext(ctx),
-	}
-
-	return s.backend.ContainerStats(ctx, vars["name"], config)
-}
-
-func (s *containerRouter) getContainersLogs(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	// Args are validated before the stream starts because when it starts we're
-	// sending HTTP 200 by writing an empty chunk of data to tell the client that
-	// daemon is going to stream. By sending this initial HTTP 200 we can't report
-	// any error after the stream starts (i.e. container not found, wrong parameters)
-	// with the appropriate status code.
-	stdout, stderr := httputils.BoolValue(r, "stdout"), httputils.BoolValue(r, "stderr")
-	if !(stdout || stderr) {
-		return errdefs.InvalidParameter(errors.New("Bad parameters: you must choose at least one stream"))
-	}
-
-	containerName := vars["name"]
-	logsConfig := &types.ContainerLogsOptions{
-		Follow:     httputils.BoolValue(r, "follow"),
-		Timestamps: httputils.BoolValue(r, "timestamps"),
-		Since:      r.Form.Get("since"),
-		Until:      r.Form.Get("until"),
-		Tail:       r.Form.Get("tail"),
-		ShowStdout: stdout,
-		ShowStderr: stderr,
-		Details:    httputils.BoolValue(r, "details"),
-	}
-
-	msgs, tty, err := s.backend.ContainerLogs(ctx, containerName, logsConfig)
-	if err != nil {
-		return err
-	}
-
-	// if has a tty, we're not muxing streams. if it doesn't, we are. simple.
-	// this is the point of no return for writing a response. once we call
-	// WriteLogStream, the response has been started and errors will be
-	// returned in band by WriteLogStream
-	httputils.WriteLogStream(ctx, w, msgs, logsConfig, !tty)
-	return nil
-}
-
-func (s *containerRouter) getContainersExport(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	return s.backend.ContainerExport(vars["name"], w)
-}
-
-type bodyOnStartError struct{}
-
-func (bodyOnStartError) Error() string {
-	return "starting container with non-empty request body was deprecated since API v1.22 and removed in v1.24"
-}
-
-func (bodyOnStartError) InvalidParameter() {}
-
-func (s *containerRouter) postContainersStart(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	// If contentLength is -1, we can assumed chunked encoding
-	// or more technically that the length is unknown
-	// https://golang.org/src/pkg/net/http/request.go#L139
-	// net/http otherwise seems to swallow any headers related to chunked encoding
-	// including r.TransferEncoding
-	// allow a nil body for backwards compatibility
-
-	version := httputils.VersionFromContext(ctx)
-	var hostConfig *container.HostConfig
-	// A non-nil json object is at least 7 characters.
-	if r.ContentLength > 7 || r.ContentLength == -1 {
-		if versions.GreaterThanOrEqualTo(version, "1.24") {
-			return bodyOnStartError{}
-		}
-
-		if err := httputils.CheckForJSON(r); err != nil {
-			return err
-		}
-
-		c, err := s.decoder.DecodeHostConfig(r.Body)
-		if err != nil {
-			return err
-		}
-		hostConfig = c
-	}
-
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	checkpoint := r.Form.Get("checkpoint")
-	checkpointDir := r.Form.Get("checkpoint-dir")
-	if err := s.backend.ContainerStart(vars["name"], hostConfig, checkpoint, checkpointDir); err != nil {
-		return err
-	}
-
-	w.WriteHeader(http.StatusNoContent)
-	return nil
-}
-
-func (s *containerRouter) postContainersStop(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	var seconds *int
-	if tmpSeconds := r.Form.Get("t"); tmpSeconds != "" {
-		valSeconds, err := strconv.Atoi(tmpSeconds)
-		if err != nil {
-			return err
-		}
-		seconds = &valSeconds
-	}
-
-	if err := s.backend.ContainerStop(vars["name"], seconds); err != nil {
-		return err
-	}
-	w.WriteHeader(http.StatusNoContent)
-
-	return nil
-}
-
-func (s *containerRouter) postContainersKill(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	var sig syscall.Signal
-	name := vars["name"]
-
-	// If we have a signal, look at it. Otherwise, do nothing
-	if sigStr := r.Form.Get("signal"); sigStr != "" {
-		var err error
-		if sig, err = signal.ParseSignal(sigStr); err != nil {
-			return errdefs.InvalidParameter(err)
-		}
-	}
-
-	if err := s.backend.ContainerKill(name, uint64(sig)); err != nil {
-		var isStopped bool
-		if errdefs.IsConflict(err) {
-			isStopped = true
-		}
-
-		// Return error that's not caused because the container is stopped.
-		// Return error if the container is not running and the api is >= 1.20
-		// to keep backwards compatibility.
-		version := httputils.VersionFromContext(ctx)
-		if versions.GreaterThanOrEqualTo(version, "1.20") || !isStopped {
-			return errors.Wrapf(err, "Cannot kill container: %s", name)
-		}
-	}
-
-	w.WriteHeader(http.StatusNoContent)
-	return nil
-}
-
-func (s *containerRouter) postContainersRestart(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	var seconds *int
-	if tmpSeconds := r.Form.Get("t"); tmpSeconds != "" {
-		valSeconds, err := strconv.Atoi(tmpSeconds)
-		if err != nil {
-			return err
-		}
-		seconds = &valSeconds
-	}
-
-	if err := s.backend.ContainerRestart(vars["name"], seconds); err != nil {
-		return err
-	}
-
-	w.WriteHeader(http.StatusNoContent)
-
-	return nil
-}
-
-func (s *containerRouter) postContainersPause(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	if err := s.backend.ContainerPause(vars["name"]); err != nil {
-		return err
-	}
-
-	w.WriteHeader(http.StatusNoContent)
-
-	return nil
-}
-
-func (s *containerRouter) postContainersUnpause(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	if err := s.backend.ContainerUnpause(vars["name"]); err != nil {
-		return err
-	}
-
-	w.WriteHeader(http.StatusNoContent)
-
-	return nil
-}
-
-func (s *containerRouter) postContainersWait(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	// Behavior changed in version 1.30 to handle wait condition and to
-	// return headers immediately.
-	version := httputils.VersionFromContext(ctx)
-	legacyBehaviorPre130 := versions.LessThan(version, "1.30")
-	legacyRemovalWaitPre134 := false
-
-	// The wait condition defaults to "not-running".
-	waitCondition := containerpkg.WaitConditionNotRunning
-	if !legacyBehaviorPre130 {
-		if err := httputils.ParseForm(r); err != nil {
-			return err
-		}
-		switch container.WaitCondition(r.Form.Get("condition")) {
-		case container.WaitConditionNextExit:
-			waitCondition = containerpkg.WaitConditionNextExit
-		case container.WaitConditionRemoved:
-			waitCondition = containerpkg.WaitConditionRemoved
-			legacyRemovalWaitPre134 = versions.LessThan(version, "1.34")
-		}
-	}
-
-	waitC, err := s.backend.ContainerWait(ctx, vars["name"], waitCondition)
-	if err != nil {
-		return err
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-
-	if !legacyBehaviorPre130 {
-		// Write response header immediately.
-		w.WriteHeader(http.StatusOK)
-		if flusher, ok := w.(http.Flusher); ok {
-			flusher.Flush()
-		}
-	}
-
-	// Block on the result of the wait operation.
-	status := <-waitC
-
-	// With API < 1.34, wait on WaitConditionRemoved did not return
-	// in case container removal failed. The only way to report an
-	// error back to the client is to not write anything (i.e. send
-	// an empty response which will be treated as an error).
-	if legacyRemovalWaitPre134 && status.Err() != nil {
-		return nil
-	}
-
-	var waitError *container.ContainerWaitOKBodyError
-	if status.Err() != nil {
-		waitError = &container.ContainerWaitOKBodyError{Message: status.Err().Error()}
-	}
-
-	return json.NewEncoder(w).Encode(&container.ContainerWaitOKBody{
-		StatusCode: int64(status.ExitCode()),
-		Error:      waitError,
-	})
-}
-
-func (s *containerRouter) getContainersChanges(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	changes, err := s.backend.ContainerChanges(vars["name"])
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, changes)
-}
-
-func (s *containerRouter) getContainersTop(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	procList, err := s.backend.ContainerTop(vars["name"], r.Form.Get("ps_args"))
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, procList)
-}
-
-func (s *containerRouter) postContainerRename(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	name := vars["name"]
-	newName := r.Form.Get("name")
-	if err := s.backend.ContainerRename(name, newName); err != nil {
-		return err
-	}
-	w.WriteHeader(http.StatusNoContent)
-	return nil
-}
-
-func (s *containerRouter) postContainerUpdate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	if err := httputils.CheckForJSON(r); err != nil {
-		return err
-	}
-
-	var updateConfig container.UpdateConfig
-
-	decoder := json.NewDecoder(r.Body)
-	if err := decoder.Decode(&updateConfig); err != nil {
-		return err
-	}
-	if versions.LessThan(httputils.VersionFromContext(ctx), "1.40") {
-		updateConfig.PidsLimit = nil
-	}
-	if updateConfig.PidsLimit != nil && *updateConfig.PidsLimit <= 0 {
-		// Both `0` and `-1` are accepted to set "unlimited" when updating.
-		// Historically, any negative value was accepted, so treat them as
-		// "unlimited" as well.
-		var unlimited int64
-		updateConfig.PidsLimit = &unlimited
-	}
-
-	hostConfig := &container.HostConfig{
-		Resources:     updateConfig.Resources,
-		RestartPolicy: updateConfig.RestartPolicy,
-	}
-
-	name := vars["name"]
-	resp, err := s.backend.ContainerUpdate(name, hostConfig)
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, resp)
-}
-
-func (s *containerRouter) postContainersCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	if err := httputils.CheckForJSON(r); err != nil {
-		return err
-	}
-
-	name := r.Form.Get("name")
-
-	config, hostConfig, networkingConfig, err := s.decoder.DecodeConfig(r.Body)
-	if err != nil {
-		return err
-	}
-	version := httputils.VersionFromContext(ctx)
-	adjustCPUShares := versions.LessThan(version, "1.19")
-
-	// When using API 1.24 and under, the client is responsible for removing the container
-	if hostConfig != nil && versions.LessThan(version, "1.25") {
-		hostConfig.AutoRemove = false
-	}
-
-	if hostConfig != nil && versions.LessThan(version, "1.40") {
-		// Ignore BindOptions.NonRecursive because it was added in API 1.40.
-		for _, m := range hostConfig.Mounts {
-			if bo := m.BindOptions; bo != nil {
-				bo.NonRecursive = false
-			}
-		}
-		// Ignore KernelMemoryTCP because it was added in API 1.40.
-		hostConfig.KernelMemoryTCP = 0
-
-		// Older clients (API < 1.40) expects the default to be shareable, make them happy
-		if hostConfig.IpcMode.IsEmpty() {
-			hostConfig.IpcMode = container.IpcMode("shareable")
-		}
-	}
-	if hostConfig != nil && versions.LessThan(version, "1.41") && !s.cgroup2 {
-		// Older clients expect the default to be "host" on cgroup v1 hosts
-		if hostConfig.CgroupnsMode.IsEmpty() {
-			hostConfig.CgroupnsMode = container.CgroupnsMode("host")
-		}
-	}
-
-	var platform *specs.Platform
-	if versions.GreaterThanOrEqualTo(version, "1.41") {
-		if v := r.Form.Get("platform"); v != "" {
-			p, err := platforms.Parse(v)
-			if err != nil {
-				return errdefs.InvalidParameter(err)
-			}
-			platform = &p
-		}
-	}
-
-	if hostConfig != nil && hostConfig.PidsLimit != nil && *hostConfig.PidsLimit <= 0 {
-		// Don't set a limit if either no limit was specified, or "unlimited" was
-		// explicitly set.
-		// Both `0` and `-1` are accepted as "unlimited", and historically any
-		// negative value was accepted, so treat those as "unlimited" as well.
-		hostConfig.PidsLimit = nil
-	}
-
-	ccr, err := s.backend.ContainerCreate(types.ContainerCreateConfig{
-		Name:             name,
-		Config:           config,
-		HostConfig:       hostConfig,
-		NetworkingConfig: networkingConfig,
-		AdjustCPUShares:  adjustCPUShares,
-		Platform:         platform,
-	})
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusCreated, ccr)
-}
-
-func (s *containerRouter) deleteContainers(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	name := vars["name"]
-	config := &types.ContainerRmConfig{
-		ForceRemove:  httputils.BoolValue(r, "force"),
-		RemoveVolume: httputils.BoolValue(r, "v"),
-		RemoveLink:   httputils.BoolValue(r, "link"),
-	}
-
-	if err := s.backend.ContainerRm(name, config); err != nil {
-		return err
-	}
-
-	w.WriteHeader(http.StatusNoContent)
-
-	return nil
-}
-
-func (s *containerRouter) postContainersResize(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	height, err := strconv.Atoi(r.Form.Get("h"))
-	if err != nil {
-		return errdefs.InvalidParameter(err)
-	}
-	width, err := strconv.Atoi(r.Form.Get("w"))
-	if err != nil {
-		return errdefs.InvalidParameter(err)
-	}
-
-	return s.backend.ContainerResize(vars["name"], height, width)
-}
-
-func (s *containerRouter) postContainersAttach(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	err := httputils.ParseForm(r)
-	if err != nil {
-		return err
-	}
-	containerName := vars["name"]
-
-	_, upgrade := r.Header["Upgrade"]
-	detachKeys := r.FormValue("detachKeys")
-
-	hijacker, ok := w.(http.Hijacker)
-	if !ok {
-		return errdefs.InvalidParameter(errors.Errorf("error attaching to container %s, hijack connection missing", containerName))
-	}
-
-	setupStreams := func() (io.ReadCloser, io.Writer, io.Writer, error) {
-		conn, _, err := hijacker.Hijack()
-		if err != nil {
-			return nil, nil, nil, err
-		}
-
-		// set raw mode
-		conn.Write([]byte{})
-
-		if upgrade {
-			fmt.Fprintf(conn, "HTTP/1.1 101 UPGRADED\r\nContent-Type: application/vnd.docker.raw-stream\r\nConnection: Upgrade\r\nUpgrade: tcp\r\n\r\n")
-		} else {
-			fmt.Fprintf(conn, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n")
-		}
-
-		closer := func() error {
-			httputils.CloseStreams(conn)
-			return nil
-		}
-		return ioutils.NewReadCloserWrapper(conn, closer), conn, conn, nil
-	}
-
-	attachConfig := &backend.ContainerAttachConfig{
-		GetStreams: setupStreams,
-		UseStdin:   httputils.BoolValue(r, "stdin"),
-		UseStdout:  httputils.BoolValue(r, "stdout"),
-		UseStderr:  httputils.BoolValue(r, "stderr"),
-		Logs:       httputils.BoolValue(r, "logs"),
-		Stream:     httputils.BoolValue(r, "stream"),
-		DetachKeys: detachKeys,
-		MuxStreams: true,
-	}
-
-	if err = s.backend.ContainerAttach(containerName, attachConfig); err != nil {
-		logrus.Errorf("Handler for %s %s returned error: %v", r.Method, r.URL.Path, err)
-		// Remember to close stream if error happens
-		conn, _, errHijack := hijacker.Hijack()
-		if errHijack == nil {
-			statusCode := errdefs.GetHTTPErrorStatusCode(err)
-			statusText := http.StatusText(statusCode)
-			fmt.Fprintf(conn, "HTTP/1.1 %d %s\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n%s\r\n", statusCode, statusText, err.Error())
-			httputils.CloseStreams(conn)
-		} else {
-			logrus.Errorf("Error Hijacking: %v", err)
-		}
-	}
-	return nil
-}
-
-func (s *containerRouter) wsContainersAttach(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	containerName := vars["name"]
-
-	var err error
-	detachKeys := r.FormValue("detachKeys")
-
-	done := make(chan struct{})
-	started := make(chan struct{})
-
-	version := httputils.VersionFromContext(ctx)
-
-	setupStreams := func() (io.ReadCloser, io.Writer, io.Writer, error) {
-		wsChan := make(chan *websocket.Conn)
-		h := func(conn *websocket.Conn) {
-			wsChan <- conn
-			<-done
-		}
-
-		srv := websocket.Server{Handler: h, Handshake: nil}
-		go func() {
-			close(started)
-			srv.ServeHTTP(w, r)
-		}()
-
-		conn := <-wsChan
-		// In case version 1.28 and above, a binary frame will be sent.
-		// See 28176 for details.
-		if versions.GreaterThanOrEqualTo(version, "1.28") {
-			conn.PayloadType = websocket.BinaryFrame
-		}
-		return conn, conn, conn, nil
-	}
-
-	attachConfig := &backend.ContainerAttachConfig{
-		GetStreams: setupStreams,
-		Logs:       httputils.BoolValue(r, "logs"),
-		Stream:     httputils.BoolValue(r, "stream"),
-		DetachKeys: detachKeys,
-		UseStdin:   true,
-		UseStdout:  true,
-		UseStderr:  true,
-		MuxStreams: false, // TODO: this should be true since it's a single stream for both stdout and stderr
-	}
-
-	err = s.backend.ContainerAttach(containerName, attachConfig)
-	close(done)
-	select {
-	case <-started:
-		if err != nil {
-			logrus.Errorf("Error attaching websocket: %s", err)
-		} else {
-			logrus.Debug("websocket connection was closed by client")
-		}
-		return nil
-	default:
-	}
-	return err
-}
-
-func (s *containerRouter) postContainersPrune(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	pruneFilters, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return errdefs.InvalidParameter(err)
-	}
-
-	pruneReport, err := s.backend.ContainersPrune(ctx, pruneFilters)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, pruneReport)
-}
--- a/api/server/router/container/copy.go
+++ b/api/server/router/container/copy.go
@@ -1,145 +0,0 @@
-package container // import "github.com/docker/docker/api/server/router/container"
-
-import (
-	"compress/flate"
-	"compress/gzip"
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"io"
-	"net/http"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/versions"
-	"github.com/docker/docker/errdefs"
-	gddohttputil "github.com/golang/gddo/httputil"
-)
-
-type pathError struct{}
-
-func (pathError) Error() string {
-	return "Path cannot be empty"
-}
-
-func (pathError) InvalidParameter() {}
-
-// postContainersCopy is deprecated in favor of getContainersArchive.
-func (s *containerRouter) postContainersCopy(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	// Deprecated since 1.8, Errors out since 1.12
-	version := httputils.VersionFromContext(ctx)
-	if versions.GreaterThanOrEqualTo(version, "1.24") {
-		w.WriteHeader(http.StatusNotFound)
-		return nil
-	}
-	if err := httputils.CheckForJSON(r); err != nil {
-		return err
-	}
-
-	cfg := types.CopyConfig{}
-	if err := json.NewDecoder(r.Body).Decode(&cfg); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	if cfg.Resource == "" {
-		return pathError{}
-	}
-
-	data, err := s.backend.ContainerCopy(vars["name"], cfg.Resource)
-	if err != nil {
-		return err
-	}
-	defer data.Close()
-
-	w.Header().Set("Content-Type", "application/x-tar")
-	_, err = io.Copy(w, data)
-	return err
-}
-
-// // Encode the stat to JSON, base64 encode, and place in a header.
-func setContainerPathStatHeader(stat *types.ContainerPathStat, header http.Header) error {
-	statJSON, err := json.Marshal(stat)
-	if err != nil {
-		return err
-	}
-
-	header.Set(
-		"X-Docker-Container-Path-Stat",
-		base64.StdEncoding.EncodeToString(statJSON),
-	)
-
-	return nil
-}
-
-func (s *containerRouter) headContainersArchive(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	v, err := httputils.ArchiveFormValues(r, vars)
-	if err != nil {
-		return err
-	}
-
-	stat, err := s.backend.ContainerStatPath(v.Name, v.Path)
-	if err != nil {
-		return err
-	}
-
-	return setContainerPathStatHeader(stat, w.Header())
-}
-
-func writeCompressedResponse(w http.ResponseWriter, r *http.Request, body io.Reader) error {
-	var cw io.Writer
-	switch gddohttputil.NegotiateContentEncoding(r, []string{"gzip", "deflate"}) {
-	case "gzip":
-		gw := gzip.NewWriter(w)
-		defer gw.Close()
-		cw = gw
-		w.Header().Set("Content-Encoding", "gzip")
-	case "deflate":
-		fw, err := flate.NewWriter(w, flate.DefaultCompression)
-		if err != nil {
-			return err
-		}
-		defer fw.Close()
-		cw = fw
-		w.Header().Set("Content-Encoding", "deflate")
-	default:
-		cw = w
-	}
-	_, err := io.Copy(cw, body)
-	return err
-}
-
-func (s *containerRouter) getContainersArchive(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	v, err := httputils.ArchiveFormValues(r, vars)
-	if err != nil {
-		return err
-	}
-
-	tarArchive, stat, err := s.backend.ContainerArchivePath(v.Name, v.Path)
-	if err != nil {
-		return err
-	}
-	defer tarArchive.Close()
-
-	if err := setContainerPathStatHeader(stat, w.Header()); err != nil {
-		return err
-	}
-
-	w.Header().Set("Content-Type", "application/x-tar")
-	return writeCompressedResponse(w, r, tarArchive)
-}
-
-func (s *containerRouter) putContainersArchive(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	v, err := httputils.ArchiveFormValues(r, vars)
-	if err != nil {
-		return err
-	}
-
-	noOverwriteDirNonDir := httputils.BoolValue(r, "noOverwriteDirNonDir")
-	copyUIDGID := httputils.BoolValue(r, "copyUIDGID")
-
-	return s.backend.ContainerExtractToDir(v.Name, v.Path, copyUIDGID, noOverwriteDirNonDir, r.Body)
-}
--- a/api/server/router/container/exec.go
+++ b/api/server/router/container/exec.go
@@ -1,156 +0,0 @@
-package container // import "github.com/docker/docker/api/server/router/container"
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"strconv"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/versions"
-	"github.com/docker/docker/errdefs"
-	"github.com/docker/docker/pkg/stdcopy"
-	"github.com/sirupsen/logrus"
-)
-
-func (s *containerRouter) getExecByID(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	eConfig, err := s.backend.ContainerExecInspect(vars["id"])
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, eConfig)
-}
-
-type execCommandError struct{}
-
-func (execCommandError) Error() string {
-	return "No exec command specified"
-}
-
-func (execCommandError) InvalidParameter() {}
-
-func (s *containerRouter) postContainerExecCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	if err := httputils.CheckForJSON(r); err != nil {
-		return err
-	}
-	name := vars["name"]
-
-	execConfig := &types.ExecConfig{}
-	if err := json.NewDecoder(r.Body).Decode(execConfig); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	if len(execConfig.Cmd) == 0 {
-		return execCommandError{}
-	}
-
-	// Register an instance of Exec in container.
-	id, err := s.backend.ContainerExecCreate(name, execConfig)
-	if err != nil {
-		logrus.Errorf("Error setting up exec command in container %s: %v", name, err)
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusCreated, &types.IDResponse{
-		ID: id,
-	})
-}
-
-// TODO(vishh): Refactor the code to avoid having to specify stream config as part of both create and start.
-func (s *containerRouter) postContainerExecStart(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	version := httputils.VersionFromContext(ctx)
-	if versions.GreaterThan(version, "1.21") {
-		if err := httputils.CheckForJSON(r); err != nil {
-			return err
-		}
-	}
-
-	var (
-		execName                  = vars["name"]
-		stdin, inStream           io.ReadCloser
-		stdout, stderr, outStream io.Writer
-	)
-
-	execStartCheck := &types.ExecStartCheck{}
-	if err := json.NewDecoder(r.Body).Decode(execStartCheck); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	if exists, err := s.backend.ExecExists(execName); !exists {
-		return err
-	}
-
-	if !execStartCheck.Detach {
-		var err error
-		// Setting up the streaming http interface.
-		inStream, outStream, err = httputils.HijackConnection(w)
-		if err != nil {
-			return err
-		}
-		defer httputils.CloseStreams(inStream, outStream)
-
-		if _, ok := r.Header["Upgrade"]; ok {
-			fmt.Fprint(outStream, "HTTP/1.1 101 UPGRADED\r\nContent-Type: application/vnd.docker.raw-stream\r\nConnection: Upgrade\r\nUpgrade: tcp\r\n")
-		} else {
-			fmt.Fprint(outStream, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n")
-		}
-
-		// copy headers that were removed as part of hijack
-		if err := w.Header().WriteSubset(outStream, nil); err != nil {
-			return err
-		}
-		fmt.Fprint(outStream, "\r\n")
-
-		stdin = inStream
-		stdout = outStream
-		if !execStartCheck.Tty {
-			stderr = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
-			stdout = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
-		}
-	}
-
-	// Now run the user process in container.
-	// Maybe we should we pass ctx here if we're not detaching?
-	if err := s.backend.ContainerExecStart(context.Background(), execName, stdin, stdout, stderr); err != nil {
-		if execStartCheck.Detach {
-			return err
-		}
-		stdout.Write([]byte(err.Error() + "\r\n"))
-		logrus.Errorf("Error running exec %s in container: %v", execName, err)
-	}
-	return nil
-}
-
-func (s *containerRouter) postContainerExecResize(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	height, err := strconv.Atoi(r.Form.Get("h"))
-	if err != nil {
-		return errdefs.InvalidParameter(err)
-	}
-	width, err := strconv.Atoi(r.Form.Get("w"))
-	if err != nil {
-		return errdefs.InvalidParameter(err)
-	}
-
-	return s.backend.ContainerExecResize(vars["name"], height, width)
-}
--- a/api/server/router/container/inspect.go
+++ b/api/server/router/container/inspect.go
@@ -1,21 +0,0 @@
-package container // import "github.com/docker/docker/api/server/router/container"
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/docker/docker/api/server/httputils"
-)
-
-// getContainersByName inspects container's configuration and serializes it as json.
-func (s *containerRouter) getContainersByName(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	displaySize := httputils.BoolValue(r, "size")
-
-	version := httputils.VersionFromContext(ctx)
-	json, err := s.backend.ContainerInspect(vars["name"], displaySize, version)
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, json)
-}
--- a/api/server/router/debug/debug.go
+++ b/api/server/router/debug/debug.go
@@ -1,53 +0,0 @@
-package debug // import "github.com/docker/docker/api/server/router/debug"
-
-import (
-	"context"
-	"expvar"
-	"net/http"
-	"net/http/pprof"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/server/router"
-)
-
-// NewRouter creates a new debug router
-// The debug router holds endpoints for debug the daemon, such as those for pprof.
-func NewRouter() router.Router {
-	r := &debugRouter{}
-	r.initRoutes()
-	return r
-}
-
-type debugRouter struct {
-	routes []router.Route
-}
-
-func (r *debugRouter) initRoutes() {
-	r.routes = []router.Route{
-		router.NewGetRoute("/vars", frameworkAdaptHandler(expvar.Handler())),
-		router.NewGetRoute("/pprof/", frameworkAdaptHandlerFunc(pprof.Index)),
-		router.NewGetRoute("/pprof/cmdline", frameworkAdaptHandlerFunc(pprof.Cmdline)),
-		router.NewGetRoute("/pprof/profile", frameworkAdaptHandlerFunc(pprof.Profile)),
-		router.NewGetRoute("/pprof/symbol", frameworkAdaptHandlerFunc(pprof.Symbol)),
-		router.NewGetRoute("/pprof/trace", frameworkAdaptHandlerFunc(pprof.Trace)),
-		router.NewGetRoute("/pprof/{name}", handlePprof),
-	}
-}
-
-func (r *debugRouter) Routes() []router.Route {
-	return r.routes
-}
-
-func frameworkAdaptHandler(handler http.Handler) httputils.APIFunc {
-	return func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-		handler.ServeHTTP(w, r)
-		return nil
-	}
-}
-
-func frameworkAdaptHandlerFunc(handler http.HandlerFunc) httputils.APIFunc {
-	return func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-		handler(w, r)
-		return nil
-	}
-}
--- a/api/server/router/debug/debug_routes.go
+++ b/api/server/router/debug/debug_routes.go
@@ -1,12 +0,0 @@
-package debug // import "github.com/docker/docker/api/server/router/debug"
-
-import (
-	"context"
-	"net/http"
-	"net/http/pprof"
-)
-
-func handlePprof(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	pprof.Handler(vars["name"]).ServeHTTP(w, r)
-	return nil
-}
--- a/api/server/router/distribution/backend.go
+++ b/api/server/router/distribution/backend.go
@@ -1,15 +0,0 @@
-package distribution // import "github.com/docker/docker/api/server/router/distribution"
-
-import (
-	"context"
-
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/reference"
-	"github.com/docker/docker/api/types"
-)
-
-// Backend is all the methods that need to be implemented
-// to provide image specific functionality.
-type Backend interface {
-	GetRepository(context.Context, reference.Named, *types.AuthConfig) (distribution.Repository, bool, error)
-}
--- a/api/server/router/distribution/distribution.go
+++ b/api/server/router/distribution/distribution.go
@@ -1,31 +0,0 @@
-package distribution // import "github.com/docker/docker/api/server/router/distribution"
-
-import "github.com/docker/docker/api/server/router"
-
-// distributionRouter is a router to talk with the registry
-type distributionRouter struct {
-	backend Backend
-	routes  []router.Route
-}
-
-// NewRouter initializes a new distribution router
-func NewRouter(backend Backend) router.Router {
-	r := &distributionRouter{
-		backend: backend,
-	}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routes
-func (r *distributionRouter) Routes() []router.Route {
-	return r.routes
-}
-
-// initRoutes initializes the routes in the distribution router
-func (r *distributionRouter) initRoutes() {
-	r.routes = []router.Route{
-		// GET
-		router.NewGetRoute("/distribution/{name:.*}/json", r.getDistributionInfo),
-	}
-}
--- a/api/server/router/distribution/distribution_routes.go
+++ b/api/server/router/distribution/distribution_routes.go
@@ -1,150 +0,0 @@
-package distribution // import "github.com/docker/docker/api/server/router/distribution"
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"net/http"
-	"strings"
-
-	"github.com/docker/distribution/manifest/manifestlist"
-	"github.com/docker/distribution/manifest/schema1"
-	"github.com/docker/distribution/manifest/schema2"
-	"github.com/docker/distribution/reference"
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types"
-	registrytypes "github.com/docker/docker/api/types/registry"
-	"github.com/docker/docker/errdefs"
-	v1 "github.com/opencontainers/image-spec/specs-go/v1"
-	"github.com/pkg/errors"
-)
-
-func (s *distributionRouter) getDistributionInfo(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-
-	var (
-		config              = &types.AuthConfig{}
-		authEncoded         = r.Header.Get("X-Registry-Auth")
-		distributionInspect registrytypes.DistributionInspect
-	)
-
-	if authEncoded != "" {
-		authJSON := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
-		if err := json.NewDecoder(authJSON).Decode(&config); err != nil {
-			// for a search it is not an error if no auth was given
-			// to increase compatibility with the existing api it is defaulting to be empty
-			config = &types.AuthConfig{}
-		}
-	}
-
-	image := vars["name"]
-
-	// TODO why is reference.ParseAnyReference() / reference.ParseNormalizedNamed() not using the reference.ErrTagInvalidFormat (and so on) errors?
-	ref, err := reference.ParseAnyReference(image)
-	if err != nil {
-		return errdefs.InvalidParameter(err)
-	}
-	namedRef, ok := ref.(reference.Named)
-	if !ok {
-		if _, ok := ref.(reference.Digested); ok {
-			// full image ID
-			return errors.Errorf("no manifest found for full image ID")
-		}
-		return errdefs.InvalidParameter(errors.Errorf("unknown image reference format: %s", image))
-	}
-
-	distrepo, _, err := s.backend.GetRepository(ctx, namedRef, config)
-	if err != nil {
-		return err
-	}
-	blobsrvc := distrepo.Blobs(ctx)
-
-	if canonicalRef, ok := namedRef.(reference.Canonical); !ok {
-		namedRef = reference.TagNameOnly(namedRef)
-
-		taggedRef, ok := namedRef.(reference.NamedTagged)
-		if !ok {
-			return errdefs.InvalidParameter(errors.Errorf("image reference not tagged: %s", image))
-		}
-
-		descriptor, err := distrepo.Tags(ctx).Get(ctx, taggedRef.Tag())
-		if err != nil {
-			return err
-		}
-		distributionInspect.Descriptor = v1.Descriptor{
-			MediaType: descriptor.MediaType,
-			Digest:    descriptor.Digest,
-			Size:      descriptor.Size,
-		}
-	} else {
-		// TODO(nishanttotla): Once manifests can be looked up as a blob, the
-		// descriptor should be set using blobsrvc.Stat(ctx, canonicalRef.Digest())
-		// instead of having to manually fill in the fields
-		distributionInspect.Descriptor.Digest = canonicalRef.Digest()
-	}
-
-	// we have a digest, so we can retrieve the manifest
-	mnfstsrvc, err := distrepo.Manifests(ctx)
-	if err != nil {
-		return err
-	}
-	mnfst, err := mnfstsrvc.Get(ctx, distributionInspect.Descriptor.Digest)
-	if err != nil {
-		switch err {
-		case reference.ErrReferenceInvalidFormat,
-			reference.ErrTagInvalidFormat,
-			reference.ErrDigestInvalidFormat,
-			reference.ErrNameContainsUppercase,
-			reference.ErrNameEmpty,
-			reference.ErrNameTooLong,
-			reference.ErrNameNotCanonical:
-			return errdefs.InvalidParameter(err)
-		}
-		return err
-	}
-
-	mediaType, payload, err := mnfst.Payload()
-	if err != nil {
-		return err
-	}
-	// update MediaType because registry might return something incorrect
-	distributionInspect.Descriptor.MediaType = mediaType
-	if distributionInspect.Descriptor.Size == 0 {
-		distributionInspect.Descriptor.Size = int64(len(payload))
-	}
-
-	// retrieve platform information depending on the type of manifest
-	switch mnfstObj := mnfst.(type) {
-	case *manifestlist.DeserializedManifestList:
-		for _, m := range mnfstObj.Manifests {
-			distributionInspect.Platforms = append(distributionInspect.Platforms, v1.Platform{
-				Architecture: m.Platform.Architecture,
-				OS:           m.Platform.OS,
-				OSVersion:    m.Platform.OSVersion,
-				OSFeatures:   m.Platform.OSFeatures,
-				Variant:      m.Platform.Variant,
-			})
-		}
-	case *schema2.DeserializedManifest:
-		configJSON, err := blobsrvc.Get(ctx, mnfstObj.Config.Digest)
-		var platform v1.Platform
-		if err == nil {
-			err := json.Unmarshal(configJSON, &platform)
-			if err == nil && (platform.OS != "" || platform.Architecture != "") {
-				distributionInspect.Platforms = append(distributionInspect.Platforms, platform)
-			}
-		}
-	case *schema1.SignedManifest:
-		platform := v1.Platform{
-			Architecture: mnfstObj.Architecture,
-			OS:           "linux",
-		}
-		distributionInspect.Platforms = append(distributionInspect.Platforms, platform)
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, distributionInspect)
-}
--- a/api/server/router/experimental.go
+++ b/api/server/router/experimental.go
@@ -1,68 +0,0 @@
-package router // import "github.com/docker/docker/api/server/router"
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/docker/docker/api/server/httputils"
-)
-
-// ExperimentalRoute defines an experimental API route that can be enabled or disabled.
-type ExperimentalRoute interface {
-	Route
-
-	Enable()
-	Disable()
-}
-
-// experimentalRoute defines an experimental API route that can be enabled or disabled.
-// It implements ExperimentalRoute
-type experimentalRoute struct {
-	local   Route
-	handler httputils.APIFunc
-}
-
-// Enable enables this experimental route
-func (r *experimentalRoute) Enable() {
-	r.handler = r.local.Handler()
-}
-
-// Disable disables the experimental route
-func (r *experimentalRoute) Disable() {
-	r.handler = experimentalHandler
-}
-
-type notImplementedError struct{}
-
-func (notImplementedError) Error() string {
-	return "This experimental feature is disabled by default. Start the Docker daemon in experimental mode in order to enable it."
-}
-
-func (notImplementedError) NotImplemented() {}
-
-func experimentalHandler(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	return notImplementedError{}
-}
-
-// Handler returns the APIFunc to let the server wrap it in middlewares.
-func (r *experimentalRoute) Handler() httputils.APIFunc {
-	return r.handler
-}
-
-// Method returns the http method that the route responds to.
-func (r *experimentalRoute) Method() string {
-	return r.local.Method()
-}
-
-// Path returns the subpath where the route responds to.
-func (r *experimentalRoute) Path() string {
-	return r.local.Path()
-}
-
-// Experimental will mark a route as experimental.
-func Experimental(r Route) Route {
-	return &experimentalRoute{
-		local:   r,
-		handler: experimentalHandler,
-	}
-}
--- a/api/server/router/grpc/backend.go
+++ b/api/server/router/grpc/backend.go
@@ -1,8 +0,0 @@
-package grpc // import "github.com/docker/docker/api/server/router/grpc"
-
-import "google.golang.org/grpc"
-
-// Backend abstracts a registerable GRPC service.
-type Backend interface {
-	RegisterGRPC(*grpc.Server)
-}
--- a/api/server/router/grpc/grpc.go
+++ b/api/server/router/grpc/grpc.go
@@ -1,37 +0,0 @@
-package grpc // import "github.com/docker/docker/api/server/router/grpc"
-
-import (
-	"github.com/docker/docker/api/server/router"
-	"golang.org/x/net/http2"
-	"google.golang.org/grpc"
-)
-
-type grpcRouter struct {
-	routes     []router.Route
-	grpcServer *grpc.Server
-	h2Server   *http2.Server
-}
-
-// NewRouter initializes a new grpc http router
-func NewRouter(backends ...Backend) router.Router {
-	r := &grpcRouter{
-		h2Server:   &http2.Server{},
-		grpcServer: grpc.NewServer(),
-	}
-	for _, b := range backends {
-		b.RegisterGRPC(r.grpcServer)
-	}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routers to the session controller
-func (r *grpcRouter) Routes() []router.Route {
-	return r.routes
-}
-
-func (r *grpcRouter) initRoutes() {
-	r.routes = []router.Route{
-		router.NewPostRoute("/grpc", r.serveGRPC),
-	}
-}
--- a/api/server/router/grpc/grpc_routes.go
+++ b/api/server/router/grpc/grpc_routes.go
@@ -1,45 +0,0 @@
-package grpc // import "github.com/docker/docker/api/server/router/grpc"
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/pkg/errors"
-	"golang.org/x/net/http2"
-)
-
-func (gr *grpcRouter) serveGRPC(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	h, ok := w.(http.Hijacker)
-	if !ok {
-		return errors.New("handler does not support hijack")
-	}
-	proto := r.Header.Get("Upgrade")
-	if proto == "" {
-		return errors.New("no upgrade proto in request")
-	}
-	if proto != "h2c" {
-		return errors.Errorf("protocol %s not supported", proto)
-	}
-
-	conn, _, err := h.Hijack()
-	if err != nil {
-		return err
-	}
-	resp := &http.Response{
-		StatusCode: http.StatusSwitchingProtocols,
-		ProtoMajor: 1,
-		ProtoMinor: 1,
-		Header:     http.Header{},
-	}
-	resp.Header.Set("Connection", "Upgrade")
-	resp.Header.Set("Upgrade", proto)
-
-	// set raw mode
-	conn.Write([]byte{})
-	resp.Write(conn)
-
-	// https://godoc.org/golang.org/x/net/http2#Server.ServeConn
-	// TODO: is it a problem that conn has already been written to?
-	gr.h2Server.ServeConn(conn, &http2.ServeConnOpts{Handler: gr.grpcServer})
-	return nil
-}
--- a/api/server/router/image/backend.go
+++ b/api/server/router/image/backend.go
@@ -1,41 +0,0 @@
-package image // import "github.com/docker/docker/api/server/router/image"
-
-import (
-	"context"
-	"io"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/image"
-	"github.com/docker/docker/api/types/registry"
-	specs "github.com/opencontainers/image-spec/specs-go/v1"
-)
-
-// Backend is all the methods that need to be implemented
-// to provide image specific functionality.
-type Backend interface {
-	imageBackend
-	importExportBackend
-	registryBackend
-}
-
-type imageBackend interface {
-	ImageDelete(imageRef string, force, prune bool) ([]types.ImageDeleteResponseItem, error)
-	ImageHistory(imageName string) ([]*image.HistoryResponseItem, error)
-	Images(imageFilters filters.Args, all bool, withExtraAttrs bool) ([]*types.ImageSummary, error)
-	LookupImage(name string) (*types.ImageInspect, error)
-	TagImage(imageName, repository, tag string) (string, error)
-	ImagesPrune(ctx context.Context, pruneFilters filters.Args) (*types.ImagesPruneReport, error)
-}
-
-type importExportBackend interface {
-	LoadImage(inTar io.ReadCloser, outStream io.Writer, quiet bool) error
-	ImportImage(src string, repository, platform string, tag string, msg string, inConfig io.ReadCloser, outStream io.Writer, changes []string) error
-	ExportImage(names []string, outStream io.Writer) error
-}
-
-type registryBackend interface {
-	PullImage(ctx context.Context, image, tag string, platform *specs.Platform, metaHeaders map[string][]string, authConfig *types.AuthConfig, outStream io.Writer) error
-	PushImage(ctx context.Context, image, tag string, metaHeaders map[string][]string, authConfig *types.AuthConfig, outStream io.Writer) error
-	SearchRegistryForImages(ctx context.Context, filtersArgs string, term string, limit int, authConfig *types.AuthConfig, metaHeaders map[string][]string) (*registry.SearchResults, error)
-}
--- a/api/server/router/image/image.go
+++ b/api/server/router/image/image.go
@@ -1,44 +0,0 @@
-package image // import "github.com/docker/docker/api/server/router/image"
-
-import (
-	"github.com/docker/docker/api/server/router"
-)
-
-// imageRouter is a router to talk with the image controller
-type imageRouter struct {
-	backend Backend
-	routes  []router.Route
-}
-
-// NewRouter initializes a new image router
-func NewRouter(backend Backend) router.Router {
-	r := &imageRouter{backend: backend}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routes to the image controller
-func (r *imageRouter) Routes() []router.Route {
-	return r.routes
-}
-
-// initRoutes initializes the routes in the image router
-func (r *imageRouter) initRoutes() {
-	r.routes = []router.Route{
-		// GET
-		router.NewGetRoute("/images/json", r.getImagesJSON),
-		router.NewGetRoute("/images/search", r.getImagesSearch),
-		router.NewGetRoute("/images/get", r.getImagesGet),
-		router.NewGetRoute("/images/{name:.*}/get", r.getImagesGet),
-		router.NewGetRoute("/images/{name:.*}/history", r.getImagesHistory),
-		router.NewGetRoute("/images/{name:.*}/json", r.getImagesByName),
-		// POST
-		router.NewPostRoute("/images/load", r.postImagesLoad),
-		router.NewPostRoute("/images/create", r.postImagesCreate),
-		router.NewPostRoute("/images/{name:.*}/push", r.postImagesPush),
-		router.NewPostRoute("/images/{name:.*}/tag", r.postImagesTag),
-		router.NewPostRoute("/images/prune", r.postImagesPrune),
-		// DELETE
-		router.NewDeleteRoute("/images/{name:.*}", r.deleteImages),
-	}
-}
--- a/api/server/router/image/image_routes.go
+++ b/api/server/router/image/image_routes.go
@@ -1,324 +0,0 @@
-package image // import "github.com/docker/docker/api/server/router/image"
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/containerd/containerd/platforms"
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/versions"
-	"github.com/docker/docker/errdefs"
-	"github.com/docker/docker/pkg/ioutils"
-	"github.com/docker/docker/pkg/streamformatter"
-	"github.com/docker/docker/pkg/system"
-	"github.com/docker/docker/registry"
-	specs "github.com/opencontainers/image-spec/specs-go/v1"
-	"github.com/pkg/errors"
-)
-
-// Creates an image from Pull or from Import
-func (s *imageRouter) postImagesCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	var (
-		image    = r.Form.Get("fromImage")
-		repo     = r.Form.Get("repo")
-		tag      = r.Form.Get("tag")
-		message  = r.Form.Get("message")
-		err      error
-		output   = ioutils.NewWriteFlusher(w)
-		platform *specs.Platform
-	)
-	defer output.Close()
-
-	w.Header().Set("Content-Type", "application/json")
-
-	version := httputils.VersionFromContext(ctx)
-	if versions.GreaterThanOrEqualTo(version, "1.32") {
-		apiPlatform := r.FormValue("platform")
-		if apiPlatform != "" {
-			sp, err := platforms.Parse(apiPlatform)
-			if err != nil {
-				return err
-			}
-			if err := system.ValidatePlatform(sp); err != nil {
-				return err
-			}
-			platform = &sp
-		}
-	}
-
-	if image != "" { // pull
-		metaHeaders := map[string][]string{}
-		for k, v := range r.Header {
-			if strings.HasPrefix(k, "X-Meta-") {
-				metaHeaders[k] = v
-			}
-		}
-
-		authEncoded := r.Header.Get("X-Registry-Auth")
-		authConfig := &types.AuthConfig{}
-		if authEncoded != "" {
-			authJSON := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
-			if err := json.NewDecoder(authJSON).Decode(authConfig); err != nil {
-				// for a pull it is not an error if no auth was given
-				// to increase compatibility with the existing api it is defaulting to be empty
-				authConfig = &types.AuthConfig{}
-			}
-		}
-		err = s.backend.PullImage(ctx, image, tag, platform, metaHeaders, authConfig, output)
-	} else { // import
-		src := r.Form.Get("fromSrc")
-		// 'err' MUST NOT be defined within this block, we need any error
-		// generated from the download to be available to the output
-		// stream processing below
-		os := ""
-		if platform != nil {
-			os = platform.OS
-		}
-		err = s.backend.ImportImage(src, repo, os, tag, message, r.Body, output, r.Form["changes"])
-	}
-	if err != nil {
-		if !output.Flushed() {
-			return err
-		}
-		_, _ = output.Write(streamformatter.FormatError(err))
-	}
-
-	return nil
-}
-
-func (s *imageRouter) postImagesPush(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	metaHeaders := map[string][]string{}
-	for k, v := range r.Header {
-		if strings.HasPrefix(k, "X-Meta-") {
-			metaHeaders[k] = v
-		}
-	}
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	authConfig := &types.AuthConfig{}
-
-	authEncoded := r.Header.Get("X-Registry-Auth")
-	if authEncoded != "" {
-		// the new format is to handle the authConfig as a header
-		authJSON := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
-		if err := json.NewDecoder(authJSON).Decode(authConfig); err != nil {
-			// to increase compatibility to existing api it is defaulting to be empty
-			authConfig = &types.AuthConfig{}
-		}
-	} else {
-		// the old format is supported for compatibility if there was no authConfig header
-		if err := json.NewDecoder(r.Body).Decode(authConfig); err != nil {
-			return errors.Wrap(errdefs.InvalidParameter(err), "Bad parameters and missing X-Registry-Auth")
-		}
-	}
-
-	image := vars["name"]
-	tag := r.Form.Get("tag")
-
-	output := ioutils.NewWriteFlusher(w)
-	defer output.Close()
-
-	w.Header().Set("Content-Type", "application/json")
-
-	if err := s.backend.PushImage(ctx, image, tag, metaHeaders, authConfig, output); err != nil {
-		if !output.Flushed() {
-			return err
-		}
-		_, _ = output.Write(streamformatter.FormatError(err))
-	}
-	return nil
-}
-
-func (s *imageRouter) getImagesGet(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	w.Header().Set("Content-Type", "application/x-tar")
-
-	output := ioutils.NewWriteFlusher(w)
-	defer output.Close()
-	var names []string
-	if name, ok := vars["name"]; ok {
-		names = []string{name}
-	} else {
-		names = r.Form["names"]
-	}
-
-	if err := s.backend.ExportImage(names, output); err != nil {
-		if !output.Flushed() {
-			return err
-		}
-		_, _ = output.Write(streamformatter.FormatError(err))
-	}
-	return nil
-}
-
-func (s *imageRouter) postImagesLoad(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	quiet := httputils.BoolValueOrDefault(r, "quiet", true)
-
-	w.Header().Set("Content-Type", "application/json")
-
-	output := ioutils.NewWriteFlusher(w)
-	defer output.Close()
-	if err := s.backend.LoadImage(r.Body, output, quiet); err != nil {
-		_, _ = output.Write(streamformatter.FormatError(err))
-	}
-	return nil
-}
-
-type missingImageError struct{}
-
-func (missingImageError) Error() string {
-	return "image name cannot be blank"
-}
-
-func (missingImageError) InvalidParameter() {}
-
-func (s *imageRouter) deleteImages(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	name := vars["name"]
-
-	if strings.TrimSpace(name) == "" {
-		return missingImageError{}
-	}
-
-	force := httputils.BoolValue(r, "force")
-	prune := !httputils.BoolValue(r, "noprune")
-
-	list, err := s.backend.ImageDelete(name, force, prune)
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, list)
-}
-
-func (s *imageRouter) getImagesByName(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	imageInspect, err := s.backend.LookupImage(vars["name"])
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, imageInspect)
-}
-
-func (s *imageRouter) getImagesJSON(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	imageFilters, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	version := httputils.VersionFromContext(ctx)
-	if versions.LessThan(version, "1.41") {
-		filterParam := r.Form.Get("filter")
-		if filterParam != "" {
-			imageFilters.Add("reference", filterParam)
-		}
-	}
-
-	images, err := s.backend.Images(imageFilters, httputils.BoolValue(r, "all"), false)
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, images)
-}
-
-func (s *imageRouter) getImagesHistory(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	name := vars["name"]
-	history, err := s.backend.ImageHistory(name)
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, history)
-}
-
-func (s *imageRouter) postImagesTag(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	if _, err := s.backend.TagImage(vars["name"], r.Form.Get("repo"), r.Form.Get("tag")); err != nil {
-		return err
-	}
-	w.WriteHeader(http.StatusCreated)
-	return nil
-}
-
-func (s *imageRouter) getImagesSearch(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	var (
-		config      *types.AuthConfig
-		authEncoded = r.Header.Get("X-Registry-Auth")
-		headers     = map[string][]string{}
-	)
-
-	if authEncoded != "" {
-		authJSON := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
-		if err := json.NewDecoder(authJSON).Decode(&config); err != nil {
-			// for a search it is not an error if no auth was given
-			// to increase compatibility with the existing api it is defaulting to be empty
-			config = &types.AuthConfig{}
-		}
-	}
-	for k, v := range r.Header {
-		if strings.HasPrefix(k, "X-Meta-") {
-			headers[k] = v
-		}
-	}
-	limit := registry.DefaultSearchLimit
-	if r.Form.Get("limit") != "" {
-		limitValue, err := strconv.Atoi(r.Form.Get("limit"))
-		if err != nil {
-			return err
-		}
-		limit = limitValue
-	}
-	query, err := s.backend.SearchRegistryForImages(ctx, r.Form.Get("filters"), r.Form.Get("term"), limit, config, headers)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, query.Results)
-}
-
-func (s *imageRouter) postImagesPrune(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	pruneFilters, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	pruneReport, err := s.backend.ImagesPrune(ctx, pruneFilters)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, pruneReport)
-}
--- a/api/server/router/local.go
+++ b/api/server/router/local.go
@@ -1,73 +0,0 @@
-package router // import "github.com/docker/docker/api/server/router"
-
-import (
-	"net/http"
-
-	"github.com/docker/docker/api/server/httputils"
-)
-
-// RouteWrapper wraps a route with extra functionality.
-// It is passed in when creating a new route.
-type RouteWrapper func(r Route) Route
-
-// localRoute defines an individual API route to connect
-// with the docker daemon. It implements Route.
-type localRoute struct {
-	method  string
-	path    string
-	handler httputils.APIFunc
-}
-
-// Handler returns the APIFunc to let the server wrap it in middlewares.
-func (l localRoute) Handler() httputils.APIFunc {
-	return l.handler
-}
-
-// Method returns the http method that the route responds to.
-func (l localRoute) Method() string {
-	return l.method
-}
-
-// Path returns the subpath where the route responds to.
-func (l localRoute) Path() string {
-	return l.path
-}
-
-// NewRoute initializes a new local route for the router.
-func NewRoute(method, path string, handler httputils.APIFunc, opts ...RouteWrapper) Route {
-	var r Route = localRoute{method, path, handler}
-	for _, o := range opts {
-		r = o(r)
-	}
-	return r
-}
-
-// NewGetRoute initializes a new route with the http method GET.
-func NewGetRoute(path string, handler httputils.APIFunc, opts ...RouteWrapper) Route {
-	return NewRoute(http.MethodGet, path, handler, opts...)
-}
-
-// NewPostRoute initializes a new route with the http method POST.
-func NewPostRoute(path string, handler httputils.APIFunc, opts ...RouteWrapper) Route {
-	return NewRoute(http.MethodPost, path, handler, opts...)
-}
-
-// NewPutRoute initializes a new route with the http method PUT.
-func NewPutRoute(path string, handler httputils.APIFunc, opts ...RouteWrapper) Route {
-	return NewRoute(http.MethodPut, path, handler, opts...)
-}
-
-// NewDeleteRoute initializes a new route with the http method DELETE.
-func NewDeleteRoute(path string, handler httputils.APIFunc, opts ...RouteWrapper) Route {
-	return NewRoute(http.MethodDelete, path, handler, opts...)
-}
-
-// NewOptionsRoute initializes a new route with the http method OPTIONS.
-func NewOptionsRoute(path string, handler httputils.APIFunc, opts ...RouteWrapper) Route {
-	return NewRoute(http.MethodOptions, path, handler, opts...)
-}
-
-// NewHeadRoute initializes a new route with the http method HEAD.
-func NewHeadRoute(path string, handler httputils.APIFunc, opts ...RouteWrapper) Route {
-	return NewRoute(http.MethodHead, path, handler, opts...)
-}
--- a/api/server/router/network/backend.go
+++ b/api/server/router/network/backend.go
@@ -1,32 +0,0 @@
-package network // import "github.com/docker/docker/api/server/router/network"
-
-import (
-	"context"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/network"
-	"github.com/docker/libnetwork"
-)
-
-// Backend is all the methods that need to be implemented
-// to provide network specific functionality.
-type Backend interface {
-	FindNetwork(idName string) (libnetwork.Network, error)
-	GetNetworks(filters.Args, types.NetworkListConfig) ([]types.NetworkResource, error)
-	CreateNetwork(nc types.NetworkCreateRequest) (*types.NetworkCreateResponse, error)
-	ConnectContainerToNetwork(containerName, networkName string, endpointConfig *network.EndpointSettings) error
-	DisconnectContainerFromNetwork(containerName string, networkName string, force bool) error
-	DeleteNetwork(networkID string) error
-	NetworksPrune(ctx context.Context, pruneFilters filters.Args) (*types.NetworksPruneReport, error)
-}
-
-// ClusterBackend is all the methods that need to be implemented
-// to provide cluster network specific functionality.
-type ClusterBackend interface {
-	GetNetworks(filters.Args) ([]types.NetworkResource, error)
-	GetNetwork(name string) (types.NetworkResource, error)
-	GetNetworksByName(name string) ([]types.NetworkResource, error)
-	CreateNetwork(nc types.NetworkCreateRequest) (string, error)
-	RemoveNetwork(name string) error
-}
--- a/api/server/router/network/filter.go
+++ b/api/server/router/network/filter.go
@@ -1 +0,0 @@
-package network // import "github.com/docker/docker/api/server/router/network"
--- a/api/server/router/network/network.go
+++ b/api/server/router/network/network.go
@@ -1,43 +0,0 @@
-package network // import "github.com/docker/docker/api/server/router/network"
-
-import (
-	"github.com/docker/docker/api/server/router"
-)
-
-// networkRouter is a router to talk with the network controller
-type networkRouter struct {
-	backend Backend
-	cluster ClusterBackend
-	routes  []router.Route
-}
-
-// NewRouter initializes a new network router
-func NewRouter(b Backend, c ClusterBackend) router.Router {
-	r := &networkRouter{
-		backend: b,
-		cluster: c,
-	}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routes to the network controller
-func (r *networkRouter) Routes() []router.Route {
-	return r.routes
-}
-
-func (r *networkRouter) initRoutes() {
-	r.routes = []router.Route{
-		// GET
-		router.NewGetRoute("/networks", r.getNetworksList),
-		router.NewGetRoute("/networks/", r.getNetworksList),
-		router.NewGetRoute("/networks/{id:.+}", r.getNetwork),
-		// POST
-		router.NewPostRoute("/networks/create", r.postNetworkCreate),
-		router.NewPostRoute("/networks/{id:.*}/connect", r.postNetworkConnect),
-		router.NewPostRoute("/networks/{id:.*}/disconnect", r.postNetworkDisconnect),
-		router.NewPostRoute("/networks/prune", r.postNetworksPrune),
-		// DELETE
-		router.NewDeleteRoute("/networks/{id:.*}", r.deleteNetwork),
-	}
-}
--- a/api/server/router/network/network_routes.go
+++ b/api/server/router/network/network_routes.go
@@ -1,414 +0,0 @@
-package network // import "github.com/docker/docker/api/server/router/network"
-
-import (
-	"context"
-	"encoding/json"
-	"io"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/network"
-	"github.com/docker/docker/api/types/versions"
-	"github.com/docker/docker/errdefs"
-	"github.com/docker/libnetwork"
-	netconst "github.com/docker/libnetwork/datastore"
-	"github.com/pkg/errors"
-)
-
-func (n *networkRouter) getNetworksList(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	filter, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	if err := network.ValidateFilters(filter); err != nil {
-		return errdefs.InvalidParameter(err)
-	}
-
-	var list []types.NetworkResource
-	nr, err := n.cluster.GetNetworks(filter)
-	if err == nil {
-		list = nr
-	}
-
-	// Combine the network list returned by Docker daemon if it is not already
-	// returned by the cluster manager
-	localNetworks, err := n.backend.GetNetworks(filter, types.NetworkListConfig{Detailed: versions.LessThan(httputils.VersionFromContext(ctx), "1.28")})
-	if err != nil {
-		return err
-	}
-
-	var idx map[string]bool
-	if len(list) > 0 {
-		idx = make(map[string]bool, len(list))
-		for _, n := range list {
-			idx[n.ID] = true
-		}
-	}
-	for _, n := range localNetworks {
-		if idx[n.ID] {
-			continue
-		}
-		list = append(list, n)
-	}
-
-	if list == nil {
-		list = []types.NetworkResource{}
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, list)
-}
-
-type invalidRequestError struct {
-	cause error
-}
-
-func (e invalidRequestError) Error() string {
-	return e.cause.Error()
-}
-
-func (e invalidRequestError) InvalidParameter() {}
-
-type ambigousResultsError string
-
-func (e ambigousResultsError) Error() string {
-	return "network " + string(e) + " is ambiguous"
-}
-
-func (ambigousResultsError) InvalidParameter() {}
-
-func nameConflict(name string) error {
-	return errdefs.Conflict(libnetwork.NetworkNameError(name))
-}
-
-func (n *networkRouter) getNetwork(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	term := vars["id"]
-	var (
-		verbose bool
-		err     error
-	)
-	if v := r.URL.Query().Get("verbose"); v != "" {
-		if verbose, err = strconv.ParseBool(v); err != nil {
-			return errors.Wrapf(invalidRequestError{err}, "invalid value for verbose: %s", v)
-		}
-	}
-	scope := r.URL.Query().Get("scope")
-
-	// In case multiple networks have duplicate names, return error.
-	// TODO (yongtang): should we wrap with version here for backward compatibility?
-
-	// First find based on full ID, return immediately once one is found.
-	// If a network appears both in swarm and local, assume it is in local first
-
-	// For full name and partial ID, save the result first, and process later
-	// in case multiple records was found based on the same term
-	listByFullName := map[string]types.NetworkResource{}
-	listByPartialID := map[string]types.NetworkResource{}
-
-	// TODO(@cpuguy83): All this logic for figuring out which network to return does not belong here
-	// Instead there should be a backend function to just get one network.
-	filter := filters.NewArgs(filters.Arg("idOrName", term))
-	if scope != "" {
-		filter.Add("scope", scope)
-	}
-	nw, _ := n.backend.GetNetworks(filter, types.NetworkListConfig{Detailed: true, Verbose: verbose})
-	for _, network := range nw {
-		if network.ID == term {
-			return httputils.WriteJSON(w, http.StatusOK, network)
-		}
-		if network.Name == term {
-			// No need to check the ID collision here as we are still in
-			// local scope and the network ID is unique in this scope.
-			listByFullName[network.ID] = network
-		}
-		if strings.HasPrefix(network.ID, term) {
-			// No need to check the ID collision here as we are still in
-			// local scope and the network ID is unique in this scope.
-			listByPartialID[network.ID] = network
-		}
-	}
-
-	nwk, err := n.cluster.GetNetwork(term)
-	if err == nil {
-		// If the get network is passed with a specific network ID / partial network ID
-		// or if the get network was passed with a network name and scope as swarm
-		// return the network. Skipped using isMatchingScope because it is true if the scope
-		// is not set which would be case if the client API v1.30
-		if strings.HasPrefix(nwk.ID, term) || (netconst.SwarmScope == scope) {
-			// If we have a previous match "backend", return it, we need verbose when enabled
-			// ex: overlay/partial_ID or name/swarm_scope
-			if nwv, ok := listByPartialID[nwk.ID]; ok {
-				nwk = nwv
-			} else if nwv, ok := listByFullName[nwk.ID]; ok {
-				nwk = nwv
-			}
-			return httputils.WriteJSON(w, http.StatusOK, nwk)
-		}
-	}
-
-	nr, _ := n.cluster.GetNetworks(filter)
-	for _, network := range nr {
-		if network.ID == term {
-			return httputils.WriteJSON(w, http.StatusOK, network)
-		}
-		if network.Name == term {
-			// Check the ID collision as we are in swarm scope here, and
-			// the map (of the listByFullName) may have already had a
-			// network with the same ID (from local scope previously)
-			if _, ok := listByFullName[network.ID]; !ok {
-				listByFullName[network.ID] = network
-			}
-		}
-		if strings.HasPrefix(network.ID, term) {
-			// Check the ID collision as we are in swarm scope here, and
-			// the map (of the listByPartialID) may have already had a
-			// network with the same ID (from local scope previously)
-			if _, ok := listByPartialID[network.ID]; !ok {
-				listByPartialID[network.ID] = network
-			}
-		}
-	}
-
-	// Find based on full name, returns true only if no duplicates
-	if len(listByFullName) == 1 {
-		for _, v := range listByFullName {
-			return httputils.WriteJSON(w, http.StatusOK, v)
-		}
-	}
-	if len(listByFullName) > 1 {
-		return errors.Wrapf(ambigousResultsError(term), "%d matches found based on name", len(listByFullName))
-	}
-
-	// Find based on partial ID, returns true only if no duplicates
-	if len(listByPartialID) == 1 {
-		for _, v := range listByPartialID {
-			return httputils.WriteJSON(w, http.StatusOK, v)
-		}
-	}
-	if len(listByPartialID) > 1 {
-		return errors.Wrapf(ambigousResultsError(term), "%d matches found based on ID prefix", len(listByPartialID))
-	}
-
-	return libnetwork.ErrNoSuchNetwork(term)
-}
-
-func (n *networkRouter) postNetworkCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var create types.NetworkCreateRequest
-
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	if err := httputils.CheckForJSON(r); err != nil {
-		return err
-	}
-
-	if err := json.NewDecoder(r.Body).Decode(&create); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	if nws, err := n.cluster.GetNetworksByName(create.Name); err == nil && len(nws) > 0 {
-		return nameConflict(create.Name)
-	}
-
-	nw, err := n.backend.CreateNetwork(create)
-	if err != nil {
-		var warning string
-		if _, ok := err.(libnetwork.NetworkNameError); ok {
-			// check if user defined CheckDuplicate, if set true, return err
-			// otherwise prepare a warning message
-			if create.CheckDuplicate {
-				return nameConflict(create.Name)
-			}
-			warning = libnetwork.NetworkNameError(create.Name).Error()
-		}
-
-		if _, ok := err.(libnetwork.ManagerRedirectError); !ok {
-			return err
-		}
-		id, err := n.cluster.CreateNetwork(create)
-		if err != nil {
-			return err
-		}
-		nw = &types.NetworkCreateResponse{
-			ID:      id,
-			Warning: warning,
-		}
-	}
-
-	return httputils.WriteJSON(w, http.StatusCreated, nw)
-}
-
-func (n *networkRouter) postNetworkConnect(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var connect types.NetworkConnect
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	if err := httputils.CheckForJSON(r); err != nil {
-		return err
-	}
-
-	if err := json.NewDecoder(r.Body).Decode(&connect); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	// Unlike other operations, we does not check ambiguity of the name/ID here.
-	// The reason is that, In case of attachable network in swarm scope, the actual local network
-	// may not be available at the time. At the same time, inside daemon `ConnectContainerToNetwork`
-	// does the ambiguity check anyway. Therefore, passing the name to daemon would be enough.
-	return n.backend.ConnectContainerToNetwork(connect.Container, vars["id"], connect.EndpointConfig)
-}
-
-func (n *networkRouter) postNetworkDisconnect(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var disconnect types.NetworkDisconnect
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	if err := httputils.CheckForJSON(r); err != nil {
-		return err
-	}
-
-	if err := json.NewDecoder(r.Body).Decode(&disconnect); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	return n.backend.DisconnectContainerFromNetwork(disconnect.Container, vars["id"], disconnect.Force)
-}
-
-func (n *networkRouter) deleteNetwork(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	nw, err := n.findUniqueNetwork(vars["id"])
-	if err != nil {
-		return err
-	}
-	if nw.Scope == "swarm" {
-		if err = n.cluster.RemoveNetwork(nw.ID); err != nil {
-			return err
-		}
-	} else {
-		if err := n.backend.DeleteNetwork(nw.ID); err != nil {
-			return err
-		}
-	}
-	w.WriteHeader(http.StatusNoContent)
-	return nil
-}
-
-func (n *networkRouter) postNetworksPrune(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	pruneFilters, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	pruneReport, err := n.backend.NetworksPrune(ctx, pruneFilters)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, pruneReport)
-}
-
-// findUniqueNetwork will search network across different scopes (both local and swarm).
-// NOTE: This findUniqueNetwork is different from FindNetwork in the daemon.
-// In case multiple networks have duplicate names, return error.
-// First find based on full ID, return immediately once one is found.
-// If a network appears both in swarm and local, assume it is in local first
-// For full name and partial ID, save the result first, and process later
-// in case multiple records was found based on the same term
-// TODO (yongtang): should we wrap with version here for backward compatibility?
-func (n *networkRouter) findUniqueNetwork(term string) (types.NetworkResource, error) {
-	listByFullName := map[string]types.NetworkResource{}
-	listByPartialID := map[string]types.NetworkResource{}
-
-	filter := filters.NewArgs(filters.Arg("idOrName", term))
-	nw, _ := n.backend.GetNetworks(filter, types.NetworkListConfig{Detailed: true})
-	for _, network := range nw {
-		if network.ID == term {
-			return network, nil
-		}
-		if network.Name == term && !network.Ingress {
-			// No need to check the ID collision here as we are still in
-			// local scope and the network ID is unique in this scope.
-			listByFullName[network.ID] = network
-		}
-		if strings.HasPrefix(network.ID, term) {
-			// No need to check the ID collision here as we are still in
-			// local scope and the network ID is unique in this scope.
-			listByPartialID[network.ID] = network
-		}
-	}
-
-	nr, _ := n.cluster.GetNetworks(filter)
-	for _, network := range nr {
-		if network.ID == term {
-			return network, nil
-		}
-		if network.Name == term {
-			// Check the ID collision as we are in swarm scope here, and
-			// the map (of the listByFullName) may have already had a
-			// network with the same ID (from local scope previously)
-			if _, ok := listByFullName[network.ID]; !ok {
-				listByFullName[network.ID] = network
-			}
-		}
-		if strings.HasPrefix(network.ID, term) {
-			// Check the ID collision as we are in swarm scope here, and
-			// the map (of the listByPartialID) may have already had a
-			// network with the same ID (from local scope previously)
-			if _, ok := listByPartialID[network.ID]; !ok {
-				listByPartialID[network.ID] = network
-			}
-		}
-	}
-
-	// Find based on full name, returns true only if no duplicates
-	if len(listByFullName) == 1 {
-		for _, v := range listByFullName {
-			return v, nil
-		}
-	}
-	if len(listByFullName) > 1 {
-		return types.NetworkResource{}, errdefs.InvalidParameter(errors.Errorf("network %s is ambiguous (%d matches found based on name)", term, len(listByFullName)))
-	}
-
-	// Find based on partial ID, returns true only if no duplicates
-	if len(listByPartialID) == 1 {
-		for _, v := range listByPartialID {
-			return v, nil
-		}
-	}
-	if len(listByPartialID) > 1 {
-		return types.NetworkResource{}, errdefs.InvalidParameter(errors.Errorf("network %s is ambiguous (%d matches found based on ID prefix)", term, len(listByPartialID)))
-	}
-
-	return types.NetworkResource{}, errdefs.NotFound(libnetwork.ErrNoSuchNetwork(term))
-}
--- a/api/server/router/plugin/backend.go
+++ b/api/server/router/plugin/backend.go
@@ -1,27 +0,0 @@
-package plugin // import "github.com/docker/docker/api/server/router/plugin"
-
-import (
-	"context"
-	"io"
-	"net/http"
-
-	"github.com/docker/distribution/reference"
-	enginetypes "github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/plugin"
-)
-
-// Backend for Plugin
-type Backend interface {
-	Disable(name string, config *enginetypes.PluginDisableConfig) error
-	Enable(name string, config *enginetypes.PluginEnableConfig) error
-	List(filters.Args) ([]enginetypes.Plugin, error)
-	Inspect(name string) (*enginetypes.Plugin, error)
-	Remove(name string, config *enginetypes.PluginRmConfig) error
-	Set(name string, args []string) error
-	Privileges(ctx context.Context, ref reference.Named, metaHeaders http.Header, authConfig *enginetypes.AuthConfig) (enginetypes.PluginPrivileges, error)
-	Pull(ctx context.Context, ref reference.Named, name string, metaHeaders http.Header, authConfig *enginetypes.AuthConfig, privileges enginetypes.PluginPrivileges, outStream io.Writer, opts ...plugin.CreateOpt) error
-	Push(ctx context.Context, name string, metaHeaders http.Header, authConfig *enginetypes.AuthConfig, outStream io.Writer) error
-	Upgrade(ctx context.Context, ref reference.Named, name string, metaHeaders http.Header, authConfig *enginetypes.AuthConfig, privileges enginetypes.PluginPrivileges, outStream io.Writer) error
-	CreateFromContext(ctx context.Context, tarCtx io.ReadCloser, options *enginetypes.PluginCreateOptions) error
-}
--- a/api/server/router/plugin/plugin.go
+++ b/api/server/router/plugin/plugin.go
@@ -1,39 +0,0 @@
-package plugin // import "github.com/docker/docker/api/server/router/plugin"
-
-import "github.com/docker/docker/api/server/router"
-
-// pluginRouter is a router to talk with the plugin controller
-type pluginRouter struct {
-	backend Backend
-	routes  []router.Route
-}
-
-// NewRouter initializes a new plugin router
-func NewRouter(b Backend) router.Router {
-	r := &pluginRouter{
-		backend: b,
-	}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routers to the plugin controller
-func (r *pluginRouter) Routes() []router.Route {
-	return r.routes
-}
-
-func (r *pluginRouter) initRoutes() {
-	r.routes = []router.Route{
-		router.NewGetRoute("/plugins", r.listPlugins),
-		router.NewGetRoute("/plugins/{name:.*}/json", r.inspectPlugin),
-		router.NewGetRoute("/plugins/privileges", r.getPrivileges),
-		router.NewDeleteRoute("/plugins/{name:.*}", r.removePlugin),
-		router.NewPostRoute("/plugins/{name:.*}/enable", r.enablePlugin),
-		router.NewPostRoute("/plugins/{name:.*}/disable", r.disablePlugin),
-		router.NewPostRoute("/plugins/pull", r.pullPlugin),
-		router.NewPostRoute("/plugins/{name:.*}/push", r.pushPlugin),
-		router.NewPostRoute("/plugins/{name:.*}/upgrade", r.upgradePlugin),
-		router.NewPostRoute("/plugins/{name:.*}/set", r.setPlugin),
-		router.NewPostRoute("/plugins/create", r.createPlugin),
-	}
-}
--- a/api/server/router/plugin/plugin_routes.go
+++ b/api/server/router/plugin/plugin_routes.go
@@ -1,315 +0,0 @@
-package plugin // import "github.com/docker/docker/api/server/router/plugin"
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"io"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/docker/distribution/reference"
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/errdefs"
-	"github.com/docker/docker/pkg/ioutils"
-	"github.com/docker/docker/pkg/streamformatter"
-	"github.com/pkg/errors"
-)
-
-func parseHeaders(headers http.Header) (map[string][]string, *types.AuthConfig) {
-
-	metaHeaders := map[string][]string{}
-	for k, v := range headers {
-		if strings.HasPrefix(k, "X-Meta-") {
-			metaHeaders[k] = v
-		}
-	}
-
-	// Get X-Registry-Auth
-	authEncoded := headers.Get("X-Registry-Auth")
-	authConfig := &types.AuthConfig{}
-	if authEncoded != "" {
-		authJSON := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
-		if err := json.NewDecoder(authJSON).Decode(authConfig); err != nil {
-			authConfig = &types.AuthConfig{}
-		}
-	}
-
-	return metaHeaders, authConfig
-}
-
-// parseRemoteRef parses the remote reference into a reference.Named
-// returning the tag associated with the reference. In the case the
-// given reference string includes both digest and tag, the returned
-// reference will have the digest without the tag, but the tag will
-// be returned.
-func parseRemoteRef(remote string) (reference.Named, string, error) {
-	// Parse remote reference, supporting remotes with name and tag
-	remoteRef, err := reference.ParseNormalizedNamed(remote)
-	if err != nil {
-		return nil, "", err
-	}
-
-	type canonicalWithTag interface {
-		reference.Canonical
-		Tag() string
-	}
-
-	if canonical, ok := remoteRef.(canonicalWithTag); ok {
-		remoteRef, err = reference.WithDigest(reference.TrimNamed(remoteRef), canonical.Digest())
-		if err != nil {
-			return nil, "", err
-		}
-		return remoteRef, canonical.Tag(), nil
-	}
-
-	remoteRef = reference.TagNameOnly(remoteRef)
-
-	return remoteRef, "", nil
-}
-
-func (pr *pluginRouter) getPrivileges(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	metaHeaders, authConfig := parseHeaders(r.Header)
-
-	ref, _, err := parseRemoteRef(r.FormValue("remote"))
-	if err != nil {
-		return err
-	}
-
-	privileges, err := pr.backend.Privileges(ctx, ref, metaHeaders, authConfig)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, privileges)
-}
-
-func (pr *pluginRouter) upgradePlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return errors.Wrap(err, "failed to parse form")
-	}
-
-	var privileges types.PluginPrivileges
-	dec := json.NewDecoder(r.Body)
-	if err := dec.Decode(&privileges); err != nil {
-		return errors.Wrap(err, "failed to parse privileges")
-	}
-	if dec.More() {
-		return errors.New("invalid privileges")
-	}
-
-	metaHeaders, authConfig := parseHeaders(r.Header)
-	ref, tag, err := parseRemoteRef(r.FormValue("remote"))
-	if err != nil {
-		return err
-	}
-
-	name, err := getName(ref, tag, vars["name"])
-	if err != nil {
-		return err
-	}
-	w.Header().Set("Docker-Plugin-Name", name)
-
-	w.Header().Set("Content-Type", "application/json")
-	output := ioutils.NewWriteFlusher(w)
-
-	if err := pr.backend.Upgrade(ctx, ref, name, metaHeaders, authConfig, privileges, output); err != nil {
-		if !output.Flushed() {
-			return err
-		}
-		_, _ = output.Write(streamformatter.FormatError(err))
-	}
-
-	return nil
-}
-
-func (pr *pluginRouter) pullPlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return errors.Wrap(err, "failed to parse form")
-	}
-
-	var privileges types.PluginPrivileges
-	dec := json.NewDecoder(r.Body)
-	if err := dec.Decode(&privileges); err != nil {
-		return errors.Wrap(err, "failed to parse privileges")
-	}
-	if dec.More() {
-		return errors.New("invalid privileges")
-	}
-
-	metaHeaders, authConfig := parseHeaders(r.Header)
-	ref, tag, err := parseRemoteRef(r.FormValue("remote"))
-	if err != nil {
-		return err
-	}
-
-	name, err := getName(ref, tag, r.FormValue("name"))
-	if err != nil {
-		return err
-	}
-	w.Header().Set("Docker-Plugin-Name", name)
-
-	w.Header().Set("Content-Type", "application/json")
-	output := ioutils.NewWriteFlusher(w)
-
-	if err := pr.backend.Pull(ctx, ref, name, metaHeaders, authConfig, privileges, output); err != nil {
-		if !output.Flushed() {
-			return err
-		}
-		_, _ = output.Write(streamformatter.FormatError(err))
-	}
-
-	return nil
-}
-
-func getName(ref reference.Named, tag, name string) (string, error) {
-	if name == "" {
-		if _, ok := ref.(reference.Canonical); ok {
-			trimmed := reference.TrimNamed(ref)
-			if tag != "" {
-				nt, err := reference.WithTag(trimmed, tag)
-				if err != nil {
-					return "", err
-				}
-				name = reference.FamiliarString(nt)
-			} else {
-				name = reference.FamiliarString(reference.TagNameOnly(trimmed))
-			}
-		} else {
-			name = reference.FamiliarString(ref)
-		}
-	} else {
-		localRef, err := reference.ParseNormalizedNamed(name)
-		if err != nil {
-			return "", err
-		}
-		if _, ok := localRef.(reference.Canonical); ok {
-			return "", errors.New("cannot use digest in plugin tag")
-		}
-		if reference.IsNameOnly(localRef) {
-			// TODO: log change in name to out stream
-			name = reference.FamiliarString(reference.TagNameOnly(localRef))
-		}
-	}
-	return name, nil
-}
-
-func (pr *pluginRouter) createPlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	options := &types.PluginCreateOptions{
-		RepoName: r.FormValue("name")}
-
-	if err := pr.backend.CreateFromContext(ctx, r.Body, options); err != nil {
-		return err
-	}
-	// TODO: send progress bar
-	w.WriteHeader(http.StatusNoContent)
-	return nil
-}
-
-func (pr *pluginRouter) enablePlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	name := vars["name"]
-	timeout, err := strconv.Atoi(r.Form.Get("timeout"))
-	if err != nil {
-		return err
-	}
-	config := &types.PluginEnableConfig{Timeout: timeout}
-
-	return pr.backend.Enable(name, config)
-}
-
-func (pr *pluginRouter) disablePlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	name := vars["name"]
-	config := &types.PluginDisableConfig{
-		ForceDisable: httputils.BoolValue(r, "force"),
-	}
-
-	return pr.backend.Disable(name, config)
-}
-
-func (pr *pluginRouter) removePlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	name := vars["name"]
-	config := &types.PluginRmConfig{
-		ForceRemove: httputils.BoolValue(r, "force"),
-	}
-	return pr.backend.Remove(name, config)
-}
-
-func (pr *pluginRouter) pushPlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return errors.Wrap(err, "failed to parse form")
-	}
-
-	metaHeaders, authConfig := parseHeaders(r.Header)
-
-	w.Header().Set("Content-Type", "application/json")
-	output := ioutils.NewWriteFlusher(w)
-
-	if err := pr.backend.Push(ctx, vars["name"], metaHeaders, authConfig, output); err != nil {
-		if !output.Flushed() {
-			return err
-		}
-		_, _ = output.Write(streamformatter.FormatError(err))
-	}
-	return nil
-}
-
-func (pr *pluginRouter) setPlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var args []string
-	if err := json.NewDecoder(r.Body).Decode(&args); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-	if err := pr.backend.Set(vars["name"], args); err != nil {
-		return err
-	}
-	w.WriteHeader(http.StatusNoContent)
-	return nil
-}
-
-func (pr *pluginRouter) listPlugins(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	pluginFilters, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-	l, err := pr.backend.List(pluginFilters)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, l)
-}
-
-func (pr *pluginRouter) inspectPlugin(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	result, err := pr.backend.Inspect(vars["name"])
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, result)
-}
--- a/api/server/router/router.go
+++ b/api/server/router/router.go
@@ -1,19 +0,0 @@
-package router // import "github.com/docker/docker/api/server/router"
-
-import "github.com/docker/docker/api/server/httputils"
-
-// Router defines an interface to specify a group of routes to add to the docker server.
-type Router interface {
-	// Routes returns the list of routes to add to the docker server.
-	Routes() []Route
-}
-
-// Route defines an individual API route in the docker server.
-type Route interface {
-	// Handler returns the raw function to create the http handler.
-	Handler() httputils.APIFunc
-	// Method returns the http method that the route responds to.
-	Method() string
-	// Path returns the subpath where the route responds to.
-	Path() string
-}
--- a/api/server/router/session/backend.go
+++ b/api/server/router/session/backend.go
@@ -1,11 +0,0 @@
-package session // import "github.com/docker/docker/api/server/router/session"
-
-import (
-	"context"
-	"net/http"
-)
-
-// Backend abstracts an session receiver from an http request.
-type Backend interface {
-	HandleHTTPRequest(ctx context.Context, w http.ResponseWriter, r *http.Request) error
-}
--- a/api/server/router/session/session.go
+++ b/api/server/router/session/session.go
@@ -1,29 +0,0 @@
-package session // import "github.com/docker/docker/api/server/router/session"
-
-import "github.com/docker/docker/api/server/router"
-
-// sessionRouter is a router to talk with the session controller
-type sessionRouter struct {
-	backend Backend
-	routes  []router.Route
-}
-
-// NewRouter initializes a new session router
-func NewRouter(b Backend) router.Router {
-	r := &sessionRouter{
-		backend: b,
-	}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routers to the session controller
-func (r *sessionRouter) Routes() []router.Route {
-	return r.routes
-}
-
-func (r *sessionRouter) initRoutes() {
-	r.routes = []router.Route{
-		router.NewPostRoute("/session", r.startSession),
-	}
-}
--- a/api/server/router/session/session_routes.go
+++ b/api/server/router/session/session_routes.go
@@ -1,16 +0,0 @@
-package session // import "github.com/docker/docker/api/server/router/session"
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/docker/docker/errdefs"
-)
-
-func (sr *sessionRouter) startSession(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	err := sr.backend.HandleHTTPRequest(ctx, w, r)
-	if err != nil {
-		return errdefs.InvalidParameter(err)
-	}
-	return nil
-}
--- a/api/server/router/swarm/backend.go
+++ b/api/server/router/swarm/backend.go
@@ -1,48 +0,0 @@
-package swarm // import "github.com/docker/docker/api/server/router/swarm"
-
-import (
-	"context"
-
-	basictypes "github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/backend"
-	types "github.com/docker/docker/api/types/swarm"
-)
-
-// Backend abstracts a swarm manager.
-type Backend interface {
-	Init(req types.InitRequest) (string, error)
-	Join(req types.JoinRequest) error
-	Leave(force bool) error
-	Inspect() (types.Swarm, error)
-	Update(uint64, types.Spec, types.UpdateFlags) error
-	GetUnlockKey() (string, error)
-	UnlockSwarm(req types.UnlockRequest) error
-
-	GetServices(basictypes.ServiceListOptions) ([]types.Service, error)
-	GetService(idOrName string, insertDefaults bool) (types.Service, error)
-	CreateService(types.ServiceSpec, string, bool) (*basictypes.ServiceCreateResponse, error)
-	UpdateService(string, uint64, types.ServiceSpec, basictypes.ServiceUpdateOptions, bool) (*basictypes.ServiceUpdateResponse, error)
-	RemoveService(string) error
-
-	ServiceLogs(context.Context, *backend.LogSelector, *basictypes.ContainerLogsOptions) (<-chan *backend.LogMessage, error)
-
-	GetNodes(basictypes.NodeListOptions) ([]types.Node, error)
-	GetNode(string) (types.Node, error)
-	UpdateNode(string, uint64, types.NodeSpec) error
-	RemoveNode(string, bool) error
-
-	GetTasks(basictypes.TaskListOptions) ([]types.Task, error)
-	GetTask(string) (types.Task, error)
-
-	GetSecrets(opts basictypes.SecretListOptions) ([]types.Secret, error)
-	CreateSecret(s types.SecretSpec) (string, error)
-	RemoveSecret(idOrName string) error
-	GetSecret(id string) (types.Secret, error)
-	UpdateSecret(idOrName string, version uint64, spec types.SecretSpec) error
-
-	GetConfigs(opts basictypes.ConfigListOptions) ([]types.Config, error)
-	CreateConfig(s types.ConfigSpec) (string, error)
-	RemoveConfig(id string) error
-	GetConfig(id string) (types.Config, error)
-	UpdateConfig(idOrName string, version uint64, spec types.ConfigSpec) error
-}
--- a/api/server/router/swarm/cluster.go
+++ b/api/server/router/swarm/cluster.go
@@ -1,63 +0,0 @@
-package swarm // import "github.com/docker/docker/api/server/router/swarm"
-
-import "github.com/docker/docker/api/server/router"
-
-// swarmRouter is a router to talk with the build controller
-type swarmRouter struct {
-	backend Backend
-	routes  []router.Route
-}
-
-// NewRouter initializes a new build router
-func NewRouter(b Backend) router.Router {
-	r := &swarmRouter{
-		backend: b,
-	}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routers to the swarm controller
-func (sr *swarmRouter) Routes() []router.Route {
-	return sr.routes
-}
-
-func (sr *swarmRouter) initRoutes() {
-	sr.routes = []router.Route{
-		router.NewPostRoute("/swarm/init", sr.initCluster),
-		router.NewPostRoute("/swarm/join", sr.joinCluster),
-		router.NewPostRoute("/swarm/leave", sr.leaveCluster),
-		router.NewGetRoute("/swarm", sr.inspectCluster),
-		router.NewGetRoute("/swarm/unlockkey", sr.getUnlockKey),
-		router.NewPostRoute("/swarm/update", sr.updateCluster),
-		router.NewPostRoute("/swarm/unlock", sr.unlockCluster),
-
-		router.NewGetRoute("/services", sr.getServices),
-		router.NewGetRoute("/services/{id}", sr.getService),
-		router.NewPostRoute("/services/create", sr.createService),
-		router.NewPostRoute("/services/{id}/update", sr.updateService),
-		router.NewDeleteRoute("/services/{id}", sr.removeService),
-		router.NewGetRoute("/services/{id}/logs", sr.getServiceLogs),
-
-		router.NewGetRoute("/nodes", sr.getNodes),
-		router.NewGetRoute("/nodes/{id}", sr.getNode),
-		router.NewDeleteRoute("/nodes/{id}", sr.removeNode),
-		router.NewPostRoute("/nodes/{id}/update", sr.updateNode),
-
-		router.NewGetRoute("/tasks", sr.getTasks),
-		router.NewGetRoute("/tasks/{id}", sr.getTask),
-		router.NewGetRoute("/tasks/{id}/logs", sr.getTaskLogs),
-
-		router.NewGetRoute("/secrets", sr.getSecrets),
-		router.NewPostRoute("/secrets/create", sr.createSecret),
-		router.NewDeleteRoute("/secrets/{id}", sr.removeSecret),
-		router.NewGetRoute("/secrets/{id}", sr.getSecret),
-		router.NewPostRoute("/secrets/{id}/update", sr.updateSecret),
-
-		router.NewGetRoute("/configs", sr.getConfigs),
-		router.NewPostRoute("/configs/create", sr.createConfig),
-		router.NewDeleteRoute("/configs/{id}", sr.removeConfig),
-		router.NewGetRoute("/configs/{id}", sr.getConfig),
-		router.NewPostRoute("/configs/{id}/update", sr.updateConfig),
-	}
-}
--- a/api/server/router/swarm/cluster_routes.go
+++ b/api/server/router/swarm/cluster_routes.go
@@ -1,560 +0,0 @@
-package swarm // import "github.com/docker/docker/api/server/router/swarm"
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strconv"
-
-	"github.com/docker/docker/api/server/httputils"
-	basictypes "github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/backend"
-	"github.com/docker/docker/api/types/filters"
-	types "github.com/docker/docker/api/types/swarm"
-	"github.com/docker/docker/api/types/versions"
-	"github.com/docker/docker/errdefs"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-)
-
-func (sr *swarmRouter) initCluster(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var req types.InitRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-	version := httputils.VersionFromContext(ctx)
-
-	// DefaultAddrPool and SubnetSize were added in API 1.39. Ignore on older API versions.
-	if versions.LessThan(version, "1.39") {
-		req.DefaultAddrPool = nil
-		req.SubnetSize = 0
-	}
-	// DataPathPort was added in API 1.40. Ignore this option on older API versions.
-	if versions.LessThan(version, "1.40") {
-		req.DataPathPort = 0
-	}
-	nodeID, err := sr.backend.Init(req)
-	if err != nil {
-		logrus.Errorf("Error initializing swarm: %v", err)
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, nodeID)
-}
-
-func (sr *swarmRouter) joinCluster(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var req types.JoinRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-	return sr.backend.Join(req)
-}
-
-func (sr *swarmRouter) leaveCluster(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	force := httputils.BoolValue(r, "force")
-	return sr.backend.Leave(force)
-}
-
-func (sr *swarmRouter) inspectCluster(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	swarm, err := sr.backend.Inspect()
-	if err != nil {
-		logrus.Errorf("Error getting swarm: %v", err)
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, swarm)
-}
-
-func (sr *swarmRouter) updateCluster(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var swarm types.Spec
-	if err := json.NewDecoder(r.Body).Decode(&swarm); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	rawVersion := r.URL.Query().Get("version")
-	version, err := strconv.ParseUint(rawVersion, 10, 64)
-	if err != nil {
-		err := fmt.Errorf("invalid swarm version '%s': %v", rawVersion, err)
-		return errdefs.InvalidParameter(err)
-	}
-
-	var flags types.UpdateFlags
-
-	if value := r.URL.Query().Get("rotateWorkerToken"); value != "" {
-		rot, err := strconv.ParseBool(value)
-		if err != nil {
-			err := fmt.Errorf("invalid value for rotateWorkerToken: %s", value)
-			return errdefs.InvalidParameter(err)
-		}
-
-		flags.RotateWorkerToken = rot
-	}
-
-	if value := r.URL.Query().Get("rotateManagerToken"); value != "" {
-		rot, err := strconv.ParseBool(value)
-		if err != nil {
-			err := fmt.Errorf("invalid value for rotateManagerToken: %s", value)
-			return errdefs.InvalidParameter(err)
-		}
-
-		flags.RotateManagerToken = rot
-	}
-
-	if value := r.URL.Query().Get("rotateManagerUnlockKey"); value != "" {
-		rot, err := strconv.ParseBool(value)
-		if err != nil {
-			return errdefs.InvalidParameter(fmt.Errorf("invalid value for rotateManagerUnlockKey: %s", value))
-		}
-
-		flags.RotateManagerUnlockKey = rot
-	}
-
-	if err := sr.backend.Update(version, swarm, flags); err != nil {
-		logrus.Errorf("Error configuring swarm: %v", err)
-		return err
-	}
-	return nil
-}
-
-func (sr *swarmRouter) unlockCluster(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var req types.UnlockRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	if err := sr.backend.UnlockSwarm(req); err != nil {
-		logrus.Errorf("Error unlocking swarm: %v", err)
-		return err
-	}
-	return nil
-}
-
-func (sr *swarmRouter) getUnlockKey(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	unlockKey, err := sr.backend.GetUnlockKey()
-	if err != nil {
-		logrus.WithError(err).Errorf("Error retrieving swarm unlock key")
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, &basictypes.SwarmUnlockKeyResponse{
-		UnlockKey: unlockKey,
-	})
-}
-
-func (sr *swarmRouter) getServices(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	filter, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return errdefs.InvalidParameter(err)
-	}
-
-	// the status query parameter is only support in API versions >= 1.41. If
-	// the client is using a lesser version, ignore the parameter.
-	cliVersion := httputils.VersionFromContext(ctx)
-	var status bool
-	if value := r.URL.Query().Get("status"); value != "" && !versions.LessThan(cliVersion, "1.41") {
-		var err error
-		status, err = strconv.ParseBool(value)
-		if err != nil {
-			return errors.Wrapf(errdefs.InvalidParameter(err), "invalid value for status: %s", value)
-		}
-	}
-
-	services, err := sr.backend.GetServices(basictypes.ServiceListOptions{Filters: filter, Status: status})
-	if err != nil {
-		logrus.Errorf("Error getting services: %v", err)
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, services)
-}
-
-func (sr *swarmRouter) getService(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var insertDefaults bool
-
-	if value := r.URL.Query().Get("insertDefaults"); value != "" {
-		var err error
-		insertDefaults, err = strconv.ParseBool(value)
-		if err != nil {
-			return errors.Wrapf(errdefs.InvalidParameter(err), "invalid value for insertDefaults: %s", value)
-		}
-	}
-
-	// you may note that there is no code here to handle the "status" query
-	// parameter, as in getServices. the Status field is not supported when
-	// retrieving an individual service because the Backend API changes
-	// required to accommodate it would be too disruptive, and because that
-	// field is so rarely needed as part of an individual service inspection.
-
-	service, err := sr.backend.GetService(vars["id"], insertDefaults)
-	if err != nil {
-		logrus.Errorf("Error getting service %s: %v", vars["id"], err)
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, service)
-}
-
-func (sr *swarmRouter) createService(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var service types.ServiceSpec
-	if err := json.NewDecoder(r.Body).Decode(&service); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	// Get returns "" if the header does not exist
-	encodedAuth := r.Header.Get("X-Registry-Auth")
-	queryRegistry := false
-	if v := httputils.VersionFromContext(ctx); v != "" {
-		if versions.LessThan(v, "1.30") {
-			queryRegistry = true
-		}
-		adjustForAPIVersion(v, &service)
-	}
-	resp, err := sr.backend.CreateService(service, encodedAuth, queryRegistry)
-	if err != nil {
-		logrus.Errorf("Error creating service %s: %v", service.Name, err)
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusCreated, resp)
-}
-
-func (sr *swarmRouter) updateService(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var service types.ServiceSpec
-	if err := json.NewDecoder(r.Body).Decode(&service); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	rawVersion := r.URL.Query().Get("version")
-	version, err := strconv.ParseUint(rawVersion, 10, 64)
-	if err != nil {
-		err := fmt.Errorf("invalid service version '%s': %v", rawVersion, err)
-		return errdefs.InvalidParameter(err)
-	}
-
-	var flags basictypes.ServiceUpdateOptions
-
-	// Get returns "" if the header does not exist
-	flags.EncodedRegistryAuth = r.Header.Get("X-Registry-Auth")
-	flags.RegistryAuthFrom = r.URL.Query().Get("registryAuthFrom")
-	flags.Rollback = r.URL.Query().Get("rollback")
-	queryRegistry := false
-	if v := httputils.VersionFromContext(ctx); v != "" {
-		if versions.LessThan(v, "1.30") {
-			queryRegistry = true
-		}
-		adjustForAPIVersion(v, &service)
-	}
-
-	resp, err := sr.backend.UpdateService(vars["id"], version, service, flags, queryRegistry)
-	if err != nil {
-		logrus.Errorf("Error updating service %s: %v", vars["id"], err)
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, resp)
-}
-
-func (sr *swarmRouter) removeService(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := sr.backend.RemoveService(vars["id"]); err != nil {
-		logrus.Errorf("Error removing service %s: %v", vars["id"], err)
-		return err
-	}
-	return nil
-}
-
-func (sr *swarmRouter) getTaskLogs(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	// make a selector to pass to the helper function
-	selector := &backend.LogSelector{
-		Tasks: []string{vars["id"]},
-	}
-	return sr.swarmLogs(ctx, w, r, selector)
-}
-
-func (sr *swarmRouter) getServiceLogs(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	// make a selector to pass to the helper function
-	selector := &backend.LogSelector{
-		Services: []string{vars["id"]},
-	}
-	return sr.swarmLogs(ctx, w, r, selector)
-}
-
-func (sr *swarmRouter) getNodes(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	filter, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	nodes, err := sr.backend.GetNodes(basictypes.NodeListOptions{Filters: filter})
-	if err != nil {
-		logrus.Errorf("Error getting nodes: %v", err)
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, nodes)
-}
-
-func (sr *swarmRouter) getNode(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	node, err := sr.backend.GetNode(vars["id"])
-	if err != nil {
-		logrus.Errorf("Error getting node %s: %v", vars["id"], err)
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, node)
-}
-
-func (sr *swarmRouter) updateNode(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var node types.NodeSpec
-	if err := json.NewDecoder(r.Body).Decode(&node); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	rawVersion := r.URL.Query().Get("version")
-	version, err := strconv.ParseUint(rawVersion, 10, 64)
-	if err != nil {
-		err := fmt.Errorf("invalid node version '%s': %v", rawVersion, err)
-		return errdefs.InvalidParameter(err)
-	}
-
-	if err := sr.backend.UpdateNode(vars["id"], version, node); err != nil {
-		logrus.Errorf("Error updating node %s: %v", vars["id"], err)
-		return err
-	}
-	return nil
-}
-
-func (sr *swarmRouter) removeNode(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	force := httputils.BoolValue(r, "force")
-
-	if err := sr.backend.RemoveNode(vars["id"], force); err != nil {
-		logrus.Errorf("Error removing node %s: %v", vars["id"], err)
-		return err
-	}
-	return nil
-}
-
-func (sr *swarmRouter) getTasks(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	filter, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	tasks, err := sr.backend.GetTasks(basictypes.TaskListOptions{Filters: filter})
-	if err != nil {
-		logrus.Errorf("Error getting tasks: %v", err)
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, tasks)
-}
-
-func (sr *swarmRouter) getTask(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	task, err := sr.backend.GetTask(vars["id"])
-	if err != nil {
-		logrus.Errorf("Error getting task %s: %v", vars["id"], err)
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, task)
-}
-
-func (sr *swarmRouter) getSecrets(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	filters, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	secrets, err := sr.backend.GetSecrets(basictypes.SecretListOptions{Filters: filters})
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, secrets)
-}
-
-func (sr *swarmRouter) createSecret(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var secret types.SecretSpec
-	if err := json.NewDecoder(r.Body).Decode(&secret); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-	version := httputils.VersionFromContext(ctx)
-	if secret.Templating != nil && versions.LessThan(version, "1.37") {
-		return errdefs.InvalidParameter(errors.Errorf("secret templating is not supported on the specified API version: %s", version))
-	}
-
-	id, err := sr.backend.CreateSecret(secret)
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusCreated, &basictypes.SecretCreateResponse{
-		ID: id,
-	})
-}
-
-func (sr *swarmRouter) removeSecret(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := sr.backend.RemoveSecret(vars["id"]); err != nil {
-		return err
-	}
-	w.WriteHeader(http.StatusNoContent)
-
-	return nil
-}
-
-func (sr *swarmRouter) getSecret(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	secret, err := sr.backend.GetSecret(vars["id"])
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, secret)
-}
-
-func (sr *swarmRouter) updateSecret(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var secret types.SecretSpec
-	if err := json.NewDecoder(r.Body).Decode(&secret); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	rawVersion := r.URL.Query().Get("version")
-	version, err := strconv.ParseUint(rawVersion, 10, 64)
-	if err != nil {
-		return errdefs.InvalidParameter(fmt.Errorf("invalid secret version"))
-	}
-
-	id := vars["id"]
-	return sr.backend.UpdateSecret(id, version, secret)
-}
-
-func (sr *swarmRouter) getConfigs(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	filters, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	configs, err := sr.backend.GetConfigs(basictypes.ConfigListOptions{Filters: filters})
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, configs)
-}
-
-func (sr *swarmRouter) createConfig(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var config types.ConfigSpec
-	if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	version := httputils.VersionFromContext(ctx)
-	if config.Templating != nil && versions.LessThan(version, "1.37") {
-		return errdefs.InvalidParameter(errors.Errorf("config templating is not supported on the specified API version: %s", version))
-	}
-
-	id, err := sr.backend.CreateConfig(config)
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusCreated, &basictypes.ConfigCreateResponse{
-		ID: id,
-	})
-}
-
-func (sr *swarmRouter) removeConfig(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := sr.backend.RemoveConfig(vars["id"]); err != nil {
-		return err
-	}
-	w.WriteHeader(http.StatusNoContent)
-
-	return nil
-}
-
-func (sr *swarmRouter) getConfig(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	config, err := sr.backend.GetConfig(vars["id"])
-	if err != nil {
-		return err
-	}
-
-	return httputils.WriteJSON(w, http.StatusOK, config)
-}
-
-func (sr *swarmRouter) updateConfig(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var config types.ConfigSpec
-	if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	rawVersion := r.URL.Query().Get("version")
-	version, err := strconv.ParseUint(rawVersion, 10, 64)
-	if err != nil {
-		return errdefs.InvalidParameter(fmt.Errorf("invalid config version"))
-	}
-
-	id := vars["id"]
-	return sr.backend.UpdateConfig(id, version, config)
-}
--- a/api/server/router/swarm/helpers.go
+++ b/api/server/router/swarm/helpers.go
@@ -1,117 +0,0 @@
-package swarm // import "github.com/docker/docker/api/server/router/swarm"
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-
-	"github.com/docker/docker/api/server/httputils"
-	basictypes "github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/backend"
-	"github.com/docker/docker/api/types/swarm"
-	"github.com/docker/docker/api/types/versions"
-)
-
-// swarmLogs takes an http response, request, and selector, and writes the logs
-// specified by the selector to the response
-func (sr *swarmRouter) swarmLogs(ctx context.Context, w io.Writer, r *http.Request, selector *backend.LogSelector) error {
-	// Args are validated before the stream starts because when it starts we're
-	// sending HTTP 200 by writing an empty chunk of data to tell the client that
-	// daemon is going to stream. By sending this initial HTTP 200 we can't report
-	// any error after the stream starts (i.e. container not found, wrong parameters)
-	// with the appropriate status code.
-	stdout, stderr := httputils.BoolValue(r, "stdout"), httputils.BoolValue(r, "stderr")
-	if !(stdout || stderr) {
-		return fmt.Errorf("Bad parameters: you must choose at least one stream")
-	}
-
-	// there is probably a neater way to manufacture the ContainerLogsOptions
-	// struct, probably in the caller, to eliminate the dependency on net/http
-	logsConfig := &basictypes.ContainerLogsOptions{
-		Follow:     httputils.BoolValue(r, "follow"),
-		Timestamps: httputils.BoolValue(r, "timestamps"),
-		Since:      r.Form.Get("since"),
-		Tail:       r.Form.Get("tail"),
-		ShowStdout: stdout,
-		ShowStderr: stderr,
-		Details:    httputils.BoolValue(r, "details"),
-	}
-
-	tty := false
-	// checking for whether logs are TTY involves iterating over every service
-	// and task. idk if there is a better way
-	for _, service := range selector.Services {
-		s, err := sr.backend.GetService(service, false)
-		if err != nil {
-			// maybe should return some context with this error?
-			return err
-		}
-		tty = (s.Spec.TaskTemplate.ContainerSpec != nil && s.Spec.TaskTemplate.ContainerSpec.TTY) || tty
-	}
-	for _, task := range selector.Tasks {
-		t, err := sr.backend.GetTask(task)
-		if err != nil {
-			// as above
-			return err
-		}
-		tty = t.Spec.ContainerSpec.TTY || tty
-	}
-
-	msgs, err := sr.backend.ServiceLogs(ctx, selector, logsConfig)
-	if err != nil {
-		return err
-	}
-
-	httputils.WriteLogStream(ctx, w, msgs, logsConfig, !tty)
-	return nil
-}
-
-// adjustForAPIVersion takes a version and service spec and removes fields to
-// make the spec compatible with the specified version.
-func adjustForAPIVersion(cliVersion string, service *swarm.ServiceSpec) {
-	if cliVersion == "" {
-		return
-	}
-	if versions.LessThan(cliVersion, "1.40") {
-		if service.TaskTemplate.ContainerSpec != nil {
-			// Sysctls for docker swarm services weren't supported before
-			// API version 1.40
-			service.TaskTemplate.ContainerSpec.Sysctls = nil
-
-			if service.TaskTemplate.ContainerSpec.Privileges != nil && service.TaskTemplate.ContainerSpec.Privileges.CredentialSpec != nil {
-				// Support for setting credential-spec through configs was added in API 1.40
-				service.TaskTemplate.ContainerSpec.Privileges.CredentialSpec.Config = ""
-			}
-			for _, config := range service.TaskTemplate.ContainerSpec.Configs {
-				// support for the Runtime target was added in API 1.40
-				config.Runtime = nil
-			}
-		}
-
-		if service.TaskTemplate.Placement != nil {
-			// MaxReplicas for docker swarm services weren't supported before
-			// API version 1.40
-			service.TaskTemplate.Placement.MaxReplicas = 0
-		}
-	}
-	if versions.LessThan(cliVersion, "1.41") {
-		if service.TaskTemplate.ContainerSpec != nil {
-			// Capabilities and Ulimits for docker swarm services weren't
-			// supported before API version 1.41
-			service.TaskTemplate.ContainerSpec.CapabilityAdd = nil
-			service.TaskTemplate.ContainerSpec.CapabilityDrop = nil
-			service.TaskTemplate.ContainerSpec.Ulimits = nil
-		}
-		if service.TaskTemplate.Resources != nil && service.TaskTemplate.Resources.Limits != nil {
-			// Limits.Pids  not supported before API version 1.41
-			service.TaskTemplate.Resources.Limits.Pids = 0
-		}
-
-		// jobs were only introduced in API version 1.41. Nil out both Job
-		// modes; if the service is one of these modes and subsequently has no
-		// mode, then something down the pipe will thrown an error.
-		service.Mode.ReplicatedJob = nil
-		service.Mode.GlobalJob = nil
-	}
-}
--- a/api/server/router/swarm/helpers_test.go
+++ b/api/server/router/swarm/helpers_test.go
@@ -1,119 +0,0 @@
-package swarm // import "github.com/docker/docker/api/server/router/swarm"
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/docker/docker/api/types/swarm"
-	"github.com/docker/go-units"
-)
-
-func TestAdjustForAPIVersion(t *testing.T) {
-	var (
-		expectedSysctls = map[string]string{"foo": "bar"}
-	)
-	// testing the negative -- does this leave everything else alone? -- is
-	// prohibitively time-consuming to write, because it would need an object
-	// with literally every field filled in.
-	spec := &swarm.ServiceSpec{
-		TaskTemplate: swarm.TaskSpec{
-			ContainerSpec: &swarm.ContainerSpec{
-				Sysctls: expectedSysctls,
-				Privileges: &swarm.Privileges{
-					CredentialSpec: &swarm.CredentialSpec{
-						Config: "someconfig",
-					},
-				},
-				Configs: []*swarm.ConfigReference{
-					{
-						File: &swarm.ConfigReferenceFileTarget{
-							Name: "foo",
-							UID:  "bar",
-							GID:  "baz",
-						},
-						ConfigID:   "configFile",
-						ConfigName: "configFile",
-					},
-					{
-						Runtime:    &swarm.ConfigReferenceRuntimeTarget{},
-						ConfigID:   "configRuntime",
-						ConfigName: "configRuntime",
-					},
-				},
-				Ulimits: []*units.Ulimit{
-					{
-						Name: "nofile",
-						Soft: 100,
-						Hard: 200,
-					},
-				},
-			},
-			Placement: &swarm.Placement{
-				MaxReplicas: 222,
-			},
-			Resources: &swarm.ResourceRequirements{
-				Limits: &swarm.Limit{
-					Pids: 300,
-				},
-			},
-		},
-	}
-
-	// first, does calling this with a later version correctly NOT strip
-	// fields? do the later version first, so we can reuse this spec in the
-	// next test.
-	adjustForAPIVersion("1.41", spec)
-	if !reflect.DeepEqual(spec.TaskTemplate.ContainerSpec.Sysctls, expectedSysctls) {
-		t.Error("Sysctls was stripped from spec")
-	}
-
-	if spec.TaskTemplate.Resources.Limits.Pids == 0 {
-		t.Error("PidsLimit was stripped from spec")
-	}
-	if spec.TaskTemplate.Resources.Limits.Pids != 300 {
-		t.Error("PidsLimit did not preserve the value from spec")
-	}
-
-	if spec.TaskTemplate.ContainerSpec.Privileges.CredentialSpec.Config != "someconfig" {
-		t.Error("CredentialSpec.Config field was stripped from spec")
-	}
-
-	if spec.TaskTemplate.ContainerSpec.Configs[1].Runtime == nil {
-		t.Error("ConfigReferenceRuntimeTarget was stripped from spec")
-	}
-
-	if spec.TaskTemplate.Placement.MaxReplicas != 222 {
-		t.Error("MaxReplicas was stripped from spec")
-	}
-
-	if len(spec.TaskTemplate.ContainerSpec.Ulimits) == 0 {
-		t.Error("Ulimits were stripped from spec")
-	}
-
-	// next, does calling this with an earlier version correctly strip fields?
-	adjustForAPIVersion("1.29", spec)
-	if spec.TaskTemplate.ContainerSpec.Sysctls != nil {
-		t.Error("Sysctls was not stripped from spec")
-	}
-
-	if spec.TaskTemplate.Resources.Limits.Pids != 0 {
-		t.Error("PidsLimit was not stripped from spec")
-	}
-
-	if spec.TaskTemplate.ContainerSpec.Privileges.CredentialSpec.Config != "" {
-		t.Error("CredentialSpec.Config field was not stripped from spec")
-	}
-
-	if spec.TaskTemplate.ContainerSpec.Configs[1].Runtime != nil {
-		t.Error("ConfigReferenceRuntimeTarget was not stripped from spec")
-	}
-
-	if spec.TaskTemplate.Placement.MaxReplicas != 0 {
-		t.Error("MaxReplicas was not stripped from spec")
-	}
-
-	if len(spec.TaskTemplate.ContainerSpec.Ulimits) != 0 {
-		t.Error("Ulimits were not stripped from spec")
-	}
-
-}
--- a/api/server/router/system/backend.go
+++ b/api/server/router/system/backend.go
@@ -1,28 +0,0 @@
-package system // import "github.com/docker/docker/api/server/router/system"
-
-import (
-	"context"
-	"time"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/events"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/swarm"
-)
-
-// Backend is the methods that need to be implemented to provide
-// system specific functionality.
-type Backend interface {
-	SystemInfo() *types.Info
-	SystemVersion() types.Version
-	SystemDiskUsage(ctx context.Context) (*types.DiskUsage, error)
-	SubscribeToEvents(since, until time.Time, ef filters.Args) ([]events.Message, chan interface{})
-	UnsubscribeFromEvents(chan interface{})
-	AuthenticateToRegistry(ctx context.Context, authConfig *types.AuthConfig) (string, string, error)
-}
-
-// ClusterBackend is all the methods that need to be implemented
-// to provide cluster system specific functionality.
-type ClusterBackend interface {
-	Info() swarm.Info
-}
--- a/api/server/router/system/system.go
+++ b/api/server/router/system/system.go
@@ -1,44 +0,0 @@
-package system // import "github.com/docker/docker/api/server/router/system"
-
-import (
-	"github.com/docker/docker/api/server/router"
-	buildkit "github.com/docker/docker/builder/builder-next"
-)
-
-// systemRouter provides information about the Docker system overall.
-// It gathers information about host, daemon and container events.
-type systemRouter struct {
-	backend  Backend
-	cluster  ClusterBackend
-	routes   []router.Route
-	builder  *buildkit.Builder
-	features *map[string]bool
-}
-
-// NewRouter initializes a new system router
-func NewRouter(b Backend, c ClusterBackend, builder *buildkit.Builder, features *map[string]bool) router.Router {
-	r := &systemRouter{
-		backend:  b,
-		cluster:  c,
-		builder:  builder,
-		features: features,
-	}
-
-	r.routes = []router.Route{
-		router.NewOptionsRoute("/{anyroute:.*}", optionsHandler),
-		router.NewGetRoute("/_ping", r.pingHandler),
-		router.NewHeadRoute("/_ping", r.pingHandler),
-		router.NewGetRoute("/events", r.getEvents),
-		router.NewGetRoute("/info", r.getInfo),
-		router.NewGetRoute("/version", r.getVersion),
-		router.NewGetRoute("/system/df", r.getDiskUsage),
-		router.NewPostRoute("/auth", r.postAuth),
-	}
-
-	return r
-}
-
-// Routes returns all the API routes dedicated to the docker system
-func (s *systemRouter) Routes() []router.Route {
-	return s.routes
-}
--- a/api/server/router/system/system_routes.go
+++ b/api/server/router/system/system_routes.go
@@ -1,243 +0,0 @@
-package system // import "github.com/docker/docker/api/server/router/system"
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/server/router/build"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/events"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/registry"
-	timetypes "github.com/docker/docker/api/types/time"
-	"github.com/docker/docker/api/types/versions"
-	"github.com/docker/docker/pkg/ioutils"
-	pkgerrors "github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	"golang.org/x/sync/errgroup"
-)
-
-func optionsHandler(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	w.WriteHeader(http.StatusOK)
-	return nil
-}
-
-func (s *systemRouter) pingHandler(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	w.Header().Add("Cache-Control", "no-cache, no-store, must-revalidate")
-	w.Header().Add("Pragma", "no-cache")
-
-	builderVersion := build.BuilderVersion(*s.features)
-	if bv := builderVersion; bv != "" {
-		w.Header().Set("Builder-Version", string(bv))
-	}
-	if r.Method == http.MethodHead {
-		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
-		w.Header().Set("Content-Length", "0")
-		return nil
-	}
-	_, err := w.Write([]byte{'O', 'K'})
-	return err
-}
-
-func (s *systemRouter) getInfo(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	info := s.backend.SystemInfo()
-
-	if s.cluster != nil {
-		info.Swarm = s.cluster.Info()
-		info.Warnings = append(info.Warnings, info.Swarm.Warnings...)
-	}
-
-	if versions.LessThan(httputils.VersionFromContext(ctx), "1.25") {
-		// TODO: handle this conversion in engine-api
-		type oldInfo struct {
-			*types.Info
-			ExecutionDriver string
-		}
-		old := &oldInfo{
-			Info:            info,
-			ExecutionDriver: "<not supported>",
-		}
-		nameOnlySecurityOptions := []string{}
-		kvSecOpts, err := types.DecodeSecurityOptions(old.SecurityOptions)
-		if err != nil {
-			return err
-		}
-		for _, s := range kvSecOpts {
-			nameOnlySecurityOptions = append(nameOnlySecurityOptions, s.Name)
-		}
-		old.SecurityOptions = nameOnlySecurityOptions
-		return httputils.WriteJSON(w, http.StatusOK, old)
-	}
-	if versions.LessThan(httputils.VersionFromContext(ctx), "1.39") {
-		if info.KernelVersion == "" {
-			info.KernelVersion = "<unknown>"
-		}
-		if info.OperatingSystem == "" {
-			info.OperatingSystem = "<unknown>"
-		}
-	}
-	return httputils.WriteJSON(w, http.StatusOK, info)
-}
-
-func (s *systemRouter) getVersion(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	info := s.backend.SystemVersion()
-
-	return httputils.WriteJSON(w, http.StatusOK, info)
-}
-
-func (s *systemRouter) getDiskUsage(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	eg, ctx := errgroup.WithContext(ctx)
-
-	var du *types.DiskUsage
-	eg.Go(func() error {
-		var err error
-		du, err = s.backend.SystemDiskUsage(ctx)
-		return err
-	})
-
-	var buildCache []*types.BuildCache
-	eg.Go(func() error {
-		var err error
-		buildCache, err = s.builder.DiskUsage(ctx)
-		if err != nil {
-			return pkgerrors.Wrap(err, "error getting build cache usage")
-		}
-		return nil
-	})
-
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-
-	var builderSize int64
-	for _, b := range buildCache {
-		builderSize += b.Size
-	}
-
-	du.BuilderSize = builderSize
-	du.BuildCache = buildCache
-
-	return httputils.WriteJSON(w, http.StatusOK, du)
-}
-
-type invalidRequestError struct {
-	Err error
-}
-
-func (e invalidRequestError) Error() string {
-	return e.Err.Error()
-}
-
-func (e invalidRequestError) InvalidParameter() {}
-
-func (s *systemRouter) getEvents(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	since, err := eventTime(r.Form.Get("since"))
-	if err != nil {
-		return err
-	}
-	until, err := eventTime(r.Form.Get("until"))
-	if err != nil {
-		return err
-	}
-
-	var (
-		timeout        <-chan time.Time
-		onlyPastEvents bool
-	)
-	if !until.IsZero() {
-		if until.Before(since) {
-			return invalidRequestError{fmt.Errorf("`since` time (%s) cannot be after `until` time (%s)", r.Form.Get("since"), r.Form.Get("until"))}
-		}
-
-		now := time.Now()
-
-		onlyPastEvents = until.Before(now)
-
-		if !onlyPastEvents {
-			dur := until.Sub(now)
-			timer := time.NewTimer(dur)
-			defer timer.Stop()
-			timeout = timer.C
-		}
-	}
-
-	ef, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	output := ioutils.NewWriteFlusher(w)
-	defer output.Close()
-	output.Flush()
-
-	enc := json.NewEncoder(output)
-
-	buffered, l := s.backend.SubscribeToEvents(since, until, ef)
-	defer s.backend.UnsubscribeFromEvents(l)
-
-	for _, ev := range buffered {
-		if err := enc.Encode(ev); err != nil {
-			return err
-		}
-	}
-
-	if onlyPastEvents {
-		return nil
-	}
-
-	for {
-		select {
-		case ev := <-l:
-			jev, ok := ev.(events.Message)
-			if !ok {
-				logrus.Warnf("unexpected event message: %q", ev)
-				continue
-			}
-			if err := enc.Encode(jev); err != nil {
-				return err
-			}
-		case <-timeout:
-			return nil
-		case <-ctx.Done():
-			logrus.Debug("Client context cancelled, stop sending events")
-			return nil
-		}
-	}
-}
-
-func (s *systemRouter) postAuth(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	var config *types.AuthConfig
-	err := json.NewDecoder(r.Body).Decode(&config)
-	r.Body.Close()
-	if err != nil {
-		return err
-	}
-	status, token, err := s.backend.AuthenticateToRegistry(ctx, config)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, &registry.AuthenticateOKBody{
-		Status:        status,
-		IdentityToken: token,
-	})
-}
-
-func eventTime(formTime string) (time.Time, error) {
-	t, tNano, err := timetypes.ParseTimestamps(formTime, -1)
-	if err != nil {
-		return time.Time{}, err
-	}
-	if t == -1 {
-		return time.Time{}, nil
-	}
-	return time.Unix(t, tNano), nil
-}
--- a/api/server/router/volume/backend.go
+++ b/api/server/router/volume/backend.go
@@ -1,20 +0,0 @@
-package volume // import "github.com/docker/docker/api/server/router/volume"
-
-import (
-	"context"
-
-	"github.com/docker/docker/volume/service/opts"
-	// TODO return types need to be refactored into pkg
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-)
-
-// Backend is the methods that need to be implemented to provide
-// volume specific functionality
-type Backend interface {
-	List(ctx context.Context, filter filters.Args) ([]*types.Volume, []string, error)
-	Get(ctx context.Context, name string, opts ...opts.GetOption) (*types.Volume, error)
-	Create(ctx context.Context, name, driverName string, opts ...opts.CreateOption) (*types.Volume, error)
-	Remove(ctx context.Context, name string, opts ...opts.RemoveOption) error
-	Prune(ctx context.Context, pruneFilters filters.Args) (*types.VolumesPruneReport, error)
-}
--- a/api/server/router/volume/volume.go
+++ b/api/server/router/volume/volume.go
@@ -1,36 +0,0 @@
-package volume // import "github.com/docker/docker/api/server/router/volume"
-
-import "github.com/docker/docker/api/server/router"
-
-// volumeRouter is a router to talk with the volumes controller
-type volumeRouter struct {
-	backend Backend
-	routes  []router.Route
-}
-
-// NewRouter initializes a new volume router
-func NewRouter(b Backend) router.Router {
-	r := &volumeRouter{
-		backend: b,
-	}
-	r.initRoutes()
-	return r
-}
-
-// Routes returns the available routes to the volumes controller
-func (r *volumeRouter) Routes() []router.Route {
-	return r.routes
-}
-
-func (r *volumeRouter) initRoutes() {
-	r.routes = []router.Route{
-		// GET
-		router.NewGetRoute("/volumes", r.getVolumesList),
-		router.NewGetRoute("/volumes/{name:.*}", r.getVolumeByName),
-		// POST
-		router.NewPostRoute("/volumes/create", r.postVolumesCreate),
-		router.NewPostRoute("/volumes/prune", r.postVolumesPrune),
-		// DELETE
-		router.NewDeleteRoute("/volumes/{name:.*}", r.deleteVolumes),
-	}
-}
--- a/api/server/router/volume/volume_routes.go
+++ b/api/server/router/volume/volume_routes.go
@@ -1,96 +0,0 @@
-package volume // import "github.com/docker/docker/api/server/router/volume"
-
-import (
-	"context"
-	"encoding/json"
-	"io"
-	"net/http"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/types/filters"
-	volumetypes "github.com/docker/docker/api/types/volume"
-	"github.com/docker/docker/errdefs"
-	"github.com/docker/docker/volume/service/opts"
-	"github.com/pkg/errors"
-)
-
-func (v *volumeRouter) getVolumesList(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	filters, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return errdefs.InvalidParameter(errors.Wrap(err, "error reading volume filters"))
-	}
-	volumes, warnings, err := v.backend.List(ctx, filters)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, &volumetypes.VolumeListOKBody{Volumes: volumes, Warnings: warnings})
-}
-
-func (v *volumeRouter) getVolumeByName(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	volume, err := v.backend.Get(ctx, vars["name"], opts.WithGetResolveStatus)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, volume)
-}
-
-func (v *volumeRouter) postVolumesCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	if err := httputils.CheckForJSON(r); err != nil {
-		return err
-	}
-
-	var req volumetypes.VolumeCreateBody
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		if err == io.EOF {
-			return errdefs.InvalidParameter(errors.New("got EOF while reading request body"))
-		}
-		return errdefs.InvalidParameter(err)
-	}
-
-	volume, err := v.backend.Create(ctx, req.Name, req.Driver, opts.WithCreateOptions(req.DriverOpts), opts.WithCreateLabels(req.Labels))
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusCreated, volume)
-}
-
-func (v *volumeRouter) deleteVolumes(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-	force := httputils.BoolValue(r, "force")
-	if err := v.backend.Remove(ctx, vars["name"], opts.WithPurgeOnError(force)); err != nil {
-		return err
-	}
-	w.WriteHeader(http.StatusNoContent)
-	return nil
-}
-
-func (v *volumeRouter) postVolumesPrune(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-	if err := httputils.ParseForm(r); err != nil {
-		return err
-	}
-
-	pruneFilters, err := filters.FromJSON(r.Form.Get("filters"))
-	if err != nil {
-		return err
-	}
-
-	pruneReport, err := v.backend.Prune(ctx, pruneFilters)
-	if err != nil {
-		return err
-	}
-	return httputils.WriteJSON(w, http.StatusOK, pruneReport)
-}
--- a/api/server/server.go
+++ b/api/server/server.go
@@ -1,205 +0,0 @@
-package server // import "github.com/docker/docker/api/server"
-
-import (
-	"context"
-	"crypto/tls"
-	"net"
-	"net/http"
-	"strings"
-
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/server/middleware"
-	"github.com/docker/docker/api/server/router"
-	"github.com/docker/docker/api/server/router/debug"
-	"github.com/docker/docker/dockerversion"
-	"github.com/docker/docker/errdefs"
-	"github.com/gorilla/mux"
-	"github.com/sirupsen/logrus"
-)
-
-// versionMatcher defines a variable matcher to be parsed by the router
-// when a request is about to be served.
-const versionMatcher = "/v{version:[0-9.]+}"
-
-// Config provides the configuration for the API server
-type Config struct {
-	Logging     bool
-	CorsHeaders string
-	Version     string
-	SocketGroup string
-	TLSConfig   *tls.Config
-}
-
-// Server contains instance details for the server
-type Server struct {
-	cfg         *Config
-	servers     []*HTTPServer
-	routers     []router.Router
-	middlewares []middleware.Middleware
-}
-
-// New returns a new instance of the server based on the specified configuration.
-// It allocates resources which will be needed for ServeAPI(ports, unix-sockets).
-func New(cfg *Config) *Server {
-	return &Server{
-		cfg: cfg,
-	}
-}
-
-// UseMiddleware appends a new middleware to the request chain.
-// This needs to be called before the API routes are configured.
-func (s *Server) UseMiddleware(m middleware.Middleware) {
-	s.middlewares = append(s.middlewares, m)
-}
-
-// Accept sets a listener the server accepts connections into.
-func (s *Server) Accept(addr string, listeners ...net.Listener) {
-	for _, listener := range listeners {
-		httpServer := &HTTPServer{
-			srv: &http.Server{
-				Addr: addr,
-			},
-			l: listener,
-		}
-		s.servers = append(s.servers, httpServer)
-	}
-}
-
-// Close closes servers and thus stop receiving requests
-func (s *Server) Close() {
-	for _, srv := range s.servers {
-		if err := srv.Close(); err != nil {
-			logrus.Error(err)
-		}
-	}
-}
-
-// serveAPI loops through all initialized servers and spawns goroutine
-// with Serve method for each. It sets createMux() as Handler also.
-func (s *Server) serveAPI() error {
-	var chErrors = make(chan error, len(s.servers))
-	for _, srv := range s.servers {
-		srv.srv.Handler = s.createMux()
-		go func(srv *HTTPServer) {
-			var err error
-			logrus.Infof("API listen on %s", srv.l.Addr())
-			if err = srv.Serve(); err != nil && strings.Contains(err.Error(), "use of closed network connection") {
-				err = nil
-			}
-			chErrors <- err
-		}(srv)
-	}
-
-	for range s.servers {
-		err := <-chErrors
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// HTTPServer contains an instance of http server and the listener.
-// srv *http.Server, contains configuration to create an http server and a mux router with all api end points.
-// l   net.Listener, is a TCP or Socket listener that dispatches incoming request to the router.
-type HTTPServer struct {
-	srv *http.Server
-	l   net.Listener
-}
-
-// Serve starts listening for inbound requests.
-func (s *HTTPServer) Serve() error {
-	return s.srv.Serve(s.l)
-}
-
-// Close closes the HTTPServer from listening for the inbound requests.
-func (s *HTTPServer) Close() error {
-	return s.l.Close()
-}
-
-func (s *Server) makeHTTPHandler(handler httputils.APIFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		// Define the context that we'll pass around to share info
-		// like the docker-request-id.
-		//
-		// The 'context' will be used for global data that should
-		// apply to all requests. Data that is specific to the
-		// immediate function being called should still be passed
-		// as 'args' on the function call.
-
-		// use intermediate variable to prevent "should not use basic type
-		// string as key in context.WithValue" golint errors
-		ctx := context.WithValue(r.Context(), dockerversion.UAStringKey{}, r.Header.Get("User-Agent"))
-		r = r.WithContext(ctx)
-		handlerFunc := s.handlerWithGlobalMiddlewares(handler)
-
-		vars := mux.Vars(r)
-		if vars == nil {
-			vars = make(map[string]string)
-		}
-
-		if err := handlerFunc(ctx, w, r, vars); err != nil {
-			statusCode := errdefs.GetHTTPErrorStatusCode(err)
-			if statusCode >= 500 {
-				logrus.Errorf("Handler for %s %s returned error: %v", r.Method, r.URL.Path, err)
-			}
-			httputils.MakeErrorHandler(err)(w, r)
-		}
-	}
-}
-
-// InitRouter initializes the list of routers for the server.
-// This method also enables the Go profiler.
-func (s *Server) InitRouter(routers ...router.Router) {
-	s.routers = append(s.routers, routers...)
-}
-
-type pageNotFoundError struct{}
-
-func (pageNotFoundError) Error() string {
-	return "page not found"
-}
-
-func (pageNotFoundError) NotFound() {}
-
-// createMux initializes the main router the server uses.
-func (s *Server) createMux() *mux.Router {
-	m := mux.NewRouter()
-
-	logrus.Debug("Registering routers")
-	for _, apiRouter := range s.routers {
-		for _, r := range apiRouter.Routes() {
-			f := s.makeHTTPHandler(r.Handler())
-
-			logrus.Debugf("Registering %s, %s", r.Method(), r.Path())
-			m.Path(versionMatcher + r.Path()).Methods(r.Method()).Handler(f)
-			m.Path(r.Path()).Methods(r.Method()).Handler(f)
-		}
-	}
-
-	debugRouter := debug.NewRouter()
-	s.routers = append(s.routers, debugRouter)
-	for _, r := range debugRouter.Routes() {
-		f := s.makeHTTPHandler(r.Handler())
-		m.Path("/debug" + r.Path()).Handler(f)
-	}
-
-	notFoundHandler := httputils.MakeErrorHandler(pageNotFoundError{})
-	m.HandleFunc(versionMatcher+"/{path:.*}", notFoundHandler)
-	m.NotFoundHandler = notFoundHandler
-	m.MethodNotAllowedHandler = notFoundHandler
-
-	return m
-}
-
-// Wait blocks the server goroutine until it exits.
-// It sends an error message if there is any error during
-// the API execution.
-func (s *Server) Wait(waitChan chan error) {
-	if err := s.serveAPI(); err != nil {
-		logrus.Errorf("ServeAPI error: %v", err)
-		waitChan <- err
-		return
-	}
-	waitChan <- nil
-}
--- a/api/server/server_test.go
+++ b/api/server/server_test.go
@@ -1,45 +0,0 @@
-package server // import "github.com/docker/docker/api/server"
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/docker/docker/api"
-	"github.com/docker/docker/api/server/httputils"
-	"github.com/docker/docker/api/server/middleware"
-)
-
-func TestMiddlewares(t *testing.T) {
-	cfg := &Config{
-		Version: "0.1omega2",
-	}
-	srv := &Server{
-		cfg: cfg,
-	}
-
-	srv.UseMiddleware(middleware.NewVersionMiddleware("0.1omega2", api.DefaultVersion, api.MinVersion))
-
-	req, _ := http.NewRequest(http.MethodGet, "/containers/json", nil)
-	resp := httptest.NewRecorder()
-	ctx := context.Background()
-
-	localHandler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
-		if httputils.VersionFromContext(ctx) == "" {
-			t.Fatal("Expected version, got empty string")
-		}
-
-		if sv := w.Header().Get("Server"); !strings.Contains(sv, "Docker/0.1omega2") {
-			t.Fatalf("Expected server version in the header `Docker/0.1omega2`, got %s", sv)
-		}
-
-		return nil
-	}
-
-	handlerFunc := srv.handlerWithGlobalMiddlewares(localHandler)
-	if err := handlerFunc(ctx, resp, req, map[string]string{}); err != nil {
-		t.Fatal(err)
-	}
-}
--- a/api/swagger-gen.yaml
+++ b/api/swagger-gen.yaml
@@ -1,12 +0,0 @@
-
-layout:
-  models:
-    - name: definition
-      source: asset:model
-      target: "{{ joinFilePath .Target .ModelPackage }}"
-      file_name: "{{ (snakize (pascalize .Name)) }}.go"
-  operations:
-    - name: handler
-      source: asset:serverOperation
-      target: "{{ joinFilePath .Target .APIPackage .Package }}"
-      file_name: "{{ (snakize (pascalize .Name)) }}.go"
--- a/api/swagger.yaml
+++ b/api/swagger.yaml
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Guillaume J. Charmes	38b8373434	Implement the COPY operator within the builder	2013-04-24 14:28:51 -07:00
Guillaume J. Charmes	03b5f8a585	Make sure the destination directory exists when using docker insert	2013-04-24 13:51:28 -07:00
Guillaume J. Charmes	bc260f0225	Add insert command in order to insert external files within an image	2013-04-24 13:37:00 -07:00
Guillaume J. Charmes	45dcd1125b	Add a Builder.Commit method	2013-04-24 13:35:57 -07:00
Guillaume J. Charmes	d2e063d9e1	make builder.Run public it now runs only given arguments without sh -c	2013-04-24 12:31:20 -07:00
Guillaume J. Charmes	567a484b66	Clear the containers/images upon failure	2013-04-24 12:02:00 -07:00
Guillaume J. Charmes	5d4b886ad6	Add build command	2013-04-24 11:03:01 -07:00
				`@@ -1 +0,0 @@`
				`package network // import "github.com/docker/docker/api/server/router/network"`