Merge pull request #209 from docker/ver-ga

[17.07] bump version to 17.07.0-ce
Merge pull request #210 from docker/cl-1707
2017-08-29 10:38:08 -07:00 · 2017-08-29 10:37:55 -07:00 · 2017-08-28 16:01:05 -07:00 · 2017-08-28 15:58:55 -07:00 · 2017-08-22 15:16:12 -07:00 · 2017-08-22 15:15:46 -07:00
6044 changed files with 151544 additions and 653914 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1 +0,0 @@
-.helpers/
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -2,125 +2,6 @@

 Want to contribute on Docker CE? Awesome!

-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](#docker-community-guidelines) before you
-start participating.
-
-## Topics
-
-* [Reporting Security Issues](#reporting-security-issues)
-* [Reporting Issues](#reporting-other-issues)
-* [Submitting Pull Requests](#submitting-pull-requests)
-* [Community Guidelines](#docker-community-guidelines)
-
-## Reporting security issues
-
-The Docker maintainers take security seriously. If you discover a security
-issue, please bring it to their attention right away!
-
-Please **DO NOT** file a public issue, instead send your report privately to
-[security@docker.com](mailto:security@docker.com).
-
-Security reports are greatly appreciated and we will publicly thank you for it.
-We also like to send gifts&mdash;if you're into Docker schwag, make sure to let
-us know. We currently do not offer a paid security bounty program, but are not
-ruling it out in the future.
-
-## Reporting other issues
-
-There are separate issue-tracking repos for the end user Docker CE
-products specialized for a platform. Find your issue or file a new issue
-for the platform you are using:
-
-* https://github.com/docker/for-linux
-* https://github.com/docker/for-mac
-* https://github.com/docker/for-win
-* https://github.com/docker/for-aws
-* https://github.com/docker/for-azure
-
-When reporting issues, always include:
-
-* The output of `docker version`.
-* The output of `docker info`.
-
-If presented with a template when creating an issue, please follow its directions.
-
-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").
-
-## Submitting pull requests
-
-Please see the corresponding `CONTRIBUTING.md` file of each component for more information:
-
 * Changes to the `engine` should be directed upstream to https://github.com/moby/moby
 * Changes to the `cli` should be directed upstream to https://github.com/docker/cli
 * Changes to the `packaging` should be directed upstream to https://github.com/docker/docker-ce-packaging
-
-## Docker community guidelines
-
-We want to keep the Docker 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.
-  Regional, racial, gender, or other abuse will not 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.
-
-### 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.
--- a/30
+++ b/30
@ -1,56 +1,30 @@
 CLI_DIR:=$(CURDIR)/components/cli
 ENGINE_DIR:=$(CURDIR)/components/engine
 PACKAGING_DIR:=$(CURDIR)/components/packaging
-MOBY_COMPONENTS_SHA=ab7c118272b02d8672dc0255561d0c4015979780
-MOBY_COMPONENTS_URL=https://raw.githubusercontent.com/shykes/moby-extras/$(MOBY_COMPONENTS_SHA)/cmd/moby-components
-MOBY_COMPONENTS=.helpers/moby-components-$(MOBY_COMPONENTS_SHA)
 VERSION=$(shell cat VERSION)

-.PHONY: help
 help: ## show make targets
 	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {sub("\\\\n",sprintf("\n%22c"," "), $$2);printf " \033[36m%-20s\033[0m  %s\n", $$1, $$2}' $(MAKEFILE_LIST)

-.PHONY: test-integration-cli
 test-integration-cli: $(CLI_DIR)/build/docker ## test integration of cli and engine
 	$(MAKE) -C $(ENGINE_DIR) DOCKER_CLI_PATH=$< test-integration-cli

 $(CLI_DIR)/build/docker:
 	$(MAKE) -C $(CLI_DIR) -f docker.Makefile build

-.PHONY: deb
 deb: ## build deb packages
 	$(MAKE) VERSION=$(VERSION) CLI_DIR=$(CLI_DIR) ENGINE_DIR=$(ENGINE_DIR) -C $(PACKAGING_DIR) deb

-.PHONY: rpm
 rpm: ## build rpm packages
 	$(MAKE) VERSION=$(VERSION) CLI_DIR=$(CLI_DIR) ENGINE_DIR=$(ENGINE_DIR) -C $(PACKAGING_DIR) rpm

-.PHONY: static
 static: ## build static packages
 	$(MAKE) VERSION=$(VERSION) CLI_DIR=$(CLI_DIR) ENGINE_DIR=$(ENGINE_DIR) -C $(PACKAGING_DIR) static

-.PHONY: clean
 clean: ## clean the build artifacts
 	-$(MAKE) -C $(CLI_DIR) clean
 	-$(MAKE) -C $(ENGINE_DIR) clean
 	-$(MAKE) -C $(PACKAGING_DIR) clean

-$(MOBY_COMPONENTS):
-	mkdir -p .helpers
-	curl -fsSL $(MOBY_COMPONENTS_URL) > $(MOBY_COMPONENTS)
-	chmod +x $(MOBY_COMPONENTS)
-
-.PHONY: update-components
-update-components: update-components-cli update-components-engine update-components-packaging ## udpate components using moby extra tool
-
-.PHONY: update-components-cli
-update-components-cli: $(MOBY_COMPONENTS)
-	$(MOBY_COMPONENTS) update cli
-
-.PHONY: update-components-engine
-update-components-engine: $(MOBY_COMPONENTS)
-	$(MOBY_COMPONENTS) update engine
-
-.PHONY: update-components-packaging
-update-components-packaging: $(MOBY_COMPONENTS)
-	$(MOBY_COMPONENTS) update packaging
+vendor: $(CLI_DIR)/build/docker
+	docker run --rm -it -v $(CLI_DIR):/go/src/github.com/docker/cli -v $(ENGINE_DIR):/go/src/github.com/docker/docker docker-cli-dev sh -c 'cd /go/src/github.com/docker/docker && git init && git add . && git -c user.name=user -c user.email=email@example.com commit -m first && cd /go/src/github.com/docker/cli && vndr; rm -rf /go/src/github.com/docker/docker/.git'
--- a/2
+++ b/2
@ -1 +1 @@
-18.03.1-ce
+17.07.0-ce
--- a/components/cli/.github/CODEOWNERS
+++ b/components/cli/.github/CODEOWNERS
@ -1,9 +1,8 @@
-# GitHub code owners
+# Github code owners
 # See https://github.com/blog/2392-introducing-code-owners

-cli/command/stack/**        @dnephin @vdemeester
 cli/compose/**              @dnephin @vdemeester
 contrib/completion/bash/**  @albers
 contrib/completion/zsh/**   @sdurrheimer
-docs/**                     @mistyhacks @vdemeester @thaJeztah
+docs/**                     @mstanleyjones @vdemeester @thaJeztah
 scripts/**                  @dnephin
--- a/components/cli/.gitignore
+++ b/components/cli/.gitignore
@ -1,12 +1,4 @@
-# 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~
-*.orig
-.*.swp
 .DS_Store
-Thumbs.db
-.editorconfig
 /build/
 cli/winresources/rsrc_386.syso
 cli/winresources/rsrc_amd64.syso
--- a/components/cli/.mailmap
+++ b/components/cli/.mailmap
@ -1,475 +0,0 @@
-# Generate AUTHORS: scripts/docs/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
-
-Aaron L. Xu <liker.xu@foxmail.com>
-Abhinandan Prativadi <abhi@docker.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@gandi.net>
-AJ Bowen <aj@gandi.net> <amy@gandi.net>
-Akihiro Matsushima <amatsusbit@gmail.com> <amatsus@users.noreply.github.com>
-Akihiro Suda <suda.akihiro@lab.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>
-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>
-Andrew Weiss <andrew.weiss@docker.com> <andrew.weiss@microsoft.com>
-Andrew Weiss <andrew.weiss@docker.com> <andrew.weiss@outlook.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>
-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>
-Benoit Chesneau <bchesneau@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>
-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>
-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>
-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>
-Chris Dias <cdias@microsoft.com>
-Chris McKinnel <chris.mckinnel@tangentlabs.co.uk>
-Christopher Biscardi <biscarch@sketcht.com>
-Christopher Latham <sudosurootdev@gmail.com>
-Chun Chen <ramichen@tencent.com> <chenchun.feed@gmail.com>
-Corbin Coleman <corbin.coleman@docker.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 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>
-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>
-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>
-Elan Ruusamäe <glen@pld-linux.org>
-Elan Ruusamäe <glen@pld-linux.org> <glen@delfi.ee>
-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>
-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>
-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>
-Gabriel Nicolas Avellaneda <avellaneda.gabriel@gmail.com>
-Gaetan de Villele <gdevillele@gmail.com>
-Gang Qiao <qiaohai8866@gmail.com> <1373319223@qq.com>
-George Kontridze <george@bugsnag.com>
-Gerwim Feiken <g.feiken@tfe.nl> <gerwim@gmail.com>
-Giampaolo Mancini <giampaolo@trampolineup.com>
-Gopikannan Venugopalsamy <gopikannan.venugopalsamy@gmail.com>
-Gou Rao <gou@portworx.com> <gourao@users.noreply.github.com>
-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>
-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>
-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>
-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>
-Ilya Khlopotov <ilya.khlopotov@gmail.com>
-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>
-Jamie Hannaford <jamie@limetree.org> <jamie.hannaford@rackspace.com>
-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 <jessfraz@google.com>
-Jessica Frazelle <jessfraz@google.com> <acidburn@docker.com>
-Jessica Frazelle <jessfraz@google.com> <acidburn@google.com>
-Jessica Frazelle <jessfraz@google.com> <jess@docker.com>
-Jessica Frazelle <jessfraz@google.com> <jess@mesosphere.com>
-Jessica Frazelle <jessfraz@google.com> <jfrazelle@users.noreply.github.com>
-Jessica Frazelle <jessfraz@google.com> <me@jessfraz.com>
-Jessica Frazelle <jessfraz@google.com> <princess@docker.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 (VM) <John.Howard@microsoft.com>
-John Howard (VM) <John.Howard@microsoft.com> <jhoward@microsoft.com>
-John Howard (VM) <John.Howard@microsoft.com> <jhoward@ntdev.microsoft.com>
-John Howard (VM) <John.Howard@microsoft.com> <jhowardmsft@users.noreply.github.com>
-John Howard (VM) <John.Howard@microsoft.com> <john.howard@microsoft.com>
-John Stephens <johnstep@docker.com> <johnstep@users.noreply.github.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 <jose@seatgeek.com> <josegonzalez@users.noreply.github.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>
-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>
-Kat Samperi <kat.samperi@gmail.com> <kizzie@users.noreply.github.com>
-Ken Cochrane <kencochrane@gmail.com> <KenCochrane@gmail.com>
-Ken Herner <kherner@progress.com> <chosenken@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 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 <lo@linux.com> <fontanalorenzo@me.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>
-Mateusz Major <apkd@users.noreply.github.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>
-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 Spetsiotis <michael_spets@hotmail.com>
-Michal Minář <miminar@redhat.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>
-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>
-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>
-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>
-Roman Dudin <katrmr@gmail.com> <decadent@users.noreply.github.com>
-Ross Boucher <rboucher@gmail.com>
-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>
-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>
-Stephen Day <stephen.day@docker.com>
-Stephen Day <stephen.day@docker.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 Krzero <thomas.kovatchitch@gmail.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>
-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>
-Trishna Guha <trishnaguha17@gmail.com>
-Tristan Carel <tristan@cogniteev.com>
-Tristan Carel <tristan@cogniteev.com> <tristan.carel@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>
-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 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>
-Vladimir Rutsky <altsysrq@gmail.com> <iamironbob@gmail.com>
-Walter Stanish <walter@pratyeka.org>
-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>
-Xianglin Gao <xlgao@zju.edu.cn>
-Xianlu Bird <xianlubird@gmail.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>
-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>
-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>
-Zhu Kunjia <zhu.kunjia@zte.com.cn>
-Zou Yu <zouyu7@huawei.com>
-
--- a/components/cli/AUTHORS
+++ b/components/cli/AUTHORS
@ -1,638 +0,0 @@
-# This file lists all individuals having contributed content to the repository.
-# For how it is generated, see `scripts/docs/generate-authors.sh`.
-
-Aanand Prasad <aanand.prasad@gmail.com>
-Aaron L. Xu <liker.xu@foxmail.com>
-Aaron Lehmann <aaron.lehmann@docker.com>
-Aaron.L.Xu <likexu@harmonycloud.cn>
-Abdur Rehman <abdur_rehman@mentor.com>
-Abhinandan Prativadi <abhi@docker.com>
-Abin Shahab <ashahab@altiscale.com>
-Addam Hardy <addam.hardy@gmail.com>
-Adolfo Ochagavía <aochagavia92@gmail.com>
-Adrien Duermael <adrien@duermael.com>
-Adrien Folie <folie.adrien@gmail.com>
-Ahmet Alp Balkan <ahmetb@microsoft.com>
-Aidan Feldman <aidan.feldman@gmail.com>
-Aidan Hobson Sayers <aidanhs@cantab.net>
-AJ Bowen <aj@gandi.net>
-Akihiro Suda <suda.akihiro@lab.ntt.co.jp>
-Akim Demaille <akim.demaille@docker.com>
-Alan Thompson <cloojure@gmail.com>
-Albert Callarisa <shark234@gmail.com>
-Aleksa Sarai <asarai@suse.de>
-Alessandro Boch <aboch@tetrationanalytics.com>
-Alex Mavrogiannis <alex.mavrogiannis@docker.com>
-Alexander Boyd <alex@opengroove.org>
-Alexander Larsson <alexl@redhat.com>
-Alexander Morozov <lk4d4@docker.com>
-Alexandre González <agonzalezro@gmail.com>
-Alfred Landrum <alfred.landrum@docker.com>
-Alicia Lauerman <alicia@eta.im>
-Allen Sun <allensun.shl@alibaba-inc.com>
-Alvin Deng <alvin.q.deng@utexas.edu>
-Amen Belayneh <amenbelayneh@gmail.com>
-Amir Goldstein <amir73il@aquasec.com>
-Amit Krishnan <amit.krishnan@oracle.com>
-Amit Shukla <amit.shukla@docker.com>
-Amy Lindburg <amy.lindburg@docker.com>
-Andrea Luzzardi <aluzzardi@gmail.com>
-Andreas Köhler <andi5.py@gmx.net>
-Andrew France <andrew@avito.co.uk>
-Andrew Hsu <andrewhsu@docker.com>
-Andrew Macpherson <hopscotch23@gmail.com>
-Andrew McDonnell <bugs@andrewmcdonnell.net>
-Andrew Po <absourd.noise@gmail.com>
-Andrey Petrov <andrey.petrov@shazow.net>
-André Martins <aanm90@gmail.com>
-Andy Goldstein <agoldste@redhat.com>
-Andy Rothfusz <github@developersupport.net>
-Anil Madhavapeddy <anil@recoil.org>
-Ankush Agarwal <ankushagarwal11@gmail.com>
-Anton Polonskiy <anton.polonskiy@gmail.com>
-Antonio Murdaca <antonio.murdaca@gmail.com>
-Antonis Kalipetis <akalipetis@gmail.com>
-Anusha Ragunathan <anusha.ragunathan@docker.com>
-Arash Deshmeh <adeshmeh@ca.ibm.com>
-Arnaud Porterie <arnaud.porterie@docker.com>
-Ashwini Oruganti <ashwini.oruganti@gmail.com>
-Azat Khuyiyakhmetov <shadow_uz@mail.ru>
-Bardia Keyoumarsi <bkeyouma@ucsc.edu>
-Barnaby Gray <barnaby@pickle.me.uk>
-Bastiaan Bakker <bbakker@xebia.com>
-BastianHofmann <bastianhofmann@me.com>
-Ben Bonnefoy <frenchben@docker.com>
-Ben Firshman <ben@firshman.co.uk>
-Benjamin Boudreau <boudreau.benjamin@gmail.com>
-Bhumika Bayani <bhumikabayani@gmail.com>
-Bill Wang <ozbillwang@gmail.com>
-Bin Liu <liubin0329@gmail.com>
-Bingshen Wang <bingshen.wbs@alibaba-inc.com>
-Boaz Shuster <ripcurld.github@gmail.com>
-Boris Pruessmann <boris@pruessmann.org>
-Bradley Cicenas <bradley.cicenas@gmail.com>
-Brandon Philips <brandon.philips@coreos.com>
-Brent Salisbury <brent.salisbury@docker.com>
-Bret Fisher <bret@bretfisher.com>
-Brian (bex) Exelbierd <bexelbie@redhat.com>
-Brian Goff <cpuguy83@gmail.com>
-Bryan Bess <squarejaw@bsbess.com>
-Bryan Boreham <bjboreham@gmail.com>
-Bryan Murphy <bmurphy1976@gmail.com>
-bryfry <bryon.fryer@gmail.com>
-Cameron Spear <cameronspear@gmail.com>
-Cao Weiwei <cao.weiwei30@zte.com.cn>
-Carlo Mion <mion00@gmail.com>
-Carlos Alexandro Becker <caarlos0@gmail.com>
-Ce Gao <ce.gao@outlook.com>
-Cedric Davies <cedricda@microsoft.com>
-Cezar Sa Espinola <cezarsa@gmail.com>
-Chao Wang <wangchao.fnst@cn.fujitsu.com>
-Charles Chan <charleswhchan@users.noreply.github.com>
-Charles Law <claw@conduce.com>
-Charles Smith <charles.smith@docker.com>
-Charlie Drage <charlie@charliedrage.com>
-ChaYoung You <yousbe@gmail.com>
-Chen Chuanliang <chen.chuanliang@zte.com.cn>
-Chen Hanxiao <chenhanxiao@cn.fujitsu.com>
-Chen Mingjie <chenmingjie0828@163.com>
-Chen Qiu <cheney-90@hotmail.com>
-Chris Gavin <chris@chrisgavin.me>
-Chris Gibson <chris@chrisg.io>
-Chris McKinnel <chrismckinnel@gmail.com>
-Chris Snow <chsnow123@gmail.com>
-Chris Weyl <cweyl@alumni.drew.edu>
-Christian Persson <saser@live.se>
-Christian Stefanescu <st.chris@gmail.com>
-Christophe Robin <crobin@nekoo.com>
-Christophe Vidal <kriss@krizalys.com>
-Christopher Biscardi <biscarch@sketcht.com>
-Christopher Jones <tophj@linux.vnet.ibm.com>
-Christy Perez <christy@linux.vnet.ibm.com>
-Chun Chen <ramichen@tencent.com>
-Clinton Kitson <clintonskitson@gmail.com>
-Coenraad Loubser <coenraad@wish.org.za>
-Colin Hebert <hebert.colin@gmail.com>
-Collin Guarino <collin.guarino@gmail.com>
-Colm Hally <colmhally@gmail.com>
-Corey Farrell <git@cfware.com>
-Cristian Staretu <cristian.staretu@gmail.com>
-Daehyeok Mun <daehyeok@gmail.com>
-Dafydd Crosby <dtcrsby@gmail.com>
-dalanlan <dalanlan925@gmail.com>
-Damien Nadé <github@livna.org>
-Dan Cotora <dan@bluevision.ro>
-Daniel Dao <dqminh@cloudflare.com>
-Daniel Farrell <dfarrell@redhat.com>
-Daniel Gasienica <daniel@gasienica.ch>
-Daniel Goosen <daniel.goosen@surveysampling.com>
-Daniel Hiltgen <daniel.hiltgen@docker.com>
-Daniel J Walsh <dwalsh@redhat.com>
-Daniel Nephin <dnephin@docker.com>
-Daniel Norberg <dano@spotify.com>
-Daniel Watkins <daniel@daniel-watkins.co.uk>
-Daniel Zhang <jmzwcn@gmail.com>
-Danny Berger <dpb587@gmail.com>
-Darren Shepherd <darren.s.shepherd@gmail.com>
-Darren Stahl <darst@microsoft.com>
-Dattatraya Kumbhar <dattatraya.kumbhar@gslab.com>
-Dave Goodchild <buddhamagnet@gmail.com>
-Dave Henderson <dhenderson@gmail.com>
-Dave Tucker <dt@docker.com>
-David Calavera <david.calavera@gmail.com>
-David Cramer <davcrame@cisco.com>
-David Dooling <dooling@gmail.com>
-David Gageot <david@gageot.net>
-David Lechner <david@lechnology.com>
-David Sheets <dsheets@docker.com>
-David Williamson <david.williamson@docker.com>
-David Xia <dxia@spotify.com>
-David Young <yangboh@cn.ibm.com>
-Deng Guangxing <dengguangxing@huawei.com>
-Denis Defreyne <denis@soundcloud.com>
-Denis Gladkikh <denis@gladkikh.email>
-Denis Ollier <larchunix@users.noreply.github.com>
-Dennis Docter <dennis@d23.nl>
-Derek McGowan <derek@mcgstyle.net>
-Deshi Xiao <dxiao@redhat.com>
-Dharmit Shah <shahdharmit@gmail.com>
-Dhawal Yogesh Bhanushali <dbhanushali@vmware.com>
-Dieter Reuter <dieter.reuter@me.com>
-Dima Stopel <dima@twistlock.com>
-Dimitry Andric <d.andric@activevideo.com>
-Ding Fei <dingfei@stars.org.cn>
-Diogo Monica <diogo@docker.com>
-Dmitry Gusev <dmitry.gusev@gmail.com>
-Dmitry Smirnov <onlyjob@member.fsf.org>
-Dmitry V. Krivenok <krivenok.dmitry@gmail.com>
-Don Kjer <don.kjer@gmail.com>
-Dong Chen <dongluo.chen@docker.com>
-Doug Davis <dug@us.ibm.com>
-Drew Erny <drew.erny@docker.com>
-Ed Costello <epc@epcostello.com>
-Eli Uriegas <eli.uriegas@docker.com>
-Eli Uriegas <seemethere101@gmail.com>
-Elias Faxö <elias.faxo@tre.se>
-Eric G. Noriega <enoriega@vizuri.com>
-Eric Rosenberg <ehaydenr@gmail.com>
-Eric Sage <eric.david.sage@gmail.com>
-Eric-Olivier Lamey <eo@lamey.me>
-Erica Windisch <erica@windisch.us>
-Erik Hollensbe <github@hollensbe.org>
-Erik St. Martin <alakriti@gmail.com>
-Ethan Haynes <ethanhaynes@alumni.harvard.edu>
-Eugene Yakubovich <eugene.yakubovich@coreos.com>
-Evan Allrich <evan@unguku.com>
-Evan Hazlett <ejhazlett@gmail.com>
-Evan Krall <krall@yelp.com>
-Evelyn Xu <evelynhsu21@gmail.com>
-Everett Toews <everett.toews@rackspace.com>
-Fabio Falci <fabiofalci@gmail.com>
-Fabrizio Soppelsa <fsoppelsa@mirantis.com>
-Felix Hupfeld <felix@quobyte.com>
-Felix Rabe <felix@rabe.io>
-Flavio Crisciani <flavio.crisciani@docker.com>
-Florian Klein <florian.klein@free.fr>
-Foysal Iqbal <foysal.iqbal.fb@gmail.com>
-Fred Lifton <fred.lifton@docker.com>
-Frederick F. Kautz IV <fkautz@redhat.com>
-Frederik Nordahl Jul Sabroe <frederikns@gmail.com>
-Frieder Bluemle <frieder.bluemle@gmail.com>
-Gabriel Nicolas Avellaneda <avellaneda.gabriel@gmail.com>
-Gaetan de Villele <gdevillele@gmail.com>
-Gang Qiao <qiaohai8866@gmail.com>
-Gary Schaetz <gary@schaetzkc.com>
-Genki Takiuchi <genki@s21g.com>
-George MacRorie <gmacr31@gmail.com>
-George Xie <georgexsh@gmail.com>
-Gianluca Borello <g.borello@gmail.com>
-Gildas Cuisinier <gildas.cuisinier@gcuisinier.net>
-Gou Rao <gou@portworx.com>
-Grant Reaber <grant.reaber@gmail.com>
-Greg Pflaum <gpflaum@users.noreply.github.com>
-Guilhem Lettron <guilhem+github@lettron.fr>
-Guillaume J. Charmes <guillaume.charmes@docker.com>
-gwx296173 <gaojing3@huawei.com>
-Günther Jungbluth <gunther@gameslabs.net>
-Hakan Özler <hakan.ozler@kodcu.com>
-Hao Zhang <21521210@zju.edu.cn>
-Harald Albers <github@albersweb.de>
-Harold Cooper <hrldcpr@gmail.com>
-Harry Zhang <harryz@hyper.sh>
-He Simei <hesimei@zju.edu.cn>
-Helen Xie <chenjg@harmonycloud.cn>
-Henning Sprang <henning.sprang@gmail.com>
-Hernan Garcia <hernandanielg@gmail.com>
-Hongbin Lu <hongbin034@gmail.com>
-Hu Keping <hukeping@huawei.com>
-Huayi Zhang <irachex@gmail.com>
-huqun <huqun@zju.edu.cn>
-Huu Nguyen <huu@prismskylabs.com>
-Hyzhou Zhy <hyzhou.zhy@alibaba-inc.com>
-Ian Campbell <ian.campbell@docker.com>
-Ian Philpot <ian.philpot@microsoft.com>
-Ignacio Capurro <icapurrofagian@gmail.com>
-Ilya Dmitrichenko <errordeveloper@gmail.com>
-Ilya Khlopotov <ilya.khlopotov@gmail.com>
-Ilya Sotkov <ilya@sotkov.com>
-Isabel Jimenez <contact.isabeljimenez@gmail.com>
-Ivan Grcic <igrcic@gmail.com>
-Ivan Markin <sw@nogoegst.net>
-Jacob Atzen <jacob@jacobatzen.dk>
-Jacob Tomlinson <jacob@tom.linson.uk>
-Jaivish Kothari <janonymous.codevulture@gmail.com>
-Jake Sanders <jsand@google.com>
-James Nesbitt <james.nesbitt@wunderkraut.com>
-James Turnbull <james@lovedthanlost.net>
-Jamie Hannaford <jamie@limetree.org>
-Jan Koprowski <jan.koprowski@gmail.com>
-Jan Pazdziora <jpazdziora@redhat.com>
-Jan-Jaap Driessen <janjaapdriessen@gmail.com>
-Jana Radhakrishnan <mrjana@docker.com>
-Jared Hocutt <jaredh@netapp.com>
-Jasmine Hegman <jasmine@jhegman.com>
-Jason Heiss <jheiss@aput.net>
-Jason Plum <jplum@devonit.com>
-Jay Kamat <github@jgkamat.33mail.com>
-Jean-Pierre Huynh <jean-pierre.huynh@ounet.fr>
-Jean-Pierre Huynh <jp@moogsoft.com>
-Jeff Lindsay <progrium@gmail.com>
-Jeff Nickoloff <jeff.nickoloff@gmail.com>
-Jeff Silberman <jsilberm@gmail.com>
-Jeremy Chambers <jeremy@thehipbot.com>
-Jeremy Unruh <jeremybunruh@gmail.com>
-Jeremy Yallop <yallop@docker.com>
-Jeroen Franse <jeroenfranse@gmail.com>
-Jesse Adametz <jesseadametz@gmail.com>
-Jessica Frazelle <jessfraz@google.com>
-Jezeniel Zapanta <jpzapanta22@gmail.com>
-Jian Zhang <zhangjian.fnst@cn.fujitsu.com>
-Jie Luo <luo612@zju.edu.cn>
-Jilles Oldenbeuving <ojilles@gmail.com>
-Jim Galasyn <jim.galasyn@docker.com>
-Jimmy Leger <jimmy.leger@gmail.com>
-Jimmy Song <rootsongjc@gmail.com>
-jimmyxian <jimmyxian2004@yahoo.com.cn>
-Joao Fernandes <joao.fernandes@docker.com>
-Joe Doliner <jdoliner@pachyderm.io>
-Joe Gordon <joe.gordon0@gmail.com>
-Joel Handwell <joelhandwell@gmail.com>
-Joey Geiger <jgeiger@gmail.com>
-Joffrey F <joffrey@docker.com>
-Johan Euphrosine <proppy@google.com>
-Johannes 'fish' Ziemke <github@freigeist.org>
-John Feminella <jxf@jxf.me>
-John Harris <john@johnharris.io>
-John Howard (VM) <John.Howard@microsoft.com>
-John Laswell <john.n.laswell@gmail.com>
-John Maguire <jmaguire@duosecurity.com>
-John Mulhausen <john@docker.com>
-John Starks <jostarks@microsoft.com>
-John Stephens <johnstep@docker.com>
-John Tims <john.k.tims@gmail.com>
-John V. Martinez <jvmatl@gmail.com>
-John Willis <john.willis@docker.com>
-Jonathan Boulle <jonathanboulle@gmail.com>
-Jonathan Lee <jonjohn1232009@gmail.com>
-Jonathan Lomas <jonathan@floatinglomas.ca>
-Jonathan McCrohan <jmccrohan@gmail.com>
-Jonh Wendell <jonh.wendell@redhat.com>
-Jordan Jennings <jjn2009@gmail.com>
-Joseph Kern <jkern@semafour.net>
-Josh Bodah <jb3689@yahoo.com>
-Josh Chorlton <jchorlton@gmail.com>
-Josh Hawn <josh.hawn@docker.com>
-Josh Horwitz <horwitz@addthis.com>
-Josh Soref <jsoref@gmail.com>
-Julien Barbier <write0@gmail.com>
-Julien Kassar <github@kassisol.com>
-Julien Maitrehenry <julien.maitrehenry@me.com>
-Justas Brazauskas <brazauskasjustas@gmail.com>
-Justin Cormack <justin.cormack@docker.com>
-Justin Simonelis <justin.p.simonelis@gmail.com>
-Jyrki Puttonen <jyrkiput@gmail.com>
-Jérôme Petazzoni <jerome.petazzoni@docker.com>
-Jörg Thalheim <joerg@higgsboson.tk>
-Kai Blin <kai@samba.org>
-Kai Qiang Wu (Kennan) <wkq5325@gmail.com>
-Kara Alexandra <kalexandra@us.ibm.com>
-Kareem Khazem <karkhaz@karkhaz.com>
-Karthik Nayak <Karthik.188@gmail.com>
-Kat Samperi <kat.samperi@gmail.com>
-Katie McLaughlin <katie@glasnt.com>
-Ke Xu <leonhartx.k@gmail.com>
-Kei Ohmura <ohmura.kei@gmail.com>
-Keith Hudgins <greenman@greenman.org>
-Ken Cochrane <kencochrane@gmail.com>
-Ken ICHIKAWA <ichikawa.ken@jp.fujitsu.com>
-Kenfe-Mickaël Laventure <mickael.laventure@gmail.com>
-Kevin Burke <kev@inburke.com>
-Kevin Feyrer <kevin.feyrer@btinternet.com>
-Kevin Kern <kaiwentan@harmonycloud.cn>
-Kevin Meredith <kevin.m.meredith@gmail.com>
-Kevin Richardson <kevin@kevinrichardson.co>
-khaled souf <khaled.souf@gmail.com>
-Kim Eik <kim@heldig.org>
-Kir Kolyshkin <kolyshkin@gmail.com>
-Kotaro Yoshimatsu <kotaro.yoshimatsu@gmail.com>
-Krasi Georgiev <krasi@vip-consult.solutions>
-Kris-Mikael Krister <krismikael@protonmail.com>
-Kun Zhang <zkazure@gmail.com>
-Kunal Kushwaha <kushwaha_kunal_v7@lab.ntt.co.jp>
-Kyle Spiers <kyle@spiers.me>
-Lachlan Cooper <lachlancooper@gmail.com>
-Lai Jiangshan <jiangshanlai@gmail.com>
-Lars Kellogg-Stedman <lars@redhat.com>
-Laura Frank <ljfrank@gmail.com>
-Laurent Erignoux <lerignoux@gmail.com>
-Lei Jitang <leijitang@huawei.com>
-Lennie <github@consolejunkie.net>
-Leo Gallucci <elgalu3@gmail.com>
-Lewis Daly <lewisdaly@me.com>
-Li Yi <denverdino@gmail.com>
-Li Yi <weiyuan.yl@alibaba-inc.com>
-Liang-Chi Hsieh <viirya@gmail.com>
-Lily Guo <lily.guo@docker.com>
-Lin Lu <doraalin@163.com>
-Linus Heckemann <lheckemann@twig-world.com>
-Liping Xue <lipingxue@gmail.com>
-Liron Levin <liron@twistlock.com>
-liwenqi <vikilwq@zju.edu.cn>
-lixiaobing10051267 <li.xiaobing1@zte.com.cn>
-Lloyd Dewolf <foolswisdom@gmail.com>
-Lorenzo Fontana <lo@linux.com>
-Louis Opter <kalessin@kalessin.fr>
-Luca Favatella <luca.favatella@erlang-solutions.com>
-Luca Marturana <lucamarturana@gmail.com>
-Lucas Chan <lucas-github@lucaschan.com>
-Luka Hartwig <mail@lukahartwig.de>
-Lukasz Zajaczkowski <Lukasz.Zajaczkowski@ts.fujitsu.com>
-Lénaïc Huard <lhuard@amadeus.com>
-Ma Shimiao <mashimiao.fnst@cn.fujitsu.com>
-Mabin <bin.ma@huawei.com>
-Madhav Puri <madhav.puri@gmail.com>
-Madhu Venugopal <madhu@socketplane.io>
-Malte Janduda <mail@janduda.net>
-Manjunath A Kumatagi <mkumatag@in.ibm.com>
-Mansi Nahar <mmn4185@rit.edu>
-mapk0y <mapk0y@gmail.com>
-Marc Bihlmaier <marc.bihlmaier@reddoxx.com>
-Marco Mariani <marco.mariani@alterway.fr>
-Marcus Martins <marcus@docker.com>
-Marianna Tessel <mtesselh@gmail.com>
-Marius Sturm <marius@graylog.com>
-Mark Oates <fl0yd@me.com>
-Martin Mosegaard Amdisen <martin.amdisen@praqma.com>
-Mary Anthony <mary.anthony@docker.com>
-Mason Malone <mason.malone@gmail.com>
-Mateusz Major <apkd@users.noreply.github.com>
-Matt Gucci <matt9ucci@gmail.com>
-Matt Robenolt <matt@ydekproductions.com>
-Matthew Heon <mheon@redhat.com>
-Matthieu Hauglustaine <matt.hauglustaine@gmail.com>
-Max Shytikov <mshytikov@gmail.com>
-Maxime Petazzoni <max@signalfuse.com>
-Mei ChunTao <mei.chuntao@zte.com.cn>
-Micah Zoltu <micah@newrelic.com>
-Michael A. Smith <michael@smith-li.com>
-Michael Bridgen <mikeb@squaremobius.net>
-Michael Crosby <michael@docker.com>
-Michael Friis <friism@gmail.com>
-Michael Irwin <mikesir87@gmail.com>
-Michael Käufl <docker@c.michael-kaeufl.de>
-Michael Prokop <github@michael-prokop.at>
-Michael Scharf <github@scharf.gr>
-Michael Spetsiotis <michael_spets@hotmail.com>
-Michael Steinert <mike.steinert@gmail.com>
-Michael West <mwest@mdsol.com>
-Michal Minář <miminar@redhat.com>
-Michał Czeraszkiewicz <czerasz@gmail.com>
-Miguel Angel Alvarez Cabrerizo <doncicuto@gmail.com>
-Mihai Borobocea <MihaiBorob@gmail.com>
-Mihuleacc Sergiu <mihuleac.sergiu@gmail.com>
-Mike Brown <brownwm@us.ibm.com>
-Mike Casas <mkcsas0@gmail.com>
-Mike Danese <mikedanese@google.com>
-Mike Dillon <mike@embody.org>
-Mike Goelzer <mike.goelzer@docker.com>
-Mike MacCana <mike.maccana@gmail.com>
-mikelinjie <294893458@qq.com>
-Mikhail Vasin <vasin@cloud-tv.ru>
-Milind Chawre <milindchawre@gmail.com>
-Misty Stanley-Jones <misty@docker.com>
-Mohammad Banikazemi <mb@us.ibm.com>
-Mohammed Aaqib Ansari <maaquib@gmail.com>
-Moorthy RS <rsmoorthy@gmail.com>
-Morgan Bauer <mbauer@us.ibm.com>
-Moysés Borges <moysesb@gmail.com>
-Mrunal Patel <mrunalp@gmail.com>
-muicoder <muicoder@gmail.com>
-Muthukumar R <muthur@gmail.com>
-Máximo Cuadros <mcuadros@gmail.com>
-Nace Oroz <orkica@gmail.com>
-Nahum Shalman <nshalman@omniti.com>
-Nalin Dahyabhai <nalin@redhat.com>
-Natalie Parker <nparker@omnifone.com>
-Nate Brennand <nate.brennand@clever.com>
-Nathan Hsieh <hsieh.nathan@gmail.com>
-Nathan LeClaire <nathan.leclaire@docker.com>
-Nathan McCauley <nathan.mccauley@docker.com>
-Neil Peterson <neilpeterson@outlook.com>
-Nicola Kabar <nicolaka@gmail.com>
-Nicolas Borboën <ponsfrilus@gmail.com>
-Nicolas De Loof <nicolas.deloof@gmail.com>
-Nikhil Chawla <chawlanikhil24@gmail.com>
-Nikolas Garofil <nikolas.garofil@uantwerpen.be>
-Nikolay Milovanov <nmil@itransformers.net>
-Nishant Totla <nishanttotla@gmail.com>
-NIWA Hideyuki <niwa.niwa@nifty.ne.jp>
-Noah Treuhaft <noah.treuhaft@docker.com>
-O.S. Tezer <ostezer@gmail.com>
-ohmystack <jun.jiang02@ele.me>
-Olle Jonsson <olle.jonsson@gmail.com>
-Otto Kekäläinen <otto@seravo.fi>
-Ovidio Mallo <ovidio.mallo@gmail.com>
-Pascal Borreli <pascal@borreli.com>
-Patrick Böänziger <patrick.baenziger@bsi-software.com>
-Patrick Hemmer <patrick.hemmer@gmail.com>
-Patrick Lang <plang@microsoft.com>
-Paul <paul9869@gmail.com>
-Paul Kehrer <paul.l.kehrer@gmail.com>
-Paul Lietar <paul@lietar.net>
-Paul Weaver <pauweave@cisco.com>
-Pavel Pospisil <pospispa@gmail.com>
-Paweł Szczekutowicz <pszczekutowicz@gmail.com>
-Peeyush Gupta <gpeeyush@linux.vnet.ibm.com>
-Peter Edge <peter.edge@gmail.com>
-Peter Jaffe <pjaffe@nevo.com>
-Peter Nagy <xificurC@gmail.com>
-Peter Salvatore <peter@psftw.com>
-Peter Waller <p@pwaller.net>
-Phil Estes <estesp@linux.vnet.ibm.com>
-Philip Alexander Etling <paetling@gmail.com>
-Philipp Gillé <philipp.gille@gmail.com>
-pidster <pid@pidster.com>
-pixelistik <pixelistik@users.noreply.github.com>
-Pratik Karki <prertik@outlook.com>
-Prayag Verma <prayag.verma@gmail.com>
-Pure White <daniel48@126.com>
-Qiang Huang <h.huangqiang@huawei.com>
-Qinglan Peng <qinglanpeng@zju.edu.cn>
-qudongfang <qudongfang@gmail.com>
-Raghavendra K T <raghavendra.kt@linux.vnet.ibm.com>
-Ray Tsang <rayt@google.com>
-Reficul <xuzhenglun@gmail.com>
-Remy Suen <remy.suen@gmail.com>
-Renaud Gaubert <rgaubert@nvidia.com>
-Ricardo N Feliciano <FelicianoTech@gmail.com>
-Rich Moyse <rich@moyse.us>
-Richard Mathie <richard.mathie@amey.co.uk>
-Richard Scothern <richard.scothern@gmail.com>
-Rick Wieman <git@rickw.nl>
-Ritesh H Shukla <sritesh@vmware.com>
-Riyaz Faizullabhoy <riyaz.faizullabhoy@docker.com>
-Robert Wallis <smilingrob@gmail.com>
-Robin Naundorf <r.naundorf@fh-muenster.de>
-Robin Speekenbrink <robin@kingsquare.nl>
-Rodolfo Ortiz <rodolfo.ortiz@definityfirst.com>
-Rogelio Canedo <rcanedo@mappy.priv>
-Roland Kammerer <roland.kammerer@linbit.com>
-Roman Dudin <katrmr@gmail.com>
-Rory Hunter <roryhunter2@gmail.com>
-Ross Boucher <rboucher@gmail.com>
-Rubens Figueiredo <r.figueiredo.52@gmail.com>
-Ryan Belgrave <rmb1993@gmail.com>
-Ryan Detzel <ryan.detzel@gmail.com>
-Ryan Stelly <ryan.stelly@live.com>
-Sainath Grandhi <sainath.grandhi@intel.com>
-Sakeven Jiang <jc5930@sina.cn>
-Sally O'Malley <somalley@redhat.com>
-Sam Neirinck <sam@samneirinck.com>
-Sambuddha Basu <sambuddhabasu1@gmail.com>
-Samuel Karp <skarp@amazon.com>
-Santhosh Manohar <santhosh@docker.com>
-Scott Collier <emailscottcollier@gmail.com>
-Sean Christopherson <sean.j.christopherson@intel.com>
-Sean Rodman <srodman7689@gmail.com>
-Sebastiaan van Stijn <github@gone.nl>
-Sergey Tryuber <Sergeant007@users.noreply.github.com>
-Serhat Gülçiçek <serhat25@gmail.com>
-Sevki Hasirci <s@sevki.org>
-Shaun Kaasten <shaunk@gmail.com>
-Sheng Yang <sheng@yasker.org>
-Shijiang Wei <mountkin@gmail.com>
-Shishir Mahajan <shishir.mahajan@redhat.com>
-Shoubhik Bose <sbose78@gmail.com>
-Shukui Yang <yangshukui@huawei.com>
-Sian Lerk Lau <kiawin@gmail.com>
-Sidhartha Mani <sidharthamn@gmail.com>
-sidharthamani <sid@rancher.com>
-Silvin Lubecki <silvin.lubecki@docker.com>
-Simei He <hesimei@zju.edu.cn>
-Simon Ferquel <simon.ferquel@docker.com>
-Sindhu S <sindhus@live.in>
-Slava Semushin <semushin@redhat.com>
-Solomon Hykes <solomon@docker.com>
-Song Gao <song@gao.io>
-Spencer Brown <spencer@spencerbrown.org>
-squeegels <1674195+squeegels@users.noreply.github.com>
-Srini Brahmaroutu <srbrahma@us.ibm.com>
-Stefan S. <tronicum@user.github.com>
-Stefan Scherer <scherer_stefan@icloud.com>
-Stefan Weil <sw@weilnetz.de>
-Stephen Day <stephen.day@docker.com>
-Stephen Rust <srust@blockbridge.com>
-Steve Durrheimer <s.durrheimer@gmail.com>
-Steven Burgess <steven.a.burgess@hotmail.com>
-Subhajit Ghosh <isubuz.g@gmail.com>
-Sun Jianbo <wonderflow.sun@gmail.com>
-Sungwon Han <sungwon.han@navercorp.com>
-Sven Dowideit <SvenDowideit@home.org.au>
-Sylvain Baubeau <sbaubeau@redhat.com>
-Sébastien HOUZÉ <cto@verylastroom.com>
-T K Sourabh <sourabhtk37@gmail.com>
-TAGOMORI Satoshi <tagomoris@gmail.com>
-Taylor Jones <monitorjbl@gmail.com>
-Thatcher Peskens <thatcher@docker.com>
-Thomas Gazagnaire <thomas@gazagnaire.org>
-Thomas Krzero <thomas.kovatchitch@gmail.com>
-Thomas Leonard <thomas.leonard@docker.com>
-Thomas Léveil <thomasleveil@gmail.com>
-Thomas Riccardi <riccardi@systran.fr>
-Thomas Swift <tgs242@gmail.com>
-Tianon Gravi <admwiggin@gmail.com>
-Tianyi Wang <capkurmagati@gmail.com>
-Tibor Vass <teabee89@gmail.com>
-Tim Dettrick <t.dettrick@uq.edu.au>
-Tim Hockin <thockin@google.com>
-Tim Smith <timbot@google.com>
-Tim Waugh <twaugh@redhat.com>
-Tim Wraight <tim.wraight@tangentlabs.co.uk>
-timfeirg <kkcocogogo@gmail.com>
-Timothy Hobbs <timothyhobbs@seznam.cz>
-Tobias Bradtke <webwurst@gmail.com>
-Tobias Gesellchen <tobias@gesellix.de>
-Todd Whiteman <todd.whiteman@joyent.com>
-Tom Denham <tom@tomdee.co.uk>
-Tom Fotherby <tom+github@peopleperhour.com>
-Tom X. Tobin <tomxtobin@tomxtobin.com>
-Tomas Tomecek <ttomecek@redhat.com>
-Tomasz Kopczynski <tomek@kopczynski.net.pl>
-Tomáš Hrčka <thrcka@redhat.com>
-Tony Abboud <tdabboud@hotmail.com>
-Tõnis Tiigi <tonistiigi@gmail.com>
-Trapier Marshall <trapier.marshall@docker.com>
-Travis Cline <travis.cline@gmail.com>
-Tristan Carel <tristan@cogniteev.com>
-Tycho Andersen <tycho@docker.com>
-Tycho Andersen <tycho@tycho.ws>
-uhayate <uhayate.gong@daocloud.io>
-Umesh Yadav <umesh4257@gmail.com>
-Valentin Lorentz <progval+git@progval.net>
-Veres Lajos <vlajos@gmail.com>
-Victor Vieux <victor.vieux@docker.com>
-Victoria Bialas <victoria.bialas@docker.com>
-Viktor Stanchev <me@viktorstanchev.com>
-Vincent Batts <vbatts@redhat.com>
-Vincent Bernat <Vincent.Bernat@exoscale.ch>
-Vincent Demeester <vincent.demeester@docker.com>
-Vincent Woo <me@vincentwoo.com>
-Vishnu Kannan <vishnuk@google.com>
-Vivek Goyal <vgoyal@redhat.com>
-Wang Jie <wangjie5@chinaskycloud.com>
-Wang Long <long.wanglong@huawei.com>
-Wang Ping <present.wp@icloud.com>
-Wang Xing <hzwangxing@corp.netease.com>
-Wang Yuexiao <wang.yuexiao@zte.com.cn>
-Wataru Ishida <ishida.wataru@lab.ntt.co.jp>
-Wayne Song <wsong@docker.com>
-Wen Cheng Ma <wenchma@cn.ibm.com>
-Wenzhi Liang <wenzhi.liang@gmail.com>
-Wes Morgan <cap10morgan@gmail.com>
-Wewang Xiaorenfine <wang.xiaoren@zte.com.cn>
-William Henry <whenry@redhat.com>
-Xianglin Gao <xlgao@zju.edu.cn>
-Xinbo Weng <xihuanbo_0521@zju.edu.cn>
-Xuecong Liao <satorulogic@gmail.com>
-Yan Feng <yanfeng2@huawei.com>
-Yanqiang Miao <miao.yanqiang@zte.com.cn>
-Yassine Tijani <yasstij11@gmail.com>
-Yi EungJun <eungjun.yi@navercorp.com>
-Ying Li <ying.li@docker.com>
-Yong Tang <yong.tang.github@outlook.com>
-Yosef Fertel <yfertel@gmail.com>
-Yu Peng <yu.peng36@zte.com.cn>
-Yuan Sun <sunyuan3@huawei.com>
-Yunxiang Huang <hyxqshk@vip.qq.com>
-zebrilee <zebrilee@gmail.com>
-Zhang Kun <zkazure@gmail.com>
-Zhang Wei <zhangwei555@huawei.com>
-Zhang Wentao <zhangwentao234@huawei.com>
-ZhangHang <stevezhang2014@gmail.com>
-zhenghenghuo <zhenghenghuo@zju.edu.cn>
-Zhou Hao <zhouhao@cn.fujitsu.com>
-Zhu Guihua <zhugh.fnst@cn.fujitsu.com>
-Álex González <agonzalezro@gmail.com>
-Álvaro Lázaro <alvaro.lazaro.g@gmail.com>
-Átila Camurça Alves <camurca.home@gmail.com>
-徐俊杰 <paco.xu@daocloud.io>
--- a/components/cli/CONTRIBUTING.md
+++ b/components/cli/CONTRIBUTING.md
@ -1,365 +0,0 @@
-# Contributing to Docker
-
-Want to hack on Docker? Awesome!  We have a contributor's guide that explains
-[setting up a Docker development environment and the contribution
-process](https://docs.docker.com/opensource/project/who-written-for/). 
-
-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](#docker-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](#docker-community-guidelines)
-
-## Reporting security issues
-
-The Docker maintainers take security seriously. If you discover a security
-issue, please bring it to their attention right away!
-
-Please **DO NOT** file a public issue, instead send your report privately to
-[security@docker.com](mailto:security@docker.com).
-
-Security reports are greatly appreciated and we will publicly thank you for it.
-We also like to send gifts&mdash;if you're into Docker schwag, make sure to let
-us know. We currently do not offer a paid security bounty program, but are not
-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/docker/cli/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.
-
-### 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/docker/cli/issues) before
-anybody starts working on it.
-
-We are always thrilled to receive pull requests. We do our best to process them
-quickly. If your pull request is not accepted on the first try,
-don't get discouraged! Our contributor's guide explains [the review process we
-use for simple changes](https://docs.docker.com/opensource/workflow/make-a-contribution/).
-
-### Talking to other Docker users and contributors
-
-<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 Docker and related projects in the Docker Ecosystem. To participate,
-      just log in with your Docker Hub account on <a href="https://forums.docker.com" target="_blank">https://forums.docker.com</a>.
-    </td>
-  </tr>
-  <tr>
-    <td>Community Slack</td>
-    <td>
-      The Docker Community has a dedicated Slack chat to discuss features and issues.  You can sign-up <a href="https://community.docker.com/registrations/groups/4316" target="_blank">with this link</a>.
-    </td>
-  </tr>
-  <tr>
-    <td>Twitter</td>
-    <td>
-      You can follow <a href="https://twitter.com/docker/" target="_blank">Docker's Twitter feed</a>
-      to get updates on our products. You can also tweet us questions or just
-      share blogs or stories.
-    </td>
-  </tr>
-  <tr>
-    <td>Stack Overflow</td>
-    <td>
-      Stack Overflow has over 17000 Docker questions listed. We regularly
-      monitor <a href="https://stackoverflow.com/search?tab=newest&q=docker" target="_blank">Docker questions</a>
-      and so do many other knowledgeable Docker users.
-    </td>
-  </tr>
-</table>
-
-
-### Conventions
-
-Fork the repository 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.
-
-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](README.md) on your branch before
-submitting a pull request.
-
-Update the documentation when creating or modifying features. Test your
-documentation changes for clarity, concision, and correctness, as well as a
-clean documentation build. See our contributors guide for [our style
-guide](https://docs.docker.com/opensource/doc-style) and instructions on [building
-the documentation](https://docs.docker.com/opensource/project/test-and-docs/#build-and-test-the-documentation).
-
-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.
-
-Pull request descriptions should be as clear as possible and include a reference
-to all the issues that they address.
-
-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.
-
-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.
-
-Pull requests must be cleanly rebased on top of master without multiple branches
-mixed into the PR.
-
-**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`.
-
-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. 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 the pull request
-description 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
-
-Docker maintainers use LGTM (Looks Good To Me) in comments on the code review to
-indicate acceptance.
-
-A change requires LGTMs from an absolute majority of the maintainers of each
-component affected. For example, if a change affects `docs/` and `registry/`, it
-needs an absolute majority from the maintainers of `docs/` AND, separately, an
-absolute majority of the maintainers of `registry/`.
-
-For more details, see the [MAINTAINERS](MAINTAINERS) 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.
-660 York Street, Suite 102,
-San Francisco, CA 94110 USA
-
-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 
-global [MAINTAINERS](https://github.com/docker/opensource/blob/master/MAINTAINERS)
-file in the [https://github.com/docker/opensource/](https://github.com/docker/opensource/)
-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!
-
-## Docker community guidelines
-
-We want to keep the Docker 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.
-
-### 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.
--- a/components/cli/Jenkinsfile
+++ b/components/cli/Jenkinsfile
@ -1,12 +0,0 @@
-wrappedNode(label: 'linux && x86_64', cleanWorkspace: true) {
-  timeout(time: 60, unit: 'MINUTES') {
-    stage "Git Checkout"
-    checkout scm
-
-    stage "Run end-to-end test suite"
-    sh "docker version"
-    sh "E2E_UNIQUE_ID=clie2e${BUILD_NUMBER} \
-        IMAGE_TAG=clie2e${BUILD_NUMBER} \
-        make -f docker.Makefile test-e2e"
-  }
-}
--- a/components/cli/MAINTAINERS
+++ b/components/cli/MAINTAINERS
@ -1,6 +1,6 @@
 # Docker maintainers file
 #
-# This file describes who runs the docker/cli project and how.
+# This file describes who runs the docker/docker project and how.
 # This is a living document - if you see something out of date or missing, speak up!
 #
 # It is structured to be consumable by both humans and programs.
@ -21,12 +21,22 @@
 	# a subsystem, they are responsible for doing so and holding the
 	# subsystem maintainers accountable. If ownership is unclear, they are the de facto owners.

+	# For each release (including minor releases), a "release captain" is assigned from the
+	# pool of core maintainers. Rotation is encouraged across all maintainers, to ensure
+	# the release process is clear and up-to-date.
+
 		people = [
 			"aaronlehmann",
-			"albers",
+			"aluzzardi",
+			"anusha",
 			"cpuguy83",
+			"crosbymichael",
 			"dnephin",
+			"ehazlett",
+			"johnstep",
 			"justincormack",
+			"mavenugo",
+			"mlaventure",
 			"stevvooe",
 			"tibor",
 			"tonistiigi",
@ -56,6 +66,7 @@
 	# - close an issue or pull request when it's inappropriate or off-topic

 		people = [
+			"ehazlett",
 			"programmerq",
 			"thajeztah"
 		]
@ -73,21 +84,41 @@
 	Email = "aaron.lehmann@docker.com"
 	GitHub = "aaronlehmann"

-	[people.albers]
-	Name = "Harald Albers"
-	Email = "github@albersweb.de"
-	GitHub = "albers"
+	[people.aluzzardi]
+	Name = "Andrea Luzzardi"
+	Email = "al@docker.com"
+	GitHub = "aluzzardi"
+
+	[people.anusha]
+	Name = "Anusha Ragunathan"
+	Email = "anusha@docker.com"
+	GitHub = "anusha-ragunathan"

 	[people.cpuguy83]
 	Name = "Brian Goff"
 	Email = "cpuguy83@gmail.com"
-	GitHub = "cpuguy83"
+	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.ehazlett]
+	Name = "Evan Hazlett"
+	Email = "ejhazlett@gmail.com"
+	GitHub = "ehazlett"
+
+	[people.johnstep]
+	Name = "John Stephens"
+	Email = "johnstep@docker.com"
+	GitHub = "johnstep"
+
 	[people.justincormack]
 	Name = "Justin Cormack"
 	Email = "justin.cormack@docker.com"
@ -96,12 +127,17 @@
 	[people.misty]
 	Name = "Misty Stanley-Jones"
 	Email = "misty@docker.com"
-	GitHub = "mistyhacks"
+	GitHub = "mstanleyjones"

-	[people.programmerq]
-	Name = "Jeff Anderson"
-	Email = "jeff@docker.com"
-	GitHub = "programmerq"
+	[people.mlaventure]
+	Name = "Kenfe-Mickaël Laventure"
+	Email = "mickael.laventure@docker.com"
+	GitHub = "mlaventure"
+
+	[people.shykes]
+	Name = "Solomon Hykes"
+	Email = "solomon@docker.com"
+	GitHub = "shykes"

 	[people.stevvooe]
 	Name = "Stephen Day"
--- a/components/cli/Makefile
+++ b/components/cli/Makefile
@ -3,88 +3,64 @@
 #
 all: binary

-
-_:=$(shell ./scripts/warn-outside-container $(MAKECMDGOALS))
-
+# remove build artifacts
 .PHONY: clean
-clean: ## remove build artifacts
+clean:
 	rm -rf ./build/* cli/winresources/rsrc_* ./man/man[1-9] docs/yaml/gen

-.PHONY: test-unit
-test-unit: ## run unit test
-	./scripts/test/unit $(shell go list ./... | grep -vE '/vendor/|/e2e/')
-
+# run go test
+# the "-tags daemon" part is temporary
 .PHONY: test
-test: test-unit ## run tests
+test:
+	./scripts/test/unit $(shell go list ./... | grep -v '/vendor/')

 .PHONY: test-coverage
-test-coverage: ## run test coverage
-	./scripts/test/unit-with-coverage $(shell go list ./... | grep -vE '/vendor/|/e2e/')
+test-coverage:
+	./scripts/test/unit-with-coverage $(shell go list ./... | grep -v '/vendor/')

 .PHONY: lint
-lint: ## run all the lint tools
+lint:
 	gometalinter --config gometalinter.json ./...

 .PHONY: binary
-binary: ## build executable for Linux
+binary:
 	@echo "WARNING: binary creates a Linux executable. Use cross for macOS or Windows."
 	./scripts/build/binary

 .PHONY: cross
-cross: ## build executable for macOS and Windows
+cross:
 	./scripts/build/cross

-.PHONY: binary-windows
-binary-windows: ## build executable for Windows
-	./scripts/build/windows
-
-.PHONY: binary-osx
-binary-osx: ## build executable for macOS
-	./scripts/build/osx
-
 .PHONY: dynbinary
-dynbinary: ## build dynamically linked binary
+dynbinary:
 	./scripts/build/dynbinary

 .PHONY: watch
-watch: ## monitor file changes and run go test
+watch:
 	./scripts/test/watch

-vendor: vendor.conf ## check that vendor matches vendor.conf
-	rm -rf vendor
-	bash -c 'vndr |& grep -v -i clone'
+# Check vendor matches vendor.conf
+vendor: vendor.conf
+	vndr 2> /dev/null
 	scripts/validate/check-git-diff vendor

-.PHONY: authors
-authors: ## generate AUTHORS file from git history
-	scripts/docs/generate-authors.sh
-
+## generate man pages from go source and markdown
 .PHONY: manpages
-manpages: ## generate man pages from go source and markdown
+manpages:
 	scripts/docs/generate-man.sh

+## generate documentation YAML files consumed by docs repo
 .PHONY: yamldocs
-yamldocs: ## generate documentation YAML files consumed by docs repo
+yamldocs:
 	scripts/docs/generate-yaml.sh

+## Shellcheck validation
 .PHONY: shellcheck
-shellcheck: ## run shellcheck validation
+shellcheck:
 	scripts/validate/shellcheck

-.PHONY: help
-help: ## print this help
-	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {sub("\\\\n",sprintf("\n%22c"," "), $$2);printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
-
-
 cli/compose/schema/bindata.go: cli/compose/schema/data/*.json
 	go generate github.com/docker/cli/cli/compose/schema

 compose-jsonschema: cli/compose/schema/bindata.go
 	scripts/validate/check-git-diff cli/compose/schema/bindata.go
-
-.PHONY: ci-validate
-ci-validate:
-	time make -B vendor
-	time make -B compose-jsonschema
-	time make manpages
-	time make yamldocs
--- a/components/cli/README.md
+++ b/components/cli/README.md
@ -1,4 +1,4 @@
-[![build status](https://circleci.com/gh/docker/cli.svg?style=shield)](https://circleci.com/gh/docker/cli/tree/master) [![Build Status](https://jenkins.dockerproject.org/job/docker/job/cli/job/master/badge/icon)](https://jenkins.dockerproject.org/job/docker/job/cli/job/master/)
+[![build status](https://circleci.com/gh/docker/cli.svg?style=shield)](https://circleci.com/gh/docker/cli/tree/master)

 docker/cli
 ==========
@ -29,12 +29,6 @@ Run all linting:
 $ make -f docker.Makefile lint
 ```

-List all the available targets:
-
-```
-$ make help
-```
-
 ### In-container development environment

 Start an interactive development environment:
--- a/components/cli/TESTING.md
+++ b/components/cli/TESTING.md
@ -1,87 +0,0 @@
-# Testing
-
-The following guidelines summarize the testing policy for docker/cli.
-
-## Unit Test Suite
-
-All code changes should have unit test coverage.
-
-Error cases should be tested with unit tests.
-
-Bug fixes should be covered by new unit tests or additional assertions in
-existing unit tests.
-
-### Details
-
-The unit test suite follows the standard Go testing convention. Tests are
-located in the package directory in `_test.go` files.
-
-Unit tests should be named using the convention:
-
-```
-Test<Function Name><Test Case Name>
-```
-
-[Table tests](https://github.com/golang/go/wiki/TableDrivenTests) should be used
-where appropriate, but may not be appropriate in all cases.
-
-Assertions should be made using
-[testify/assert](https://godoc.org/github.com/stretchr/testify/assert) and test
-requirements should be verified using
-[testify/require](https://godoc.org/github.com/stretchr/testify/require).
-
-Fakes, and testing utilities can be found in
-[internal/test](https://godoc.org/github.com/docker/cli/internal/test) and
-[gotestyourself](https://godoc.org/github.com/gotestyourself/gotestyourself).
-
-## End-to-End Test Suite
-
-The end-to-end test suite tests a cli binary against a real API backend.
-
-### Guidelines
-
-Each feature (subcommand) should have a single end-to-end test for 
-the success case. The test should include all (or most) flags/options supported
-by that feature.
-
-In some rare cases a couple additional end-to-end tests may be written for a
-sufficiently complex and critical feature (ex: `container run`, `service 
-create`, `service update`, and `docker build` may have ~3-5 cases each).
-
-In some rare cases a sufficiently critical error paths may have a single
-end-to-end test case.
-
-In all other cases the behaviour should be covered by unit tests.
-
-If a code change adds a new flag, that flag should be added to the existing 
-"success case" end-to-end test.
-
-If a code change fixes a bug, that bug fix should be covered either by adding 
-assertions to the existing end-to-end test, or with one or more unit test.
-
-### Details
-
-The end-to-end test suite is located in
-[./e2e](https://github.com/docker/cli/tree/master/e2e). Each directory in `e2e`
-corresponds to a directory in `cli/command` and contains the tests for that
-subcommand. Files in each directory should be named `<command>_test.go` where
-command is the basename of the command (ex: the test for `docker stack deploy`
-is found in `e2e/stack/deploy_test.go`).
-
-Tests should be named using the convention:
-
-```
-Test<Command Basename>[<Test Case Name>]
-```
-
-where the test case name is only required when there are multiple test cases for
-a single command.
-
-End-to-end test should run the `docker` binary using
-[gotestyourself/icmd](https://godoc.org/github.com/gotestyourself/gotestyourself/icmd)
-and make assertions about the exit code, stdout, stderr, and local file system.
-
-Any Docker image or registry operations should use `registry:5000/<image name>`
-to communicate with the local instance of the Docker registry. To load 
-additional fixture images to the registry see
-[scripts/test/e2e/run](https://github.com/docker/cli/blob/master/scripts/test/e2e/run).
--- a/components/cli/VERSION
+++ b/components/cli/VERSION
@ -1 +1 @@
-18.03.1-ce
+17.07.0-ce
--- a/components/cli/appveyor.yml
+++ b/components/cli/appveyor.yml
@ -1,23 +0,0 @@
-version: "{build}"
-
-clone_folder: c:\gopath\src\github.com\docker\cli
-
-environment:
-  GOPATH: c:\gopath
-  GOVERSION: 1.10
-  DEPVERSION: v0.4.1
-
-install:
-  - rmdir c:\go /s /q
-  - appveyor DownloadFile https://storage.googleapis.com/golang/go%GOVERSION%.windows-amd64.msi
-  - msiexec /i go%GOVERSION%.windows-amd64.msi /q
-  - go version
-  - go env
-
-deploy: false
-
-build_script:
-  - ps: .\scripts\make.ps1 -Binary
-
-test_script:
-  - ps: .\scripts\make.ps1 -TestUnit
--- a/components/cli/circle.yml
+++ b/components/cli/circle.yml
@ -71,8 +71,7 @@ jobs:
                test-$CIRCLE_BUILD_NUM:/go/src/github.com/docker/cli/coverage.txt \
                coverage.txt
            apk add -U bash curl
-            curl -s https://codecov.io/bash | bash || \
-                echo 'Codecov failed to upload'
+            curl -s https://codecov.io/bash | bash

  validate:
    working_directory: /work
@ -90,7 +89,7 @@ jobs:
            rm -f .dockerignore # include .git
            docker build -f $dockerfile --tag cli-builder-with-git:$CIRCLE_BUILD_NUM .
            docker run --rm cli-builder-with-git:$CIRCLE_BUILD_NUM \
-                make ci-validate
+                make -B vendor compose-jsonschema manpages yamldocs
  shellcheck:
    working_directory: /work
    docker: [{image: 'docker:17.06-git'}]
@ -104,7 +103,7 @@ jobs:
            echo "COPY . ." >> $dockerfile
            docker build -f $dockerfile --tag cli-validator:$CIRCLE_BUILD_NUM .
            docker run --rm cli-validator:$CIRCLE_BUILD_NUM \
-                make shellcheck
+                make -B shellcheck
 workflows:
  version: 2
  ci:
--- a/components/cli/cli/cobra.go
+++ b/components/cli/cli/cobra.go
@ -17,7 +17,6 @@ func SetupRootCommand(rootCmd *cobra.Command) {
 	cobra.AddTemplateFunc("operationSubCommands", operationSubCommands)
 	cobra.AddTemplateFunc("managementSubCommands", managementSubCommands)
 	cobra.AddTemplateFunc("wrappedFlagUsages", wrappedFlagUsages)
-	cobra.AddTemplateFunc("useLine", UseLine)

 	rootCmd.SetUsageTemplate(usageTemplate)
 	rootCmd.SetHelpTemplate(helpTemplate)
@ -26,7 +25,6 @@ func SetupRootCommand(rootCmd *cobra.Command) {

 	rootCmd.PersistentFlags().BoolP("help", "h", false, "Print usage")
 	rootCmd.PersistentFlags().MarkShorthandDeprecated("help", "please use --help")
-	rootCmd.PersistentFlags().Lookup("help").Hidden = true
 }

 // FlagErrorFunc prints an error message which matches the format of the
@ -99,19 +97,9 @@ func managementSubCommands(cmd *cobra.Command) []*cobra.Command {
 	return cmds
 }

-// UseLine returns the usage line for a command. This implementation is different
-// from the default Command.UseLine in that it does not add a `[flags]` to the
-// end of the line.
-func UseLine(cmd *cobra.Command) string {
-	if cmd.HasParent() {
-		return cmd.Parent().CommandPath() + " " + cmd.Use
-	}
-	return cmd.Use
-}
-
 var usageTemplate = `Usage:

-{{- if not .HasSubCommands}}	{{ useLine . }}{{end}}
+{{- if not .HasSubCommands}}	{{.UseLine}}{{end}}
 {{- if .HasSubCommands}}	{{ .CommandPath}} COMMAND{{end}}

 {{ .Short | trim }}
--- a/components/cli/cli/command/bundlefile/bundlefile_test.go
+++ b/components/cli/cli/command/bundlefile/bundlefile_test.go
@ -5,8 +5,7 @@ import (
 	"strings"
 	"testing"

-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )

 func TestLoadFileV01Success(t *testing.T) {
@ -26,9 +25,9 @@ func TestLoadFileV01Success(t *testing.T) {
 	}`)

 	bundle, err := LoadFile(reader)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal("0.1", bundle.Version))
-	assert.Check(t, is.Len(bundle.Services, 2))
+	assert.NoError(t, err)
+	assert.Equal(t, "0.1", bundle.Version)
+	assert.Len(t, bundle.Services, 2)
 }

 func TestLoadFileSyntaxError(t *testing.T) {
@ -38,7 +37,7 @@ func TestLoadFileSyntaxError(t *testing.T) {
 	}`)

 	_, err := LoadFile(reader)
-	assert.Error(t, err, "JSON syntax error at byte 37: invalid character 'u' looking for beginning of value")
+	assert.EqualError(t, err, "JSON syntax error at byte 37: invalid character 'u' looking for beginning of value")
 }

 func TestLoadFileTypeError(t *testing.T) {
@ -53,7 +52,7 @@ func TestLoadFileTypeError(t *testing.T) {
 	}`)

 	_, err := LoadFile(reader)
-	assert.Error(t, err, "Unexpected type at byte 94. Expected []string but received string.")
+	assert.EqualError(t, err, "Unexpected type at byte 94. Expected []string but received string.")
 }

 func TestPrint(t *testing.T) {
@ -67,12 +66,12 @@ func TestPrint(t *testing.T) {
 			},
 		},
 	}
-	assert.Check(t, Print(&buffer, bundle))
+	assert.NoError(t, Print(&buffer, bundle))
 	output := buffer.String()
-	assert.Check(t, is.Contains(output, "\"Image\": \"image\""))
-	assert.Check(t, is.Contains(output,
+	assert.Contains(t, output, "\"Image\": \"image\"")
+	assert.Contains(t, output,
 		`"Command": [
                "echo",
                "something"
-            ]`))
+            ]`)
 }
--- a/components/cli/cli/command/checkpoint/cmd.go
+++ b/components/cli/cli/command/checkpoint/cmd.go
@ -9,11 +9,11 @@ import (
 // NewCheckpointCommand returns the `checkpoint` subcommand (only in experimental)
 func NewCheckpointCommand(dockerCli command.Cli) *cobra.Command {
 	cmd := &cobra.Command{
-		Use:         "checkpoint",
-		Short:       "Manage checkpoints",
-		Args:        cli.NoArgs,
-		RunE:        command.ShowHelp(dockerCli.Err()),
-		Annotations: map[string]string{"experimental": "", "version": "1.25"},
+		Use:   "checkpoint",
+		Short: "Manage checkpoints",
+		Args:  cli.NoArgs,
+		RunE:  command.ShowHelp(dockerCli.Err()),
+		Tags:  map[string]string{"experimental": "", "version": "1.25"},
 	}
 	cmd.AddCommand(
 		newCreateCommand(dockerCli),
--- a/components/cli/cli/command/checkpoint/create_test.go
+++ b/components/cli/cli/command/checkpoint/create_test.go
@ -5,11 +5,11 @@ import (
 	"strings"
 	"testing"

-	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/cli/internal/test"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )

 func TestCheckpointCreateErrors(t *testing.T) {
@ -20,11 +20,11 @@ func TestCheckpointCreateErrors(t *testing.T) {
 	}{
 		{
 			args:          []string{"too-few-arguments"},
-			expectedError: "requires exactly 2 arguments",
+			expectedError: "requires exactly 2 argument(s)",
 		},
 		{
 			args:          []string{"too", "many", "arguments"},
-			expectedError: "requires exactly 2 arguments",
+			expectedError: "requires exactly 2 argument(s)",
 		},
 		{
 			args: []string{"foo", "bar"},
@ -42,7 +42,7 @@ func TestCheckpointCreateErrors(t *testing.T) {
 		cmd := newCreateCommand(cli)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }

@ -63,10 +63,10 @@ func TestCheckpointCreateWithOptions(t *testing.T) {
 	cmd.SetArgs([]string{"container-foo", checkpoint})
 	cmd.Flags().Set("leave-running", "true")
 	cmd.Flags().Set("checkpoint-dir", "/dir/foo")
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.Equal("container-foo", containerID))
-	assert.Check(t, is.Equal(checkpoint, checkpointID))
-	assert.Check(t, is.Equal("/dir/foo", checkpointDir))
-	assert.Check(t, is.Equal(false, exit))
-	assert.Check(t, is.Equal(checkpoint, strings.TrimSpace(cli.OutBuffer().String())))
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "container-foo", containerID)
+	assert.Equal(t, checkpoint, checkpointID)
+	assert.Equal(t, "/dir/foo", checkpointDir)
+	assert.Equal(t, false, exit)
+	assert.Equal(t, checkpoint, strings.TrimSpace(cli.OutBuffer().String()))
 }
--- a/components/cli/cli/command/checkpoint/list_test.go
+++ b/components/cli/cli/command/checkpoint/list_test.go
@ -1,15 +1,16 @@
 package checkpoint

 import (
+	"bytes"
 	"io/ioutil"
 	"testing"

-	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/cli/internal/test"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/docker/docker/pkg/testutil/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )

 func TestCheckpointListErrors(t *testing.T) {
@ -36,19 +37,20 @@ func TestCheckpointListErrors(t *testing.T) {
 	}

 	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{
+		cli := test.NewFakeCliWithOutput(&fakeClient{
 			checkpointListFunc: tc.checkpointListFunc,
-		})
+		}, &bytes.Buffer{})
 		cmd := newListCommand(cli)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }

 func TestCheckpointListWithOptions(t *testing.T) {
 	var containerID, checkpointDir string
-	cli := test.NewFakeCli(&fakeClient{
+	buf := new(bytes.Buffer)
+	cli := test.NewFakeCliWithOutput(&fakeClient{
 		checkpointListFunc: func(container string, options types.CheckpointListOptions) ([]types.Checkpoint, error) {
 			containerID = container
 			checkpointDir = options.CheckpointDir
@ -56,12 +58,14 @@ func TestCheckpointListWithOptions(t *testing.T) {
 				{Name: "checkpoint-foo"},
 			}, nil
 		},
-	})
+	}, buf)
 	cmd := newListCommand(cli)
 	cmd.SetArgs([]string{"container-foo"})
 	cmd.Flags().Set("checkpoint-dir", "/dir/foo")
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.Equal("container-foo", containerID))
-	assert.Check(t, is.Equal("/dir/foo", checkpointDir))
-	golden.Assert(t, cli.OutBuffer().String(), "checkpoint-list-with-options.golden")
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "container-foo", containerID)
+	assert.Equal(t, "/dir/foo", checkpointDir)
+	actual := buf.String()
+	expected := golden.Get(t, []byte(actual), "checkpoint-list-with-options.golden")
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }
--- a/components/cli/cli/command/checkpoint/remove_test.go
+++ b/components/cli/cli/command/checkpoint/remove_test.go
@ -1,14 +1,15 @@
 package checkpoint

 import (
+	"bytes"
 	"io/ioutil"
 	"testing"

-	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/cli/internal/test"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )

 func TestCheckpointRemoveErrors(t *testing.T) {
@ -19,11 +20,11 @@ func TestCheckpointRemoveErrors(t *testing.T) {
 	}{
 		{
 			args:          []string{"too-few-arguments"},
-			expectedError: "requires exactly 2 arguments",
+			expectedError: "requires exactly 2 argument(s)",
 		},
 		{
 			args:          []string{"too", "many", "arguments"},
-			expectedError: "requires exactly 2 arguments",
+			expectedError: "requires exactly 2 argument(s)",
 		},
 		{
 			args: []string{"foo", "bar"},
@ -35,31 +36,31 @@ func TestCheckpointRemoveErrors(t *testing.T) {
 	}

 	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{
+		cli := test.NewFakeCliWithOutput(&fakeClient{
 			checkpointDeleteFunc: tc.checkpointDeleteFunc,
-		})
+		}, &bytes.Buffer{})
 		cmd := newRemoveCommand(cli)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }

 func TestCheckpointRemoveWithOptions(t *testing.T) {
 	var containerID, checkpointID, checkpointDir string
-	cli := test.NewFakeCli(&fakeClient{
+	cli := test.NewFakeCliWithOutput(&fakeClient{
 		checkpointDeleteFunc: func(container string, options types.CheckpointDeleteOptions) error {
 			containerID = container
 			checkpointID = options.CheckpointID
 			checkpointDir = options.CheckpointDir
 			return nil
 		},
-	})
+	}, &bytes.Buffer{})
 	cmd := newRemoveCommand(cli)
 	cmd.SetArgs([]string{"container-foo", "checkpoint-bar"})
 	cmd.Flags().Set("checkpoint-dir", "/dir/foo")
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.Equal("container-foo", containerID))
-	assert.Check(t, is.Equal("checkpoint-bar", checkpointID))
-	assert.Check(t, is.Equal("/dir/foo", checkpointDir))
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "container-foo", containerID)
+	assert.Equal(t, "checkpoint-bar", checkpointID)
+	assert.Equal(t, "/dir/foo", checkpointDir)
 }
--- a/components/cli/cli/command/cli.go
+++ b/components/cli/cli/command/cli.go
@ -5,29 +5,21 @@ import (
 	"net"
 	"net/http"
 	"os"
-	"path/filepath"
 	"runtime"
 	"time"

 	"github.com/docker/cli/cli"
-	"github.com/docker/cli/cli/config"
 	cliconfig "github.com/docker/cli/cli/config"
 	"github.com/docker/cli/cli/config/configfile"
 	cliflags "github.com/docker/cli/cli/flags"
-	manifeststore "github.com/docker/cli/cli/manifest/store"
-	registryclient "github.com/docker/cli/cli/registry/client"
-	"github.com/docker/cli/cli/trust"
 	dopts "github.com/docker/cli/opts"
 	"github.com/docker/docker/api"
-	"github.com/docker/docker/api/types"
-	registrytypes "github.com/docker/docker/api/types/registry"
 	"github.com/docker/docker/client"
+	"github.com/docker/go-connections/sockets"
 	"github.com/docker/go-connections/tlsconfig"
+	"github.com/docker/notary/passphrase"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/theupdateframework/notary"
-	notaryclient "github.com/theupdateframework/notary/client"
-	"github.com/theupdateframework/notary/passphrase"
 	"golang.org/x/net/context"
 )

@ -47,30 +39,23 @@ type Cli interface {
 	SetIn(in *InStream)
 	ConfigFile() *configfile.ConfigFile
 	ServerInfo() ServerInfo
-	ClientInfo() ClientInfo
-	NotaryClient(imgRefAndAuth trust.ImageRefAndAuth, actions []string) (notaryclient.Repository, error)
-	DefaultVersion() string
-	ManifestStore() manifeststore.Store
-	RegistryClient(bool) registryclient.RegistryClient
-	ContentTrustEnabled() bool
 }

 // DockerCli is an instance the docker command line client.
 // Instances of the client can be returned from NewDockerCli.
 type DockerCli struct {
-	configFile   *configfile.ConfigFile
-	in           *InStream
-	out          *OutStream
-	err          io.Writer
-	client       client.APIClient
-	serverInfo   ServerInfo
-	clientInfo   ClientInfo
-	contentTrust bool
+	configFile     *configfile.ConfigFile
+	in             *InStream
+	out            *OutStream
+	err            io.Writer
+	client         client.APIClient
+	defaultVersion string
+	server         ServerInfo
 }

 // DefaultVersion returns api.defaultVersion or DOCKER_API_VERSION if specified.
 func (cli *DockerCli) DefaultVersion() string {
-	return cli.clientInfo.DefaultVersion
+	return cli.defaultVersion
 }

 // Client returns the APIClient
@ -115,33 +100,7 @@ func (cli *DockerCli) ConfigFile() *configfile.ConfigFile {
 // ServerInfo returns the server version details for the host this client is
 // connected to
 func (cli *DockerCli) ServerInfo() ServerInfo {
-	return cli.serverInfo
-}
-
-// ClientInfo returns the client details for the cli
-func (cli *DockerCli) ClientInfo() ClientInfo {
-	return cli.clientInfo
-}
-
-// ContentTrustEnabled returns whether content trust has been enabled by an
-// environment variable.
-func (cli *DockerCli) ContentTrustEnabled() bool {
-	return cli.contentTrust
-}
-
-// ManifestStore returns a store for local manifests
-func (cli *DockerCli) ManifestStore() manifeststore.Store {
-	// TODO: support override default location from config file
-	return manifeststore.NewStore(filepath.Join(config.Dir(), "manifests"))
-}
-
-// RegistryClient returns a client for communicating with a Docker distribution
-// registry
-func (cli *DockerCli) RegistryClient(allowInsecure bool) registryclient.RegistryClient {
-	resolver := func(ctx context.Context, index *registrytypes.IndexInfo) types.AuthConfig {
-		return ResolveAuthConfig(ctx, cli, index)
-	}
-	return registryclient.NewRegistryClient(resolver, UserAgent(), allowInsecure)
+	return cli.server
 }

 // Initialize the dockerCli runs initialization that must happen after command
@ -152,77 +111,44 @@ func (cli *DockerCli) Initialize(opts *cliflags.ClientOptions) error {
 	var err error
 	cli.client, err = NewAPIClientFromFlags(opts.Common, cli.configFile)
 	if tlsconfig.IsErrEncryptedKey(err) {
+		var (
+			passwd string
+			giveup bool
+		)
 		passRetriever := passphrase.PromptRetrieverWithInOut(cli.In(), cli.Out(), nil)
-		newClient := func(password string) (client.APIClient, error) {
-			opts.Common.TLSOptions.Passphrase = password
-			return NewAPIClientFromFlags(opts.Common, cli.configFile)
+
+		for attempts := 0; tlsconfig.IsErrEncryptedKey(err); attempts++ {
+			// some code and comments borrowed from notary/trustmanager/keystore.go
+			passwd, giveup, err = passRetriever("private", "encrypted TLS private", false, attempts)
+			// Check if the passphrase retriever got an error or if it is telling us to give up
+			if giveup || err != nil {
+				return errors.Wrap(err, "private key is encrypted, but could not get passphrase")
+			}
+
+			opts.Common.TLSOptions.Passphrase = passwd
+			cli.client, err = NewAPIClientFromFlags(opts.Common, cli.configFile)
 		}
-		cli.client, err = getClientWithPassword(passRetriever, newClient)
 	}
+
 	if err != nil {
 		return err
 	}
-	hasExperimental, err := isEnabled(cli.configFile.Experimental)
-	if err != nil {
-		return errors.Wrap(err, "Experimental field")
-	}
-	orchestrator := GetOrchestrator(hasExperimental, opts.Common.Orchestrator, cli.configFile.Orchestrator)
-	cli.clientInfo = ClientInfo{
-		DefaultVersion:  cli.client.ClientVersion(),
-		HasExperimental: hasExperimental,
-		Orchestrator:    orchestrator,
-	}
-	cli.initializeFromClient()
-	return nil
-}

-func isEnabled(value string) (bool, error) {
-	switch value {
-	case "enabled":
-		return true, nil
-	case "", "disabled":
-		return false, nil
-	default:
-		return false, errors.Errorf("%q is not valid, should be either enabled or disabled", value)
-	}
-}
+	cli.defaultVersion = cli.client.ClientVersion()

-func (cli *DockerCli) initializeFromClient() {
-	ping, err := cli.client.Ping(context.Background())
-	if err != nil {
+	if ping, err := cli.client.Ping(context.Background()); err == nil {
+		cli.server = ServerInfo{
+			HasExperimental: ping.Experimental,
+			OSType:          ping.OSType,
+		}
+
+		cli.client.NegotiateAPIVersionPing(ping)
+	} else {
 		// Default to true if we fail to connect to daemon
-		cli.serverInfo = ServerInfo{HasExperimental: true}
-
-		if ping.APIVersion != "" {
-			cli.client.NegotiateAPIVersionPing(ping)
-		}
-		return
+		cli.server = ServerInfo{HasExperimental: true}
 	}

-	cli.serverInfo = ServerInfo{
-		HasExperimental: ping.Experimental,
-		OSType:          ping.OSType,
-	}
-	cli.client.NegotiateAPIVersionPing(ping)
-}
-
-func getClientWithPassword(passRetriever notary.PassRetriever, newClient func(password string) (client.APIClient, error)) (client.APIClient, error) {
-	for attempts := 0; ; attempts++ {
-		passwd, giveup, err := passRetriever("private", "encrypted TLS private", false, attempts)
-		if giveup || err != nil {
-			return nil, errors.Wrap(err, "private key is encrypted, but could not get passphrase")
-		}
-
-		apiclient, err := newClient(passwd)
-		if !tlsconfig.IsErrEncryptedKey(err) {
-			return apiclient, err
-		}
-	}
-}
-
-// NotaryClient provides a Notary Repository to interact with signed metadata for an image
-func (cli *DockerCli) NotaryClient(imgRefAndAuth trust.ImageRefAndAuth, actions []string) (notaryclient.Repository, error) {
-	return trust.GetNotaryRepository(cli.In(), cli.Out(), UserAgent(), imgRefAndAuth.RepoInfo(), imgRefAndAuth.AuthConfig(), actions...)
+	return nil
 }

 // ServerInfo stores details about the supported features and platform of the
@ -232,21 +158,9 @@ type ServerInfo struct {
 	OSType          string
 }

-// ClientInfo stores details about the supported features of the client
-type ClientInfo struct {
-	HasExperimental bool
-	DefaultVersion  string
-	Orchestrator    Orchestrator
-}
-
-// HasKubernetes checks if kubernetes orchestrator is enabled
-func (c ClientInfo) HasKubernetes() bool {
-	return c.HasExperimental && c.Orchestrator == OrchestratorKubernetes
-}
-
 // NewDockerCli returns a DockerCli instance with IO output and error streams set by in, out and err.
-func NewDockerCli(in io.ReadCloser, out, err io.Writer, isTrusted bool) *DockerCli {
-	return &DockerCli{in: NewInStream(in), out: NewOutStream(out), err: err, contentTrust: isTrusted}
+func NewDockerCli(in io.ReadCloser, out, err io.Writer) *DockerCli {
+	return &DockerCli{in: NewInStream(in), out: NewOutStream(out), err: err}
 }

 // NewAPIClientFromFlags creates a new APIClient from command line flags
@ -267,16 +181,15 @@ func NewAPIClientFromFlags(opts *cliflags.CommonOptions, configFile *configfile.
 		verStr = tmpStr
 	}

-	return client.NewClientWithOpts(
-		withHTTPClient(opts.TLSOptions),
-		client.WithHTTPHeaders(customHeaders),
-		client.WithVersion(verStr),
-		client.WithHost(host),
-	)
+	httpClient, err := newHTTPClient(host, opts.TLSOptions)
+	if err != nil {
+		return &client.Client{}, err
+	}
+
+	return client.NewClient(host, verStr, httpClient, customHeaders)
 }

-func getServerHost(hosts []string, tlsOptions *tlsconfig.Options) (string, error) {
-	var host string
+func getServerHost(hosts []string, tlsOptions *tlsconfig.Options) (host string, err error) {
 	switch len(hosts) {
 	case 0:
 		host = os.Getenv("DOCKER_HOST")
@ -286,35 +199,39 @@ func getServerHost(hosts []string, tlsOptions *tlsconfig.Options) (string, error
 		return "", errors.New("Please specify only one -H")
 	}

-	return dopts.ParseHost(tlsOptions != nil, host)
+	host, err = dopts.ParseHost(tlsOptions != nil, host)
+	return
 }

-func withHTTPClient(tlsOpts *tlsconfig.Options) func(*client.Client) error {
-	return func(c *client.Client) error {
-		if tlsOpts == nil {
-			// Use the default HTTPClient
-			return nil
-		}
-
-		opts := *tlsOpts
-		opts.ExclusiveRootPools = true
-		tlsConfig, err := tlsconfig.Client(opts)
-		if err != nil {
-			return err
-		}
-
-		httpClient := &http.Client{
-			Transport: &http.Transport{
-				TLSClientConfig: tlsConfig,
-				DialContext: (&net.Dialer{
-					KeepAlive: 30 * time.Second,
-					Timeout:   30 * time.Second,
-				}).DialContext,
-			},
-			CheckRedirect: client.CheckRedirect,
-		}
-		return client.WithHTTPClient(httpClient)(c)
+func newHTTPClient(host string, tlsOptions *tlsconfig.Options) (*http.Client, error) {
+	if tlsOptions == nil {
+		// let the api client configure the default transport.
+		return nil, nil
 	}
+	opts := *tlsOptions
+	opts.ExclusiveRootPools = true
+	config, err := tlsconfig.Client(opts)
+	if err != nil {
+		return nil, err
+	}
+	tr := &http.Transport{
+		TLSClientConfig: config,
+		DialContext: (&net.Dialer{
+			KeepAlive: 30 * time.Second,
+			Timeout:   30 * time.Second,
+		}).DialContext,
+	}
+	proto, addr, _, err := client.ParseHost(host)
+	if err != nil {
+		return nil, err
+	}
+
+	sockets.ConfigureTransport(tr, proto, addr)
+
+	return &http.Client{
+		Transport:     tr,
+		CheckRedirect: client.CheckRedirect,
+	}, nil
 }

 // UserAgent returns the user agent string used for making API requests
--- a/components/cli/cli/command/cli_test.go
+++ b/components/cli/cli/command/cli_test.go
@ -1,344 +0,0 @@
-package command
-
-import (
-	"crypto/x509"
-	"os"
-	"runtime"
-	"testing"
-
-	cliconfig "github.com/docker/cli/cli/config"
-	"github.com/docker/cli/cli/config/configfile"
-	"github.com/docker/cli/cli/flags"
-	"github.com/docker/docker/api"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/client"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/fs"
-	"github.com/pkg/errors"
-	"golang.org/x/net/context"
-)
-
-func TestNewAPIClientFromFlags(t *testing.T) {
-	host := "unix://path"
-	if runtime.GOOS == "windows" {
-		host = "npipe://./"
-	}
-	opts := &flags.CommonOptions{Hosts: []string{host}}
-	configFile := &configfile.ConfigFile{
-		HTTPHeaders: map[string]string{
-			"My-Header": "Custom-Value",
-		},
-	}
-	apiclient, err := NewAPIClientFromFlags(opts, configFile)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(host, apiclient.DaemonHost()))
-
-	expectedHeaders := map[string]string{
-		"My-Header":  "Custom-Value",
-		"User-Agent": UserAgent(),
-	}
-	assert.Check(t, is.DeepEqual(expectedHeaders, apiclient.(*client.Client).CustomHTTPHeaders()))
-	assert.Check(t, is.Equal(api.DefaultVersion, apiclient.ClientVersion()))
-}
-
-func TestNewAPIClientFromFlagsWithAPIVersionFromEnv(t *testing.T) {
-	customVersion := "v3.3.3"
-	defer patchEnvVariable(t, "DOCKER_API_VERSION", customVersion)()
-
-	opts := &flags.CommonOptions{}
-	configFile := &configfile.ConfigFile{}
-	apiclient, err := NewAPIClientFromFlags(opts, configFile)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(customVersion, apiclient.ClientVersion()))
-}
-
-// TODO: use gotestyourself/env.Patch
-func patchEnvVariable(t *testing.T, key, value string) func() {
-	oldValue, ok := os.LookupEnv(key)
-	assert.NilError(t, os.Setenv(key, value))
-	return func() {
-		if !ok {
-			assert.NilError(t, os.Unsetenv(key))
-			return
-		}
-		assert.NilError(t, os.Setenv(key, oldValue))
-	}
-}
-
-type fakeClient struct {
-	client.Client
-	pingFunc   func() (types.Ping, error)
-	version    string
-	negotiated bool
-}
-
-func (c *fakeClient) Ping(_ context.Context) (types.Ping, error) {
-	return c.pingFunc()
-}
-
-func (c *fakeClient) ClientVersion() string {
-	return c.version
-}
-
-func (c *fakeClient) NegotiateAPIVersionPing(types.Ping) {
-	c.negotiated = true
-}
-
-func TestInitializeFromClient(t *testing.T) {
-	defaultVersion := "v1.55"
-
-	var testcases = []struct {
-		doc            string
-		pingFunc       func() (types.Ping, error)
-		expectedServer ServerInfo
-		negotiated     bool
-	}{
-		{
-			doc: "successful ping",
-			pingFunc: func() (types.Ping, error) {
-				return types.Ping{Experimental: true, OSType: "linux", APIVersion: "v1.30"}, nil
-			},
-			expectedServer: ServerInfo{HasExperimental: true, OSType: "linux"},
-			negotiated:     true,
-		},
-		{
-			doc: "failed ping, no API version",
-			pingFunc: func() (types.Ping, error) {
-				return types.Ping{}, errors.New("failed")
-			},
-			expectedServer: ServerInfo{HasExperimental: true},
-		},
-		{
-			doc: "failed ping, with API version",
-			pingFunc: func() (types.Ping, error) {
-				return types.Ping{APIVersion: "v1.33"}, errors.New("failed")
-			},
-			expectedServer: ServerInfo{HasExperimental: true},
-			negotiated:     true,
-		},
-	}
-
-	for _, testcase := range testcases {
-		t.Run(testcase.doc, func(t *testing.T) {
-			apiclient := &fakeClient{
-				pingFunc: testcase.pingFunc,
-				version:  defaultVersion,
-			}
-
-			cli := &DockerCli{client: apiclient}
-			cli.initializeFromClient()
-			assert.Check(t, is.DeepEqual(testcase.expectedServer, cli.serverInfo))
-			assert.Check(t, is.Equal(testcase.negotiated, apiclient.negotiated))
-		})
-	}
-}
-
-func TestExperimentalCLI(t *testing.T) {
-	defaultVersion := "v1.55"
-
-	var testcases = []struct {
-		doc                     string
-		configfile              string
-		expectedExperimentalCLI bool
-	}{
-		{
-			doc:                     "default",
-			configfile:              `{}`,
-			expectedExperimentalCLI: false,
-		},
-		{
-			doc: "experimental",
-			configfile: `{
-	"experimental": "enabled"
-}`,
-			expectedExperimentalCLI: true,
-		},
-	}
-
-	for _, testcase := range testcases {
-		t.Run(testcase.doc, func(t *testing.T) {
-			dir := fs.NewDir(t, testcase.doc, fs.WithFile("config.json", testcase.configfile))
-			defer dir.Remove()
-			apiclient := &fakeClient{
-				version: defaultVersion,
-			}
-
-			cli := &DockerCli{client: apiclient, err: os.Stderr}
-			cliconfig.SetDir(dir.Path())
-			err := cli.Initialize(flags.NewClientOptions())
-			assert.NilError(t, err)
-			assert.Check(t, is.Equal(testcase.expectedExperimentalCLI, cli.ClientInfo().HasExperimental))
-		})
-	}
-}
-
-func TestOrchestratorSwitch(t *testing.T) {
-	defaultVersion := "v0.00"
-
-	var testcases = []struct {
-		doc                  string
-		configfile           string
-		envOrchestrator      string
-		flagOrchestrator     string
-		expectedOrchestrator string
-		expectedKubernetes   bool
-	}{
-		{
-			doc: "default",
-			configfile: `{
-				"experimental": "enabled"
-			}`,
-			expectedOrchestrator: "swarm",
-			expectedKubernetes:   false,
-		},
-		{
-			doc: "kubernetesIsExperimental",
-			configfile: `{
-				"experimental": "disabled",
-				"orchestrator": "kubernetes"
-			}`,
-			envOrchestrator:      "kubernetes",
-			flagOrchestrator:     "kubernetes",
-			expectedOrchestrator: "swarm",
-			expectedKubernetes:   false,
-		},
-		{
-			doc: "kubernetesConfigFile",
-			configfile: `{
-				"experimental": "enabled",
-				"orchestrator": "kubernetes"
-			}`,
-			expectedOrchestrator: "kubernetes",
-			expectedKubernetes:   true,
-		},
-		{
-			doc: "kubernetesEnv",
-			configfile: `{
-				"experimental": "enabled"
-			}`,
-			envOrchestrator:      "kubernetes",
-			expectedOrchestrator: "kubernetes",
-			expectedKubernetes:   true,
-		},
-		{
-			doc: "kubernetesFlag",
-			configfile: `{
-				"experimental": "enabled"
-			}`,
-			flagOrchestrator:     "kubernetes",
-			expectedOrchestrator: "kubernetes",
-			expectedKubernetes:   true,
-		},
-		{
-			doc: "envOverridesConfigFile",
-			configfile: `{
-				"experimental": "enabled",
-				"orchestrator": "kubernetes"
-			}`,
-			envOrchestrator:      "swarm",
-			expectedOrchestrator: "swarm",
-			expectedKubernetes:   false,
-		},
-		{
-			doc: "flagOverridesEnv",
-			configfile: `{
-				"experimental": "enabled"
-			}`,
-			envOrchestrator:      "kubernetes",
-			flagOrchestrator:     "swarm",
-			expectedOrchestrator: "swarm",
-			expectedKubernetes:   false,
-		},
-	}
-
-	for _, testcase := range testcases {
-		t.Run(testcase.doc, func(t *testing.T) {
-			dir := fs.NewDir(t, testcase.doc, fs.WithFile("config.json", testcase.configfile))
-			defer dir.Remove()
-			apiclient := &fakeClient{
-				version: defaultVersion,
-			}
-			if testcase.envOrchestrator != "" {
-				defer patchEnvVariable(t, "DOCKER_ORCHESTRATOR", testcase.envOrchestrator)()
-			}
-
-			cli := &DockerCli{client: apiclient, err: os.Stderr}
-			cliconfig.SetDir(dir.Path())
-			options := flags.NewClientOptions()
-			if testcase.flagOrchestrator != "" {
-				options.Common.Orchestrator = testcase.flagOrchestrator
-			}
-			err := cli.Initialize(options)
-			assert.NilError(t, err)
-			assert.Check(t, is.Equal(testcase.expectedKubernetes, cli.ClientInfo().HasKubernetes()))
-			assert.Check(t, is.Equal(testcase.expectedOrchestrator, string(cli.ClientInfo().Orchestrator)))
-		})
-	}
-}
-
-func TestGetClientWithPassword(t *testing.T) {
-	expected := "password"
-
-	var testcases = []struct {
-		doc             string
-		password        string
-		retrieverErr    error
-		retrieverGiveup bool
-		newClientErr    error
-		expectedErr     string
-	}{
-		{
-			doc:      "successful connect",
-			password: expected,
-		},
-		{
-			doc:             "password retriever exhausted",
-			retrieverGiveup: true,
-			retrieverErr:    errors.New("failed"),
-			expectedErr:     "private key is encrypted, but could not get passphrase",
-		},
-		{
-			doc:          "password retriever error",
-			retrieverErr: errors.New("failed"),
-			expectedErr:  "failed",
-		},
-		{
-			doc:          "newClient error",
-			newClientErr: errors.New("failed to connect"),
-			expectedErr:  "failed to connect",
-		},
-	}
-
-	for _, testcase := range testcases {
-		t.Run(testcase.doc, func(t *testing.T) {
-			passRetriever := func(_, _ string, _ bool, attempts int) (passphrase string, giveup bool, err error) {
-				// Always return an invalid pass first to test iteration
-				switch attempts {
-				case 0:
-					return "something else", false, nil
-				default:
-					return testcase.password, testcase.retrieverGiveup, testcase.retrieverErr
-				}
-			}
-
-			newClient := func(currentPassword string) (client.APIClient, error) {
-				if testcase.newClientErr != nil {
-					return nil, testcase.newClientErr
-				}
-				if currentPassword == expected {
-					return &client.Client{}, nil
-				}
-				return &client.Client{}, x509.IncorrectPasswordError
-			}
-
-			_, err := getClientWithPassword(passRetriever, newClient)
-			if testcase.expectedErr != "" {
-				assert.ErrorContains(t, err, testcase.expectedErr)
-				return
-			}
-
-			assert.NilError(t, err)
-		})
-	}
-}
--- a/components/cli/cli/command/commands/commands.go
+++ b/components/cli/cli/command/commands/commands.go
@ -8,7 +8,6 @@ import (
 	"github.com/docker/cli/cli/command/config"
 	"github.com/docker/cli/cli/command/container"
 	"github.com/docker/cli/cli/command/image"
-	"github.com/docker/cli/cli/command/manifest"
 	"github.com/docker/cli/cli/command/network"
 	"github.com/docker/cli/cli/command/node"
 	"github.com/docker/cli/cli/command/plugin"
@ -18,7 +17,6 @@ import (
 	"github.com/docker/cli/cli/command/stack"
 	"github.com/docker/cli/cli/command/swarm"
 	"github.com/docker/cli/cli/command/system"
-	"github.com/docker/cli/cli/command/trust"
 	"github.com/docker/cli/cli/command/volume"
 	"github.com/spf13/cobra"
 )
@ -40,15 +38,12 @@ func AddCommands(cmd *cobra.Command, dockerCli *command.DockerCli) {
 		image.NewImageCommand(dockerCli),
 		image.NewBuildCommand(dockerCli),

-		// manifest
-		manifest.NewManifestCommand(dockerCli),
+		// node
+		node.NewNodeCommand(dockerCli),

 		// network
 		network.NewNetworkCommand(dockerCli),

-		// node
-		node.NewNodeCommand(dockerCli),
-
 		// plugin
 		plugin.NewPluginCommand(dockerCli),

@ -74,9 +69,6 @@ func AddCommands(cmd *cobra.Command, dockerCli *command.DockerCli) {
 		// swarm
 		swarm.NewSwarmCommand(dockerCli),

-		// trust
-		trust.NewTrustCommand(dockerCli),
-
 		// volume
 		volume.NewVolumeCommand(dockerCli),

--- a/components/cli/cli/command/config/cmd.go
+++ b/components/cli/cli/command/config/cmd.go
@ -8,16 +8,14 @@ import (
 )

 // NewConfigCommand returns a cobra command for `config` subcommands
-func NewConfigCommand(dockerCli command.Cli) *cobra.Command {
+// nolint: interfacer
+func NewConfigCommand(dockerCli *command.DockerCli) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "config",
 		Short: "Manage Docker configs",
 		Args:  cli.NoArgs,
 		RunE:  command.ShowHelp(dockerCli.Err()),
-		Annotations: map[string]string{
-			"version": "1.30",
-			"swarm":   "",
-		},
+		Tags:  map[string]string{"version": "1.30"},
 	}
 	cmd.AddCommand(
 		newConfigListCommand(dockerCli),
--- a/components/cli/cli/command/config/create.go
+++ b/components/cli/cli/command/config/create.go
@ -16,10 +16,9 @@ import (
 )

 type createOptions struct {
-	name           string
-	templateDriver string
-	file           string
-	labels         opts.ListOpts
+	name   string
+	file   string
+	labels opts.ListOpts
 }

 func newConfigCreateCommand(dockerCli command.Cli) *cobra.Command {
@ -29,7 +28,7 @@ func newConfigCreateCommand(dockerCli command.Cli) *cobra.Command {

 	cmd := &cobra.Command{
 		Use:   "create [OPTIONS] CONFIG file|-",
-		Short: "Create a config from a file or STDIN",
+		Short: "Create a configuration file from a file or STDIN as content",
 		Args:  cli.ExactArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			createOpts.name = args[0]
@ -39,8 +38,6 @@ func newConfigCreateCommand(dockerCli command.Cli) *cobra.Command {
 	}
 	flags := cmd.Flags()
 	flags.VarP(&createOpts.labels, "label", "l", "Config labels")
-	flags.StringVar(&createOpts.templateDriver, "template-driver", "", "Template driver")
-	flags.SetAnnotation("driver", "version", []string{"1.37"})

 	return cmd
 }
@ -71,11 +68,7 @@ func runConfigCreate(dockerCli command.Cli, options createOptions) error {
 		},
 		Data: configData,
 	}
-	if options.templateDriver != "" {
-		spec.Templating = &swarm.Driver{
-			Name: options.templateDriver,
-		}
-	}
+
 	r, err := client.ConfigCreate(ctx, spec)
 	if err != nil {
 		return err
--- a/components/cli/cli/command/config/create_test.go
+++ b/components/cli/cli/command/config/create_test.go
@ -7,13 +7,13 @@ import (
 	"strings"
 	"testing"

-	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/cli/internal/test"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/docker/docker/pkg/testutil/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )

 const configDataFile = "config-create-with-name.golden"
@ -26,10 +26,10 @@ func TestConfigCreateErrors(t *testing.T) {
 	}{
 		{
 			args:          []string{"too_few"},
-			expectedError: "requires exactly 2 arguments",
+			expectedError: "requires exactly 2 argument(s)",
 		},
 		{args: []string{"too", "many", "arguments"},
-			expectedError: "requires exactly 2 arguments",
+			expectedError: "requires exactly 2 argument(s)",
 		},
 		{
 			args: []string{"name", filepath.Join("testdata", configDataFile)},
@ -47,7 +47,7 @@ func TestConfigCreateErrors(t *testing.T) {
 		)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }

@ -70,9 +70,10 @@ func TestConfigCreateWithName(t *testing.T) {

 	cmd := newConfigCreateCommand(cli)
 	cmd.SetArgs([]string{name, filepath.Join("testdata", configDataFile)})
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, string(actual), configDataFile)
-	assert.Check(t, is.Equal("ID-"+name, strings.TrimSpace(cli.OutBuffer().String())))
+	assert.NoError(t, cmd.Execute())
+	expected := golden.Get(t, actual, configDataFile)
+	assert.Equal(t, string(expected), string(actual))
+	assert.Equal(t, "ID-"+name, strings.TrimSpace(cli.OutBuffer().String()))
 }

 func TestConfigCreateWithLabels(t *testing.T) {
@ -82,21 +83,14 @@ func TestConfigCreateWithLabels(t *testing.T) {
 	}
 	name := "foo"

-	data, err := ioutil.ReadFile(filepath.Join("testdata", configDataFile))
-	assert.NilError(t, err)
-
-	expected := swarm.ConfigSpec{
-		Annotations: swarm.Annotations{
-			Name:   name,
-			Labels: expectedLabels,
-		},
-		Data: data,
-	}
-
 	cli := test.NewFakeCli(&fakeClient{
 		configCreateFunc: func(spec swarm.ConfigSpec) (types.ConfigCreateResponse, error) {
-			if !reflect.DeepEqual(spec, expected) {
-				return types.ConfigCreateResponse{}, errors.Errorf("expected %+v, got %+v", expected, spec)
+			if spec.Name != name {
+				return types.ConfigCreateResponse{}, errors.Errorf("expected name %q, got %q", name, spec.Name)
+			}
+
+			if !reflect.DeepEqual(spec.Labels, expectedLabels) {
+				return types.ConfigCreateResponse{}, errors.Errorf("expected labels %v, got %v", expectedLabels, spec.Labels)
 			}

 			return types.ConfigCreateResponse{
@ -109,35 +103,6 @@ func TestConfigCreateWithLabels(t *testing.T) {
 	cmd.SetArgs([]string{name, filepath.Join("testdata", configDataFile)})
 	cmd.Flags().Set("label", "lbl1=Label-foo")
 	cmd.Flags().Set("label", "lbl2=Label-bar")
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.Equal("ID-"+name, strings.TrimSpace(cli.OutBuffer().String())))
-}
-
-func TestConfigCreateWithTemplatingDriver(t *testing.T) {
-	expectedDriver := &swarm.Driver{
-		Name: "template-driver",
-	}
-	name := "foo"
-
-	cli := test.NewFakeCli(&fakeClient{
-		configCreateFunc: func(spec swarm.ConfigSpec) (types.ConfigCreateResponse, error) {
-			if spec.Name != name {
-				return types.ConfigCreateResponse{}, errors.Errorf("expected name %q, got %q", name, spec.Name)
-			}
-
-			if spec.Templating.Name != expectedDriver.Name {
-				return types.ConfigCreateResponse{}, errors.Errorf("expected driver %v, got %v", expectedDriver, spec.Labels)
-			}
-
-			return types.ConfigCreateResponse{
-				ID: "ID-" + spec.Name,
-			}, nil
-		},
-	})
-
-	cmd := newConfigCreateCommand(cli)
-	cmd.SetArgs([]string{name, filepath.Join("testdata", configDataFile)})
-	cmd.Flags().Set("template-driver", expectedDriver.Name)
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.Equal("ID-"+name, strings.TrimSpace(cli.OutBuffer().String())))
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "ID-"+name, strings.TrimSpace(cli.OutBuffer().String()))
 }
--- a/components/cli/cli/command/config/inspect.go
+++ b/components/cli/cli/command/config/inspect.go
@ -21,7 +21,7 @@ func newConfigInspectCommand(dockerCli command.Cli) *cobra.Command {
 	opts := inspectOptions{}
 	cmd := &cobra.Command{
 		Use:   "inspect [OPTIONS] CONFIG [CONFIG...]",
-		Short: "Display detailed information on one or more configs",
+		Short: "Display detailed information on one or more configuration files",
 		Args:  cli.RequiresMinArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			opts.names = args
--- a/components/cli/cli/command/config/inspect_test.go
+++ b/components/cli/cli/command/config/inspect_test.go
@ -1,18 +1,20 @@
 package config

 import (
+	"bytes"
 	"fmt"
 	"io/ioutil"
 	"testing"
 	"time"

-	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/cli/internal/test"
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
-	. "github.com/docker/cli/internal/test/builders"
-	"github.com/gotestyourself/gotestyourself/assert"
-	"github.com/gotestyourself/gotestyourself/golden"
+	. "github.com/docker/cli/cli/internal/test/builders"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )

 func TestConfigInspectErrors(t *testing.T) {
@ -51,17 +53,18 @@ func TestConfigInspectErrors(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
+		buf := new(bytes.Buffer)
 		cmd := newConfigInspectCommand(
-			test.NewFakeCli(&fakeClient{
+			test.NewFakeCliWithOutput(&fakeClient{
 				configInspectFunc: tc.configInspectFunc,
-			}),
+			}, buf),
 		)
 		cmd.SetArgs(tc.args)
 		for key, value := range tc.flags {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }

@ -92,11 +95,17 @@ func TestConfigInspectWithoutFormat(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{configInspectFunc: tc.configInspectFunc})
-		cmd := newConfigInspectCommand(cli)
+		buf := new(bytes.Buffer)
+		cmd := newConfigInspectCommand(
+			test.NewFakeCliWithOutput(&fakeClient{
+				configInspectFunc: tc.configInspectFunc,
+			}, buf),
+		)
 		cmd.SetArgs(tc.args)
-		assert.NilError(t, cmd.Execute())
-		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("config-inspect-without-format.%s.golden", tc.name))
+		assert.NoError(t, cmd.Execute())
+		actual := buf.String()
+		expected := golden.Get(t, []byte(actual), fmt.Sprintf("config-inspect-without-format.%s.golden", tc.name))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }

@ -126,14 +135,18 @@ func TestConfigInspectWithFormat(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{
-			configInspectFunc: tc.configInspectFunc,
-		})
-		cmd := newConfigInspectCommand(cli)
+		buf := new(bytes.Buffer)
+		cmd := newConfigInspectCommand(
+			test.NewFakeCliWithOutput(&fakeClient{
+				configInspectFunc: tc.configInspectFunc,
+			}, buf),
+		)
 		cmd.SetArgs(tc.args)
 		cmd.Flags().Set("format", tc.format)
-		assert.NilError(t, cmd.Execute())
-		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("config-inspect-with-format.%s.golden", tc.name))
+		assert.NoError(t, cmd.Execute())
+		actual := buf.String()
+		expected := golden.Get(t, []byte(actual), fmt.Sprintf("config-inspect-with-format.%s.golden", tc.name))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }

@ -159,14 +172,16 @@ func TestConfigInspectPretty(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{
-			configInspectFunc: tc.configInspectFunc,
-		})
-		cmd := newConfigInspectCommand(cli)
-
+		buf := new(bytes.Buffer)
+		cmd := newConfigInspectCommand(
+			test.NewFakeCliWithOutput(&fakeClient{
+				configInspectFunc: tc.configInspectFunc,
+			}, buf))
 		cmd.SetArgs([]string{"configID"})
 		cmd.Flags().Set("pretty", "true")
-		assert.NilError(t, cmd.Execute())
-		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("config-inspect-pretty.%s.golden", tc.name))
+		assert.NoError(t, cmd.Execute())
+		actual := buf.String()
+		expected := golden.Get(t, []byte(actual), fmt.Sprintf("config-inspect-pretty.%s.golden", tc.name))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
--- a/components/cli/cli/command/config/ls.go
+++ b/components/cli/cli/command/config/ls.go
@ -1,27 +1,15 @@
 package config

 import (
-	"sort"
-
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/cli/command/formatter"
 	"github.com/docker/cli/opts"
 	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/swarm"
 	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
-	"vbom.ml/util/sortorder"
 )

-type byConfigName []swarm.Config
-
-func (r byConfigName) Len() int      { return len(r) }
-func (r byConfigName) Swap(i, j int) { r[i], r[j] = r[j], r[i] }
-func (r byConfigName) Less(i, j int) bool {
-	return sortorder.NaturalLess(r[i].Spec.Name, r[j].Spec.Name)
-}
-
 type listOptions struct {
 	quiet  bool
 	format string
@ -67,8 +55,6 @@ func runConfigList(dockerCli command.Cli, options listOptions) error {
 		}
 	}

-	sort.Sort(byConfigName(configs))
-
 	configCtx := formatter.Context{
 		Output: dockerCli.Out(),
 		Format: formatter.NewConfigFormat(format, options.quiet),
--- a/components/cli/cli/command/config/ls_test.go
+++ b/components/cli/cli/command/config/ls_test.go
@ -6,15 +6,15 @@ import (
 	"time"

 	"github.com/docker/cli/cli/config/configfile"
-	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/cli/internal/test"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
-	. "github.com/docker/cli/internal/test/builders"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/golden"
+	. "github.com/docker/cli/cli/internal/test/builders"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )

 func TestConfigListErrors(t *testing.T) {
@ -42,7 +42,7 @@ func TestConfigListErrors(t *testing.T) {
 		)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }

@ -50,20 +50,14 @@ func TestConfigList(t *testing.T) {
 	cli := test.NewFakeCli(&fakeClient{
 		configListFunc: func(options types.ConfigListOptions) ([]swarm.Config, error) {
 			return []swarm.Config{
-				*Config(ConfigID("ID-1-foo"),
-					ConfigName("1-foo"),
+				*Config(ConfigID("ID-foo"),
+					ConfigName("foo"),
 					ConfigVersion(swarm.Version{Index: 10}),
 					ConfigCreatedAt(time.Now().Add(-2*time.Hour)),
 					ConfigUpdatedAt(time.Now().Add(-1*time.Hour)),
 				),
-				*Config(ConfigID("ID-10-foo"),
-					ConfigName("10-foo"),
-					ConfigVersion(swarm.Version{Index: 11}),
-					ConfigCreatedAt(time.Now().Add(-2*time.Hour)),
-					ConfigUpdatedAt(time.Now().Add(-1*time.Hour)),
-				),
-				*Config(ConfigID("ID-2-foo"),
-					ConfigName("2-foo"),
+				*Config(ConfigID("ID-bar"),
+					ConfigName("bar"),
 					ConfigVersion(swarm.Version{Index: 11}),
 					ConfigCreatedAt(time.Now().Add(-2*time.Hour)),
 					ConfigUpdatedAt(time.Now().Add(-1*time.Hour)),
@ -72,8 +66,11 @@ func TestConfigList(t *testing.T) {
 		},
 	})
 	cmd := newConfigListCommand(cli)
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "config-list-sort.golden")
+	cmd.SetOutput(cli.OutBuffer())
+	assert.NoError(t, cmd.Execute())
+	actual := cli.OutBuffer().String()
+	expected := golden.Get(t, []byte(actual), "config-list.golden")
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }

 func TestConfigListWithQuietOption(t *testing.T) {
@ -89,8 +86,10 @@ func TestConfigListWithQuietOption(t *testing.T) {
 	})
 	cmd := newConfigListCommand(cli)
 	cmd.Flags().Set("quiet", "true")
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "config-list-with-quiet-option.golden")
+	assert.NoError(t, cmd.Execute())
+	actual := cli.OutBuffer().String()
+	expected := golden.Get(t, []byte(actual), "config-list-with-quiet-option.golden")
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }

 func TestConfigListWithConfigFormat(t *testing.T) {
@ -108,8 +107,10 @@ func TestConfigListWithConfigFormat(t *testing.T) {
 		ConfigFormat: "{{ .Name }} {{ .Labels }}",
 	})
 	cmd := newConfigListCommand(cli)
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "config-list-with-config-format.golden")
+	assert.NoError(t, cmd.Execute())
+	actual := cli.OutBuffer().String()
+	expected := golden.Get(t, []byte(actual), "config-list-with-config-format.golden")
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }

 func TestConfigListWithFormat(t *testing.T) {
@ -125,15 +126,17 @@ func TestConfigListWithFormat(t *testing.T) {
 	})
 	cmd := newConfigListCommand(cli)
 	cmd.Flags().Set("format", "{{ .Name }} {{ .Labels }}")
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "config-list-with-format.golden")
+	assert.NoError(t, cmd.Execute())
+	actual := cli.OutBuffer().String()
+	expected := golden.Get(t, []byte(actual), "config-list-with-format.golden")
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }

 func TestConfigListWithFilter(t *testing.T) {
 	cli := test.NewFakeCli(&fakeClient{
 		configListFunc: func(options types.ConfigListOptions) ([]swarm.Config, error) {
-			assert.Check(t, is.Equal("foo", options.Filters.Get("name")[0]))
-			assert.Check(t, is.Equal("lbl1=Label-bar", options.Filters.Get("label")[0]))
+			assert.Equal(t, "foo", options.Filters.Get("name")[0])
+			assert.Equal(t, "lbl1=Label-bar", options.Filters.Get("label")[0])
 			return []swarm.Config{
 				*Config(ConfigID("ID-foo"),
 					ConfigName("foo"),
@ -153,6 +156,8 @@ func TestConfigListWithFilter(t *testing.T) {
 	cmd := newConfigListCommand(cli)
 	cmd.Flags().Set("filter", "name=foo")
 	cmd.Flags().Set("filter", "label=lbl1=Label-bar")
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "config-list-with-filter.golden")
+	assert.NoError(t, cmd.Execute())
+	actual := cli.OutBuffer().String()
+	expected := golden.Get(t, []byte(actual), "config-list-with-filter.golden")
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }
--- a/components/cli/cli/command/config/remove.go
+++ b/components/cli/cli/command/config/remove.go
@ -19,7 +19,7 @@ func newConfigRemoveCommand(dockerCli command.Cli) *cobra.Command {
 	return &cobra.Command{
 		Use:     "rm CONFIG [CONFIG...]",
 		Aliases: []string{"remove"},
-		Short:   "Remove one or more configs",
+		Short:   "Remove one or more configuration files",
 		Args:    cli.RequiresMinArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			opts := removeOptions{
--- a/components/cli/cli/command/config/remove_test.go
+++ b/components/cli/cli/command/config/remove_test.go
@ -1,14 +1,15 @@
 package config

 import (
+	"bytes"
 	"io/ioutil"
 	"strings"
 	"testing"

-	"github.com/docker/cli/internal/test"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/docker/cli/cli/internal/test"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )

 func TestConfigRemoveErrors(t *testing.T) {
@ -19,7 +20,7 @@ func TestConfigRemoveErrors(t *testing.T) {
 	}{
 		{
 			args:          []string{},
-			expectedError: "requires at least 1 argument.",
+			expectedError: "requires at least 1 argument(s).",
 		},
 		{
 			args: []string{"foo"},
@ -30,38 +31,41 @@ func TestConfigRemoveErrors(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
+		buf := new(bytes.Buffer)
 		cmd := newConfigRemoveCommand(
-			test.NewFakeCli(&fakeClient{
+			test.NewFakeCliWithOutput(&fakeClient{
 				configRemoveFunc: tc.configRemoveFunc,
-			}),
+			}, buf),
 		)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }

 func TestConfigRemoveWithName(t *testing.T) {
 	names := []string{"foo", "bar"}
+	buf := new(bytes.Buffer)
 	var removedConfigs []string
-	cli := test.NewFakeCli(&fakeClient{
+	cli := test.NewFakeCliWithOutput(&fakeClient{
 		configRemoveFunc: func(name string) error {
 			removedConfigs = append(removedConfigs, name)
 			return nil
 		},
-	})
+	}, buf)
 	cmd := newConfigRemoveCommand(cli)
 	cmd.SetArgs(names)
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.DeepEqual(names, strings.Split(strings.TrimSpace(cli.OutBuffer().String()), "\n")))
-	assert.Check(t, is.DeepEqual(names, removedConfigs))
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, names, strings.Split(strings.TrimSpace(buf.String()), "\n"))
+	assert.Equal(t, names, removedConfigs)
 }

 func TestConfigRemoveContinueAfterError(t *testing.T) {
 	names := []string{"foo", "bar"}
+	buf := new(bytes.Buffer)
 	var removedConfigs []string

-	cli := test.NewFakeCli(&fakeClient{
+	cli := test.NewFakeCliWithOutput(&fakeClient{
 		configRemoveFunc: func(name string) error {
 			removedConfigs = append(removedConfigs, name)
 			if name == "foo" {
@ -69,11 +73,11 @@ func TestConfigRemoveContinueAfterError(t *testing.T) {
 			}
 			return nil
 		},
-	})
+	}, buf)

 	cmd := newConfigRemoveCommand(cli)
 	cmd.SetArgs(names)
 	cmd.SetOutput(ioutil.Discard)
-	assert.Error(t, cmd.Execute(), "error removing config: foo")
-	assert.Check(t, is.DeepEqual(names, removedConfigs))
+	assert.EqualError(t, cmd.Execute(), "error removing config: foo")
+	assert.Equal(t, names, removedConfigs)
 }
--- a/components/cli/cli/command/config/testdata/config-inspect-pretty.simple.golden
+++ b/components/cli/cli/command/config/testdata/config-inspect-pretty.simple.golden
@ -1,8 +1,8 @@
-ID:			configID
-Name:			configName
+ID: configID
+Name: configName
 Labels:
- - lbl1=value1
-Created at:            	0001-01-01 00:00:00 +0000 utc
-Updated at:            	0001-01-01 00:00:00 +0000 utc
+	- lbl1=value1
+Created at: 0001-01-01 00:00:00+0000 utc
+Updated at: 0001-01-01 00:00:00+0000 utc
 Data:
 payload here
--- a/components/cli/cli/command/config/testdata/config-inspect-without-format.multiple-configs-with-labels.golden
+++ b/components/cli/cli/command/config/testdata/config-inspect-without-format.multiple-configs-with-labels.golden
@ -1,7 +1,7 @@
 [
    {
        "ID": "ID-foo",
-        "Version": {},
+	"Version": {},
        "CreatedAt": "0001-01-01T00:00:00Z",
        "UpdatedAt": "0001-01-01T00:00:00Z",
        "Spec": {
@ -13,7 +13,7 @@
    },
    {
        "ID": "ID-bar",
-        "Version": {},
+	"Version": {},
        "CreatedAt": "0001-01-01T00:00:00Z",
        "UpdatedAt": "0001-01-01T00:00:00Z",
        "Spec": {
--- a/components/cli/cli/command/config/testdata/config-inspect-without-format.single-config.golden
+++ b/components/cli/cli/command/config/testdata/config-inspect-without-format.single-config.golden
@ -1,9 +1,9 @@
 [
    {
        "ID": "ID-foo",
-        "Version": {},
-        "CreatedAt": "0001-01-01T00:00:00Z",
-        "UpdatedAt": "0001-01-01T00:00:00Z",
+	"Version": {},
+	"CreatedAt": "0001-01-01T00:00:00Z",
+	"UpdatedAt": "0001-01-01T00:00:00Z",
        "Spec": {
            "Name": "foo",
            "Labels": null
--- a/components/cli/cli/command/config/testdata/config-list-sort.golden
+++ b/components/cli/cli/command/config/testdata/config-list-sort.golden
@ -1,4 +0,0 @@
-ID                  NAME                CREATED             UPDATED
-ID-1-foo            1-foo               2 hours ago         About an hour ago
-ID-2-foo            2-foo               2 hours ago         About an hour ago
-ID-10-foo           10-foo              2 hours ago         About an hour ago
--- a/components/cli/cli/command/config/testdata/config-list-with-config-format.golden
+++ b/components/cli/cli/command/config/testdata/config-list-with-config-format.golden
@ -1,2 +1,2 @@
+foo
 bar label=label-bar
-foo 
--- a/components/cli/cli/command/config/testdata/config-list-with-filter.golden
+++ b/components/cli/cli/command/config/testdata/config-list-with-filter.golden
@ -1,3 +1,3 @@
 ID                  NAME                CREATED             UPDATED
-ID-bar              bar                 2 hours ago         About an hour ago
 ID-foo              foo                 2 hours ago         About an hour ago
+ID-bar              bar                 2 hours ago         About an hour ago
--- a/components/cli/cli/command/config/testdata/config-list-with-format.golden
+++ b/components/cli/cli/command/config/testdata/config-list-with-format.golden
@ -1,2 +1,2 @@
+foo
 bar label=label-bar
-foo 
--- a/components/cli/cli/command/config/testdata/config-list-with-quiet-option.golden
+++ b/components/cli/cli/command/config/testdata/config-list-with-quiet-option.golden
@ -1,2 +1,2 @@
-ID-bar
 ID-foo
+ID-bar
--- a/components/cli/cli/command/config/testdata/config-list.golden
+++ b/components/cli/cli/command/config/testdata/config-list.golden
@ -0,0 +1,3 @@
+ID                  NAME                CREATED             UPDATED
+ID-foo              foo                 2 hours ago         About an hour ago
+ID-bar              bar                 2 hours ago         About an hour ago
--- a/components/cli/cli/command/container/attach.go
+++ b/components/cli/cli/command/container/attach.go
@ -1,18 +1,16 @@
 package container

 import (
-	"fmt"
 	"io"
 	"net/http/httputil"

+	"github.com/Sirupsen/logrus"
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/client"
 	"github.com/docker/docker/pkg/signal"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
 )
@ -68,9 +66,6 @@ func runAttach(dockerCli command.Cli, opts *attachOptions) error {
 	ctx := context.Background()
 	client := dockerCli.Client()

-	// request channel to wait for client
-	resultC, errC := client.ContainerWait(ctx, opts.container, "")
-
 	c, err := inspectContainerAndCheckState(ctx, client, opts.container)
 	if err != nil {
 		return err
@ -125,7 +120,18 @@ func runAttach(dockerCli command.Cli, opts *attachOptions) error {
 	}

 	if c.Config.Tty && dockerCli.Out().IsTerminal() {
-		resizeTTY(ctx, dockerCli, opts.container)
+		height, width := dockerCli.Out().GetTtySize()
+		// To handle the case where a user repeatedly attaches/detaches without resizing their
+		// terminal, the only way to get the shell prompt to display for attaches 2+ is to artificially
+		// resize it, then go back to normal. Without this, every attach after the first will
+		// require the user to manually resize or hit enter.
+		resizeTtyTo(ctx, client, opts.container, height+1, width+1, false)
+
+		// After the above resizing occurs, the call to MonitorTtySize below will handle resetting back
+		// to the actual size.
+		if err := MonitorTtySize(ctx, dockerCli, opts.container, false); err != nil {
+			logrus.Debugf("Error monitoring TTY size: %s", err)
+		}
 	}

 	streamer := hijackedIOStreamer{
@ -146,36 +152,13 @@ func runAttach(dockerCli command.Cli, opts *attachOptions) error {
 		return errAttach
 	}

-	return getExitStatus(errC, resultC)
-}
-
-func getExitStatus(errC <-chan error, resultC <-chan container.ContainerWaitOKBody) error {
-	select {
-	case result := <-resultC:
-		if result.Error != nil {
-			return fmt.Errorf(result.Error.Message)
-		}
-		if result.StatusCode != 0 {
-			return cli.StatusError{StatusCode: int(result.StatusCode)}
-		}
-	case err := <-errC:
+	_, status, err := getExitCode(ctx, dockerCli, opts.container)
+	if err != nil {
 		return err
 	}
+	if status != 0 {
+		return cli.StatusError{StatusCode: status}
+	}

 	return nil
 }
-
-func resizeTTY(ctx context.Context, dockerCli command.Cli, containerID string) {
-	height, width := dockerCli.Out().GetTtySize()
-	// To handle the case where a user repeatedly attaches/detaches without resizing their
-	// terminal, the only way to get the shell prompt to display for attaches 2+ is to artificially
-	// resize it, then go back to normal. Without this, every attach after the first will
-	// require the user to manually resize or hit enter.
-	resizeTtyTo(ctx, dockerCli.Client(), containerID, height+1, width+1, false)
-
-	// After the above resizing occurs, the call to MonitorTtySize below will handle resetting back
-	// to the actual size.
-	if err := MonitorTtySize(ctx, dockerCli, containerID, false); err != nil {
-		logrus.Debugf("Error monitoring TTY size: %s", err)
-	}
-}
--- a/components/cli/cli/command/container/attach_test.go
+++ b/components/cli/cli/command/container/attach_test.go
@ -1,15 +1,12 @@
 package container

 import (
-	"fmt"
 	"io/ioutil"
 	"testing"

-	"github.com/docker/cli/cli"
-	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/cli/internal/test"
 	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/gotestyourself/gotestyourself/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
 )

@ -70,60 +67,9 @@ func TestNewAttachCommandErrors(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
-		cmd := NewAttachCommand(test.NewFakeCli(&fakeClient{inspectFunc: tc.containerInspectFunc}))
+		cmd := NewAttachCommand(test.NewFakeCli(&fakeClient{containerInspectFunc: tc.containerInspectFunc}))
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
-	}
-}
-
-func TestGetExitStatus(t *testing.T) {
-	var (
-		expectedErr = fmt.Errorf("unexpected error")
-		errC        = make(chan error, 1)
-		resultC     = make(chan container.ContainerWaitOKBody, 1)
-	)
-
-	testcases := []struct {
-		result        *container.ContainerWaitOKBody
-		err           error
-		expectedError error
-	}{
-		{
-			result: &container.ContainerWaitOKBody{
-				StatusCode: 0,
-			},
-		},
-		{
-			err:           expectedErr,
-			expectedError: expectedErr,
-		},
-		{
-			result: &container.ContainerWaitOKBody{
-				Error: &container.ContainerWaitOKBodyError{expectedErr.Error()},
-			},
-			expectedError: expectedErr,
-		},
-		{
-			result: &container.ContainerWaitOKBody{
-				StatusCode: 15,
-			},
-			expectedError: cli.StatusError{StatusCode: 15},
-		},
-	}
-
-	for _, testcase := range testcases {
-		if testcase.err != nil {
-			errC <- testcase.err
-		}
-		if testcase.result != nil {
-			resultC <- *testcase.result
-		}
-		err := getExitStatus(errC, resultC)
-		if testcase.expectedError == nil {
-			assert.NilError(t, err)
-		} else {
-			assert.Error(t, err, testcase.expectedError.Error())
-		}
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
--- a/components/cli/cli/command/container/client_test.go
+++ b/components/cli/cli/command/container/client_test.go
@ -1,126 +1,19 @@
 package container

 import (
-	"io"
-
 	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"
 	"golang.org/x/net/context"
 )

 type fakeClient struct {
 	client.Client
-	inspectFunc           func(string) (types.ContainerJSON, error)
-	execInspectFunc       func(execID string) (types.ContainerExecInspect, error)
-	execCreateFunc        func(container string, config types.ExecConfig) (types.IDResponse, error)
-	createContainerFunc   func(config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, containerName string) (container.ContainerCreateCreatedBody, error)
-	containerStartFunc    func(container string, options types.ContainerStartOptions) error
-	imageCreateFunc       func(parentReference string, options types.ImageCreateOptions) (io.ReadCloser, error)
-	infoFunc              func() (types.Info, error)
-	containerStatPathFunc func(container, path string) (types.ContainerPathStat, error)
-	containerCopyFromFunc func(container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error)
-	logFunc               func(string, types.ContainerLogsOptions) (io.ReadCloser, error)
-	waitFunc              func(string) (<-chan container.ContainerWaitOKBody, <-chan error)
-	containerListFunc     func(types.ContainerListOptions) ([]types.Container, error)
-	Version               string
+	containerInspectFunc func(string) (types.ContainerJSON, error)
 }

-func (f *fakeClient) ContainerList(_ context.Context, options types.ContainerListOptions) ([]types.Container, error) {
-	if f.containerListFunc != nil {
-		return f.containerListFunc(options)
-	}
-	return []types.Container{}, nil
-}
-
-func (f *fakeClient) ContainerInspect(_ context.Context, containerID string) (types.ContainerJSON, error) {
-	if f.inspectFunc != nil {
-		return f.inspectFunc(containerID)
+func (cli *fakeClient) ContainerInspect(_ context.Context, containerID string) (types.ContainerJSON, error) {
+	if cli.containerInspectFunc != nil {
+		return cli.containerInspectFunc(containerID)
 	}
 	return types.ContainerJSON{}, nil
 }
-
-func (f *fakeClient) ContainerExecCreate(_ context.Context, container string, config types.ExecConfig) (types.IDResponse, error) {
-	if f.execCreateFunc != nil {
-		return f.execCreateFunc(container, config)
-	}
-	return types.IDResponse{}, nil
-}
-
-func (f *fakeClient) ContainerExecInspect(_ context.Context, execID string) (types.ContainerExecInspect, error) {
-	if f.execInspectFunc != nil {
-		return f.execInspectFunc(execID)
-	}
-	return types.ContainerExecInspect{}, nil
-}
-
-func (f *fakeClient) ContainerExecStart(ctx context.Context, execID string, config types.ExecStartCheck) error {
-	return nil
-}
-
-func (f *fakeClient) ContainerCreate(
-	_ context.Context,
-	config *container.Config,
-	hostConfig *container.HostConfig,
-	networkingConfig *network.NetworkingConfig,
-	containerName string,
-) (container.ContainerCreateCreatedBody, error) {
-	if f.createContainerFunc != nil {
-		return f.createContainerFunc(config, hostConfig, networkingConfig, containerName)
-	}
-	return container.ContainerCreateCreatedBody{}, nil
-}
-
-func (f *fakeClient) ImageCreate(ctx context.Context, parentReference string, options types.ImageCreateOptions) (io.ReadCloser, error) {
-	if f.imageCreateFunc != nil {
-		return f.imageCreateFunc(parentReference, options)
-	}
-	return nil, nil
-}
-
-func (f *fakeClient) Info(_ context.Context) (types.Info, error) {
-	if f.infoFunc != nil {
-		return f.infoFunc()
-	}
-	return types.Info{}, nil
-}
-
-func (f *fakeClient) ContainerStatPath(_ context.Context, container, path string) (types.ContainerPathStat, error) {
-	if f.containerStatPathFunc != nil {
-		return f.containerStatPathFunc(container, path)
-	}
-	return types.ContainerPathStat{}, nil
-}
-
-func (f *fakeClient) CopyFromContainer(_ context.Context, container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
-	if f.containerCopyFromFunc != nil {
-		return f.containerCopyFromFunc(container, srcPath)
-	}
-	return nil, types.ContainerPathStat{}, nil
-}
-
-func (f *fakeClient) ContainerLogs(_ context.Context, container string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
-	if f.logFunc != nil {
-		return f.logFunc(container, options)
-	}
-	return nil, nil
-}
-
-func (f *fakeClient) ClientVersion() string {
-	return f.Version
-}
-
-func (f *fakeClient) ContainerWait(_ context.Context, container string, _ container.WaitCondition) (<-chan container.ContainerWaitOKBody, <-chan error) {
-	if f.waitFunc != nil {
-		return f.waitFunc(container)
-	}
-	return nil, nil
-}
-
-func (f *fakeClient) ContainerStart(_ context.Context, container string, options types.ContainerStartOptions) error {
-	if f.containerStartFunc != nil {
-		return f.containerStartFunc(container, options)
-	}
-	return nil
-}
--- a/components/cli/cli/command/container/cmd.go
+++ b/components/cli/cli/command/container/cmd.go
@ -7,7 +7,8 @@ import (
 )

 // NewContainerCommand returns a cobra command for `container` subcommands
-func NewContainerCommand(dockerCli command.Cli) *cobra.Command {
+// nolint: interfacer
+func NewContainerCommand(dockerCli *command.DockerCli) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "container",
 		Short: "Manage containers",
--- a/components/cli/cli/command/container/commit.go
+++ b/components/cli/cli/command/container/commit.go
@ -22,7 +22,7 @@ type commitOptions struct {
 }

 // NewCommitCommand creates a new cobra.Command for `docker commit`
-func NewCommitCommand(dockerCli command.Cli) *cobra.Command {
+func NewCommitCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var options commitOptions

 	cmd := &cobra.Command{
@ -51,7 +51,7 @@ func NewCommitCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runCommit(dockerCli command.Cli, options *commitOptions) error {
+func runCommit(dockerCli *command.DockerCli, options *commitOptions) error {
 	ctx := context.Background()

 	name := options.container
--- a/components/cli/cli/command/container/cp.go
+++ b/components/cli/cli/command/container/cp.go
@ -26,21 +26,17 @@ type copyOptions struct {
 type copyDirection int

 const (
-	fromContainer copyDirection = 1 << iota
+	fromContainer copyDirection = (1 << iota)
 	toContainer
 	acrossContainers = fromContainer | toContainer
 )

 type cpConfig struct {
 	followLink bool
-	copyUIDGID bool
-	sourcePath string
-	destPath   string
-	container  string
 }

 // NewCopyCommand creates a new `docker cp` command
-func NewCopyCommand(dockerCli command.Cli) *cobra.Command {
+func NewCopyCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts copyOptions

 	cmd := &cobra.Command{
@ -69,57 +65,58 @@ func NewCopyCommand(dockerCli command.Cli) *cobra.Command {
 	}

 	flags := cmd.Flags()
+
 	flags.BoolVarP(&opts.followLink, "follow-link", "L", false, "Always follow symbol link in SRC_PATH")
 	flags.BoolVarP(&opts.copyUIDGID, "archive", "a", false, "Archive mode (copy all uid/gid information)")
+
 	return cmd
 }

-func runCopy(dockerCli command.Cli, opts copyOptions) error {
+func runCopy(dockerCli *command.DockerCli, opts copyOptions) error {
 	srcContainer, srcPath := splitCpArg(opts.source)
-	destContainer, destPath := splitCpArg(opts.destination)
-
-	copyConfig := cpConfig{
-		followLink: opts.followLink,
-		copyUIDGID: opts.copyUIDGID,
-		sourcePath: srcPath,
-		destPath:   destPath,
-	}
+	dstContainer, dstPath := splitCpArg(opts.destination)

 	var direction copyDirection
 	if srcContainer != "" {
 		direction |= fromContainer
-		copyConfig.container = srcContainer
 	}
-	if destContainer != "" {
+	if dstContainer != "" {
 		direction |= toContainer
-		copyConfig.container = destContainer
+	}
+
+	cpParam := &cpConfig{
+		followLink: opts.followLink,
 	}

 	ctx := context.Background()

 	switch direction {
 	case fromContainer:
-		return copyFromContainer(ctx, dockerCli, copyConfig)
+		return copyFromContainer(ctx, dockerCli, srcContainer, srcPath, dstPath, cpParam)
 	case toContainer:
-		return copyToContainer(ctx, dockerCli, copyConfig)
+		return copyToContainer(ctx, dockerCli, srcPath, dstContainer, dstPath, cpParam, opts.copyUIDGID)
 	case acrossContainers:
+		// Copying between containers isn't supported.
 		return errors.New("copying between containers is not supported")
 	default:
+		// User didn't specify any container.
 		return errors.New("must specify at least one container source")
 	}
 }

+func statContainerPath(ctx context.Context, dockerCli *command.DockerCli, containerName, path string) (types.ContainerPathStat, error) {
+	return dockerCli.Client().ContainerStatPath(ctx, containerName, path)
+}
+
 func resolveLocalPath(localPath string) (absPath string, err error) {
 	if absPath, err = filepath.Abs(localPath); err != nil {
 		return
 	}
-	return archive.PreserveTrailingDotOrSeparator(absPath, localPath, filepath.Separator), nil
+
+	return archive.PreserveTrailingDotOrSeparator(absPath, localPath), nil
 }

-func copyFromContainer(ctx context.Context, dockerCli command.Cli, copyConfig cpConfig) (err error) {
-	dstPath := copyConfig.destPath
-	srcPath := copyConfig.sourcePath
-
+func copyFromContainer(ctx context.Context, dockerCli *command.DockerCli, srcContainer, srcPath, dstPath string, cpParam *cpConfig) (err error) {
 	if dstPath != "-" {
 		// Get an absolute destination path.
 		dstPath, err = resolveLocalPath(dstPath)
@ -128,11 +125,10 @@ func copyFromContainer(ctx context.Context, dockerCli command.Cli, copyConfig cp
 		}
 	}

-	client := dockerCli.Client()
 	// if client requests to follow symbol link, then must decide target file to be copied
 	var rebaseName string
-	if copyConfig.followLink {
-		srcStat, err := client.ContainerStatPath(ctx, copyConfig.container, srcPath)
+	if cpParam.followLink {
+		srcStat, err := statContainerPath(ctx, dockerCli, srcContainer, srcPath)

 		// If the destination is a symbolic link, we should follow it.
 		if err == nil && srcStat.Mode&os.ModeSymlink != 0 {
@ -149,17 +145,20 @@ func copyFromContainer(ctx context.Context, dockerCli command.Cli, copyConfig cp

 	}

-	content, stat, err := client.CopyFromContainer(ctx, copyConfig.container, srcPath)
+	content, stat, err := dockerCli.Client().CopyFromContainer(ctx, srcContainer, srcPath)
 	if err != nil {
 		return err
 	}
 	defer content.Close()

 	if dstPath == "-" {
-		_, err = io.Copy(dockerCli.Out(), content)
+		// Send the response to STDOUT.
+		_, err = io.Copy(os.Stdout, content)
+
 		return err
 	}

+	// Prepare source copy info.
 	srcInfo := archive.CopyInfo{
 		Path:       srcPath,
 		Exists:     true,
@ -172,17 +171,13 @@ func copyFromContainer(ctx context.Context, dockerCli command.Cli, copyConfig cp
 		_, srcBase := archive.SplitPathDirEntry(srcInfo.Path)
 		preArchive = archive.RebaseArchiveEntries(content, srcBase, srcInfo.RebaseName)
 	}
+	// See comments in the implementation of `archive.CopyTo` for exactly what
+	// goes into deciding how and whether the source archive needs to be
+	// altered for the correct copy behavior.
 	return archive.CopyTo(preArchive, srcInfo, dstPath)
 }

-// In order to get the copy behavior right, we need to know information
-// about both the source and destination. The API is a simple tar
-// archive/extract API but we can use the stat info header about the
-// destination to be more informed about exactly what the destination is.
-func copyToContainer(ctx context.Context, dockerCli command.Cli, copyConfig cpConfig) (err error) {
-	srcPath := copyConfig.sourcePath
-	dstPath := copyConfig.destPath
-
+func copyToContainer(ctx context.Context, dockerCli *command.DockerCli, srcPath, dstContainer, dstPath string, cpParam *cpConfig, copyUIDGID bool) (err error) {
 	if srcPath != "-" {
 		// Get an absolute source path.
 		srcPath, err = resolveLocalPath(srcPath)
@ -191,10 +186,14 @@ func copyToContainer(ctx context.Context, dockerCli command.Cli, copyConfig cpCo
 		}
 	}

-	client := dockerCli.Client()
+	// In order to get the copy behavior right, we need to know information
+	// about both the source and destination. The API is a simple tar
+	// archive/extract API but we can use the stat info header about the
+	// destination to be more informed about exactly what the destination is.
+
 	// Prepare destination copy info by stat-ing the container path.
 	dstInfo := archive.CopyInfo{Path: dstPath}
-	dstStat, err := client.ContainerStatPath(ctx, copyConfig.container, dstPath)
+	dstStat, err := statContainerPath(ctx, dockerCli, dstContainer, dstPath)

 	// If the destination is a symbolic link, we should evaluate it.
 	if err == nil && dstStat.Mode&os.ModeSymlink != 0 {
@ -206,7 +205,7 @@ func copyToContainer(ctx context.Context, dockerCli command.Cli, copyConfig cpCo
 		}

 		dstInfo.Path = linkTarget
-		dstStat, err = client.ContainerStatPath(ctx, copyConfig.container, linkTarget)
+		dstStat, err = statContainerPath(ctx, dockerCli, dstContainer, linkTarget)
 	}

 	// Ignore any error and assume that the parent directory of the destination
@ -225,14 +224,15 @@ func copyToContainer(ctx context.Context, dockerCli command.Cli, copyConfig cpCo
 	)

 	if srcPath == "-" {
+		// Use STDIN.
 		content = os.Stdin
 		resolvedDstPath = dstInfo.Path
 		if !dstInfo.IsDir {
-			return errors.Errorf("destination \"%s:%s\" must be a directory", copyConfig.container, dstPath)
+			return errors.Errorf("destination \"%s:%s\" must be a directory", dstContainer, dstPath)
 		}
 	} else {
 		// Prepare source copy info.
-		srcInfo, err := archive.CopyInfoSourcePath(srcPath, copyConfig.followLink)
+		srcInfo, err := archive.CopyInfoSourcePath(srcPath, cpParam.followLink)
 		if err != nil {
 			return err
 		}
@ -267,9 +267,10 @@ func copyToContainer(ctx context.Context, dockerCli command.Cli, copyConfig cpCo

 	options := types.CopyToContainerOptions{
 		AllowOverwriteDirWithFile: false,
-		CopyUIDGID:                copyConfig.copyUIDGID,
+		CopyUIDGID:                copyUIDGID,
 	}
-	return client.CopyToContainer(ctx, copyConfig.container, resolvedDstPath, content, options)
+
+	return dockerCli.Client().CopyToContainer(ctx, dstContainer, resolvedDstPath, content, options)
 }

 // We use `:` as a delimiter between CONTAINER and PATH, but `:` could also be
--- a/components/cli/cli/command/container/cp_test.go
+++ b/components/cli/cli/command/container/cp_test.go
@ -1,192 +0,0 @@
-package container
-
-import (
-	"io"
-	"io/ioutil"
-	"os"
-	"runtime"
-	"strings"
-	"testing"
-
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/pkg/archive"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/fs"
-	"github.com/gotestyourself/gotestyourself/skip"
-)
-
-func TestRunCopyWithInvalidArguments(t *testing.T) {
-	var testcases = []struct {
-		doc         string
-		options     copyOptions
-		expectedErr string
-	}{
-		{
-			doc: "copy between container",
-			options: copyOptions{
-				source:      "first:/path",
-				destination: "second:/path",
-			},
-			expectedErr: "copying between containers is not supported",
-		},
-		{
-			doc: "copy without a container",
-			options: copyOptions{
-				source:      "./source",
-				destination: "./dest",
-			},
-			expectedErr: "must specify at least one container source",
-		},
-	}
-	for _, testcase := range testcases {
-		t.Run(testcase.doc, func(t *testing.T) {
-			err := runCopy(test.NewFakeCli(nil), testcase.options)
-			assert.Error(t, err, testcase.expectedErr)
-		})
-	}
-}
-
-func TestRunCopyFromContainerToStdout(t *testing.T) {
-	tarContent := "the tar content"
-
-	fakeClient := &fakeClient{
-		containerCopyFromFunc: func(container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
-			assert.Check(t, is.Equal("container", container))
-			return ioutil.NopCloser(strings.NewReader(tarContent)), types.ContainerPathStat{}, nil
-		},
-	}
-	options := copyOptions{source: "container:/path", destination: "-"}
-	cli := test.NewFakeCli(fakeClient)
-	err := runCopy(cli, options)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(tarContent, cli.OutBuffer().String()))
-	assert.Check(t, is.Equal("", cli.ErrBuffer().String()))
-}
-
-func TestRunCopyFromContainerToFilesystem(t *testing.T) {
-	destDir := fs.NewDir(t, "cp-test",
-		fs.WithFile("file1", "content\n"))
-	defer destDir.Remove()
-
-	fakeClient := &fakeClient{
-		containerCopyFromFunc: func(container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
-			assert.Check(t, is.Equal("container", container))
-			readCloser, err := archive.TarWithOptions(destDir.Path(), &archive.TarOptions{})
-			return readCloser, types.ContainerPathStat{}, err
-		},
-	}
-	options := copyOptions{source: "container:/path", destination: destDir.Path()}
-	cli := test.NewFakeCli(fakeClient)
-	err := runCopy(cli, options)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal("", cli.OutBuffer().String()))
-	assert.Check(t, is.Equal("", cli.ErrBuffer().String()))
-
-	content, err := ioutil.ReadFile(destDir.Join("file1"))
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal("content\n", string(content)))
-}
-
-func TestRunCopyFromContainerToFilesystemMissingDestinationDirectory(t *testing.T) {
-	destDir := fs.NewDir(t, "cp-test",
-		fs.WithFile("file1", "content\n"))
-	defer destDir.Remove()
-
-	fakeClient := &fakeClient{
-		containerCopyFromFunc: func(container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
-			assert.Check(t, is.Equal("container", container))
-			readCloser, err := archive.TarWithOptions(destDir.Path(), &archive.TarOptions{})
-			return readCloser, types.ContainerPathStat{}, err
-		},
-	}
-
-	options := copyOptions{
-		source:      "container:/path",
-		destination: destDir.Join("missing", "foo"),
-	}
-	cli := test.NewFakeCli(fakeClient)
-	err := runCopy(cli, options)
-	assert.ErrorContains(t, err, destDir.Join("missing"))
-}
-
-func TestRunCopyToContainerFromFileWithTrailingSlash(t *testing.T) {
-	srcFile := fs.NewFile(t, t.Name())
-	defer srcFile.Remove()
-
-	options := copyOptions{
-		source:      srcFile.Path() + string(os.PathSeparator),
-		destination: "container:/path",
-	}
-	cli := test.NewFakeCli(&fakeClient{})
-	err := runCopy(cli, options)
-
-	expectedError := "not a directory"
-	if runtime.GOOS == "windows" {
-		expectedError = "The filename, directory name, or volume label syntax is incorrect"
-	}
-	assert.ErrorContains(t, err, expectedError)
-}
-
-func TestRunCopyToContainerSourceDoesNotExist(t *testing.T) {
-	options := copyOptions{
-		source:      "/does/not/exist",
-		destination: "container:/path",
-	}
-	cli := test.NewFakeCli(&fakeClient{})
-	err := runCopy(cli, options)
-	expected := "no such file or directory"
-	if runtime.GOOS == "windows" {
-		expected = "cannot find the file specified"
-	}
-	assert.ErrorContains(t, err, expected)
-}
-
-func TestSplitCpArg(t *testing.T) {
-	var testcases = []struct {
-		doc               string
-		path              string
-		os                string
-		expectedContainer string
-		expectedPath      string
-	}{
-		{
-			doc:          "absolute path with colon",
-			os:           "linux",
-			path:         "/abs/path:withcolon",
-			expectedPath: "/abs/path:withcolon",
-		},
-		{
-			doc:          "relative path with colon",
-			path:         "./relative:path",
-			expectedPath: "./relative:path",
-		},
-		{
-			doc:          "absolute path with drive",
-			os:           "windows",
-			path:         `d:\abs\path`,
-			expectedPath: `d:\abs\path`,
-		},
-		{
-			doc:          "no separator",
-			path:         "relative/path",
-			expectedPath: "relative/path",
-		},
-		{
-			doc:               "with separator",
-			path:              "container:/opt/foo",
-			expectedPath:      "/opt/foo",
-			expectedContainer: "container",
-		},
-	}
-	for _, testcase := range testcases {
-		t.Run(testcase.doc, func(t *testing.T) {
-			skip.IfCondition(t, testcase.os != "" && testcase.os != runtime.GOOS)
-
-			container, path := splitCpArg(testcase.path)
-			assert.Check(t, is.Equal(testcase.expectedContainer, container))
-			assert.Check(t, is.Equal(testcase.expectedPath, path))
-		})
-	}
-}
--- a/components/cli/cli/command/container/create.go
+++ b/components/cli/cli/command/container/create.go
@ -21,9 +21,7 @@ import (
 )

 type createOptions struct {
-	name      string
-	platform  string
-	untrusted bool
+	name string
 }

 // NewCreateCommand creates a new cobra.Command for `docker create`
@ -53,8 +51,7 @@ func NewCreateCommand(dockerCli command.Cli) *cobra.Command {
 	// with hostname
 	flags.Bool("help", false, "Print usage")

-	command.AddPlatformFlag(flags, &opts.platform)
-	command.AddTrustVerificationFlags(flags, &opts.untrusted, dockerCli.ContentTrustEnabled())
+	command.AddTrustVerificationFlags(flags)
 	copts = addFlags(flags)
 	return cmd
 }
@ -65,7 +62,7 @@ func runCreate(dockerCli command.Cli, flags *pflag.FlagSet, opts *createOptions,
 		reportError(dockerCli.Err(), "create", err.Error(), true)
 		return cli.StatusError{StatusCode: 125}
 	}
-	response, err := createContainer(context.Background(), dockerCli, containerConfig, opts)
+	response, err := createContainer(context.Background(), dockerCli, containerConfig, opts.name)
 	if err != nil {
 		return err
 	}
@ -73,7 +70,7 @@ func runCreate(dockerCli command.Cli, flags *pflag.FlagSet, opts *createOptions,
 	return nil
 }

-func pullImage(ctx context.Context, dockerCli command.Cli, image string, platform string, out io.Writer) error {
+func pullImage(ctx context.Context, dockerCli command.Cli, image string, out io.Writer) error {
 	ref, err := reference.ParseNormalizedNamed(image)
 	if err != nil {
 		return err
@ -93,7 +90,6 @@ func pullImage(ctx context.Context, dockerCli command.Cli, image string, platfor

 	options := types.ImageCreateOptions{
 		RegistryAuth: encodedAuth,
-		Platform:     platform,
 	}

 	responseBody, err := dockerCli.Client().ImageCreate(ctx, image, options)
@ -117,9 +113,6 @@ type cidFile struct {
 }

 func (cid *cidFile) Close() error {
-	if cid.file == nil {
-		return nil
-	}
 	cid.file.Close()

 	if cid.written {
@ -133,9 +126,6 @@ func (cid *cidFile) Close() error {
 }

 func (cid *cidFile) Write(id string) error {
-	if cid.file == nil {
-		return nil
-	}
 	if _, err := cid.file.Write([]byte(id)); err != nil {
 		return errors.Errorf("Failed to write the container ID to the file: %s", err)
 	}
@ -144,9 +134,6 @@ func (cid *cidFile) Write(id string) error {
 }

 func newCIDFile(path string) (*cidFile, error) {
-	if path == "" {
-		return &cidFile{}, nil
-	}
 	if _, err := os.Stat(path); err == nil {
 		return nil, errors.Errorf("Container ID file found, make sure the other container isn't running or delete %s", path)
 	}
@ -159,22 +146,26 @@ func newCIDFile(path string) (*cidFile, error) {
 	return &cidFile{path: path, file: f}, nil
 }

-func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig *containerConfig, opts *createOptions) (*container.ContainerCreateCreatedBody, error) {
+func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig *containerConfig, name string) (*container.ContainerCreateCreatedBody, error) {
 	config := containerConfig.Config
 	hostConfig := containerConfig.HostConfig
 	networkingConfig := containerConfig.NetworkingConfig
 	stderr := dockerCli.Err()

 	var (
-		trustedRef reference.Canonical
-		namedRef   reference.Named
+		containerIDFile *cidFile
+		trustedRef      reference.Canonical
+		namedRef        reference.Named
 	)

-	containerIDFile, err := newCIDFile(hostConfig.ContainerIDFile)
-	if err != nil {
-		return nil, err
+	cidfile := hostConfig.ContainerIDFile
+	if cidfile != "" {
+		var err error
+		if containerIDFile, err = newCIDFile(cidfile); err != nil {
+			return nil, err
+		}
+		defer containerIDFile.Close()
 	}
-	defer containerIDFile.Close()

 	ref, err := reference.ParseAnyReference(config.Image)
 	if err != nil {
@ -183,7 +174,7 @@ func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig
 	if named, ok := ref.(reference.Named); ok {
 		namedRef = reference.TagNameOnly(named)

-		if taggedRef, ok := namedRef.(reference.NamedTagged); ok && !opts.untrusted {
+		if taggedRef, ok := namedRef.(reference.NamedTagged); ok && command.IsTrusted() {
 			var err error
 			trustedRef, err = image.TrustedReference(ctx, dockerCli, taggedRef, nil)
 			if err != nil {
@ -194,15 +185,15 @@ func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig
 	}

 	//create the container
-	response, err := dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, opts.name)
+	response, err := dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, name)

 	//if image not found try to pull it
 	if err != nil {
-		if apiclient.IsErrNotFound(err) && namedRef != nil {
+		if apiclient.IsErrImageNotFound(err) && namedRef != nil {
 			fmt.Fprintf(stderr, "Unable to find image '%s' locally\n", reference.FamiliarString(namedRef))

 			// we don't want to write to stdout anything apart from container.ID
-			if err := pullImage(ctx, dockerCli, config.Image, opts.platform, stderr); err != nil {
+			if err = pullImage(ctx, dockerCli, config.Image, stderr); err != nil {
 				return nil, err
 			}
 			if taggedRef, ok := namedRef.(reference.NamedTagged); ok && trustedRef != nil {
@ -212,7 +203,7 @@ func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig
 			}
 			// Retry
 			var retryErr error
-			response, retryErr = dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, opts.name)
+			response, retryErr = dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, name)
 			if retryErr != nil {
 				return nil, retryErr
 			}
@ -224,6 +215,10 @@ func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig
 	for _, warning := range response.Warnings {
 		fmt.Fprintf(stderr, "WARNING: %s\n", warning)
 	}
-	err = containerIDFile.Write(response.ID)
-	return &response, err
+	if containerIDFile != nil {
+		if err = containerIDFile.Write(response.ID); err != nil {
+			return nil, err
+		}
+	}
+	return &response, nil
 }
--- a/components/cli/cli/command/container/create_test.go
+++ b/components/cli/cli/command/container/create_test.go
@ -1,172 +0,0 @@
-package container
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"runtime"
-	"strings"
-	"testing"
-
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/cli/internal/test/notary"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/network"
-	"github.com/google/go-cmp/cmp"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/fs"
-	"github.com/pkg/errors"
-)
-
-func TestCIDFileNoOPWithNoFilename(t *testing.T) {
-	file, err := newCIDFile("")
-	assert.NilError(t, err)
-	assert.DeepEqual(t, &cidFile{}, file, cmp.AllowUnexported(cidFile{}))
-
-	assert.NilError(t, file.Write("id"))
-	assert.NilError(t, file.Close())
-}
-
-func TestNewCIDFileWhenFileAlreadyExists(t *testing.T) {
-	tempfile := fs.NewFile(t, "test-cid-file")
-	defer tempfile.Remove()
-
-	_, err := newCIDFile(tempfile.Path())
-	assert.ErrorContains(t, err, "Container ID file found")
-}
-
-func TestCIDFileCloseWithNoWrite(t *testing.T) {
-	tempdir := fs.NewDir(t, "test-cid-file")
-	defer tempdir.Remove()
-
-	path := tempdir.Join("cidfile")
-	file, err := newCIDFile(path)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(file.path, path))
-
-	assert.NilError(t, file.Close())
-	_, err = os.Stat(path)
-	assert.Check(t, os.IsNotExist(err))
-}
-
-func TestCIDFileCloseWithWrite(t *testing.T) {
-	tempdir := fs.NewDir(t, "test-cid-file")
-	defer tempdir.Remove()
-
-	path := tempdir.Join("cidfile")
-	file, err := newCIDFile(path)
-	assert.NilError(t, err)
-
-	content := "id"
-	assert.NilError(t, file.Write(content))
-
-	actual, err := ioutil.ReadFile(path)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(content, string(actual)))
-
-	assert.NilError(t, file.Close())
-	_, err = os.Stat(path)
-	assert.NilError(t, err)
-}
-
-func TestCreateContainerPullsImageIfMissing(t *testing.T) {
-	imageName := "does-not-exist-locally"
-	responseCounter := 0
-	containerID := "abcdef"
-
-	client := &fakeClient{
-		createContainerFunc: func(
-			config *container.Config,
-			hostConfig *container.HostConfig,
-			networkingConfig *network.NetworkingConfig,
-			containerName string,
-		) (container.ContainerCreateCreatedBody, error) {
-			defer func() { responseCounter++ }()
-			switch responseCounter {
-			case 0:
-				return container.ContainerCreateCreatedBody{}, fakeNotFound{}
-			case 1:
-				return container.ContainerCreateCreatedBody{ID: containerID}, nil
-			default:
-				return container.ContainerCreateCreatedBody{}, errors.New("unexpected")
-			}
-		},
-		imageCreateFunc: func(parentReference string, options types.ImageCreateOptions) (io.ReadCloser, error) {
-			return ioutil.NopCloser(strings.NewReader("")), nil
-		},
-		infoFunc: func() (types.Info, error) {
-			return types.Info{IndexServerAddress: "http://indexserver"}, nil
-		},
-	}
-	cli := test.NewFakeCli(client)
-	config := &containerConfig{
-		Config: &container.Config{
-			Image: imageName,
-		},
-		HostConfig: &container.HostConfig{},
-	}
-	body, err := createContainer(context.Background(), cli, config, &createOptions{
-		name:      "name",
-		platform:  runtime.GOOS,
-		untrusted: true,
-	})
-	assert.NilError(t, err)
-	expected := container.ContainerCreateCreatedBody{ID: containerID}
-	assert.Check(t, is.DeepEqual(expected, *body))
-	stderr := cli.ErrBuffer().String()
-	assert.Check(t, is.Contains(stderr, "Unable to find image 'does-not-exist-locally:latest' locally"))
-}
-
-func TestNewCreateCommandWithContentTrustErrors(t *testing.T) {
-	testCases := []struct {
-		name          string
-		args          []string
-		expectedError string
-		notaryFunc    test.NotaryClientFuncType
-	}{
-		{
-			name:          "offline-notary-server",
-			notaryFunc:    notary.GetOfflineNotaryRepository,
-			expectedError: "client is offline",
-			args:          []string{"image:tag"},
-		},
-		{
-			name:          "uninitialized-notary-server",
-			notaryFunc:    notary.GetUninitializedNotaryRepository,
-			expectedError: "remote trust data does not exist",
-			args:          []string{"image:tag"},
-		},
-		{
-			name:          "empty-notary-server",
-			notaryFunc:    notary.GetEmptyTargetsNotaryRepository,
-			expectedError: "No valid trust data for tag",
-			args:          []string{"image:tag"},
-		},
-	}
-	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{
-			createContainerFunc: func(config *container.Config,
-				hostConfig *container.HostConfig,
-				networkingConfig *network.NetworkingConfig,
-				containerName string,
-			) (container.ContainerCreateCreatedBody, error) {
-				return container.ContainerCreateCreatedBody{}, fmt.Errorf("shouldn't try to pull image")
-			},
-		}, test.EnableContentTrust)
-		cli.SetNotaryClient(tc.notaryFunc)
-		cmd := NewCreateCommand(cli)
-		cmd.SetOutput(ioutil.Discard)
-		cmd.SetArgs(tc.args)
-		err := cmd.Execute()
-		assert.ErrorContains(t, err, tc.expectedError)
-	}
-}
-
-type fakeNotFound struct{}
-
-func (f fakeNotFound) NotFound() bool { return true }
-func (f fakeNotFound) Error() string  { return "error fake not found" }
--- a/components/cli/cli/command/container/diff.go
+++ b/components/cli/cli/command/container/diff.go
@ -14,7 +14,7 @@ type diffOptions struct {
 }

 // NewDiffCommand creates a new cobra.Command for `docker diff`
-func NewDiffCommand(dockerCli command.Cli) *cobra.Command {
+func NewDiffCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts diffOptions

 	return &cobra.Command{
@ -28,7 +28,7 @@ func NewDiffCommand(dockerCli command.Cli) *cobra.Command {
 	}
 }

-func runDiff(dockerCli command.Cli, opts *diffOptions) error {
+func runDiff(dockerCli *command.DockerCli, opts *diffOptions) error {
 	if opts.container == "" {
 		return errors.New("Container name cannot be empty")
 	}
--- a/components/cli/cli/command/container/exec.go
+++ b/components/cli/cli/command/container/exec.go
@ -4,14 +4,13 @@ import (
 	"fmt"
 	"io"

+	"github.com/Sirupsen/logrus"
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/config/configfile"
 	"github.com/docker/cli/opts"
 	"github.com/docker/docker/api/types"
 	apiclient "github.com/docker/docker/client"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
+	"github.com/docker/docker/pkg/promise"
 	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
 )
@ -23,14 +22,14 @@ type execOptions struct {
 	detach      bool
 	user        string
 	privileged  bool
-	env         opts.ListOpts
-	workdir     string
-	container   string
-	command     []string
+	env         *opts.ListOpts
 }

-func newExecOptions() execOptions {
-	return execOptions{env: opts.NewListOpts(opts.ValidateEnv)}
+func newExecOptions() *execOptions {
+	var values []string
+	return &execOptions{
+		env: opts.NewListOptsRef(&values, opts.ValidateEnv),
+	}
 }

 // NewExecCommand creates a new cobra.Command for `docker exec`
@ -42,9 +41,9 @@ func NewExecCommand(dockerCli command.Cli) *cobra.Command {
 		Short: "Run a command in a running container",
 		Args:  cli.RequiresMinArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			options.container = args[0]
-			options.command = args[1:]
-			return runExec(dockerCli, options)
+			container := args[0]
+			execCmd := args[1:]
+			return runExec(dockerCli, options, container, execCmd)
 		},
 	}

@ -57,16 +56,27 @@ func NewExecCommand(dockerCli command.Cli) *cobra.Command {
 	flags.BoolVarP(&options.detach, "detach", "d", false, "Detached mode: run command in the background")
 	flags.StringVarP(&options.user, "user", "u", "", "Username or UID (format: <name|uid>[:<group|gid>])")
 	flags.BoolVarP(&options.privileged, "privileged", "", false, "Give extended privileges to the command")
-	flags.VarP(&options.env, "env", "e", "Set environment variables")
+	flags.VarP(options.env, "env", "e", "Set environment variables")
 	flags.SetAnnotation("env", "version", []string{"1.25"})
-	flags.StringVarP(&options.workdir, "workdir", "w", "", "Working directory inside the container")
-	flags.SetAnnotation("workdir", "version", []string{"1.35"})

 	return cmd
 }

-func runExec(dockerCli command.Cli, options execOptions) error {
-	execConfig := parseExec(options, dockerCli.ConfigFile())
+// nolint: gocyclo
+func runExec(dockerCli command.Cli, options *execOptions, container string, execCmd []string) error {
+	execConfig, err := parseExec(options, execCmd)
+	// just in case the ParseExec does not exit
+	if container == "" || err != nil {
+		return cli.StatusError{StatusCode: 1}
+	}
+
+	if options.detachKeys != "" {
+		dockerCli.ConfigFile().DetachKeys = options.detachKeys
+	}
+
+	// Send client escape keys
+	execConfig.DetachKeys = dockerCli.ConfigFile().DetachKeys
+
 	ctx := context.Background()
 	client := dockerCli.Client()

@ -74,7 +84,7 @@ func runExec(dockerCli command.Cli, options execOptions) error {
 	// otherwise if we error out we will leak execIDs on the server (and
 	// there's no easy way to clean those up). But also in order to make "not
 	// exist" errors take precedence we do a dummy inspect first.
-	if _, err := client.ContainerInspect(ctx, options.container); err != nil {
+	if _, err := client.ContainerInspect(ctx, container); err != nil {
 		return err
 	}
 	if !execConfig.Detach {
@ -83,31 +93,32 @@ func runExec(dockerCli command.Cli, options execOptions) error {
 		}
 	}

-	response, err := client.ContainerExecCreate(ctx, options.container, *execConfig)
+	response, err := client.ContainerExecCreate(ctx, container, *execConfig)
 	if err != nil {
 		return err
 	}

 	execID := response.ID
 	if execID == "" {
-		return errors.New("exec ID empty")
+		fmt.Fprintln(dockerCli.Out(), "exec ID empty")
+		return nil
 	}

+	// Temp struct for execStart so that we don't need to transfer all the execConfig.
 	if execConfig.Detach {
 		execStartCheck := types.ExecStartCheck{
 			Detach: execConfig.Detach,
 			Tty:    execConfig.Tty,
 		}
+
 		return client.ContainerExecStart(ctx, execID, execStartCheck)
 	}
-	return interactiveExec(ctx, dockerCli, execConfig, execID)
-}

-func interactiveExec(ctx context.Context, dockerCli command.Cli, execConfig *types.ExecConfig, execID string) error {
 	// Interactive exec requested.
 	var (
 		out, stderr io.Writer
 		in          io.ReadCloser
+		errCh       chan error
 	)

 	if execConfig.AttachStdin {
@ -124,34 +135,24 @@ func interactiveExec(ctx context.Context, dockerCli command.Cli, execConfig *typ
 		}
 	}

-	client := dockerCli.Client()
-	execStartCheck := types.ExecStartCheck{
-		Tty: execConfig.Tty,
-	}
-	resp, err := client.ContainerExecAttach(ctx, execID, execStartCheck)
+	resp, err := client.ContainerExecAttach(ctx, execID, *execConfig)
 	if err != nil {
 		return err
 	}
 	defer resp.Close()
+	errCh = promise.Go(func() error {
+		streamer := hijackedIOStreamer{
+			streams:      dockerCli,
+			inputStream:  in,
+			outputStream: out,
+			errorStream:  stderr,
+			resp:         resp,
+			tty:          execConfig.Tty,
+			detachKeys:   execConfig.DetachKeys,
+		}

-	errCh := make(chan error, 1)
-
-	go func() {
-		defer close(errCh)
-		errCh <- func() error {
-			streamer := hijackedIOStreamer{
-				streams:      dockerCli,
-				inputStream:  in,
-				outputStream: out,
-				errorStream:  stderr,
-				resp:         resp,
-				tty:          execConfig.Tty,
-				detachKeys:   execConfig.DetachKeys,
-			}
-
-			return streamer.stream(ctx)
-		}()
-	}()
+		return streamer.stream(ctx)
+	})

 	if execConfig.Tty && dockerCli.In().IsTerminal() {
 		if err := MonitorTtySize(ctx, dockerCli, execID, true); err != nil {
@ -164,36 +165,42 @@ func interactiveExec(ctx context.Context, dockerCli command.Cli, execConfig *typ
 		return err
 	}

-	return getExecExitStatus(ctx, client, execID)
+	var status int
+	if _, status, err = getExecExitCode(ctx, client, execID); err != nil {
+		return err
+	}
+
+	if status != 0 {
+		return cli.StatusError{StatusCode: status}
+	}
+
+	return nil
 }

-func getExecExitStatus(ctx context.Context, client apiclient.ContainerAPIClient, execID string) error {
+// getExecExitCode perform an inspect on the exec command. It returns
+// the running state and the exit code.
+func getExecExitCode(ctx context.Context, client apiclient.ContainerAPIClient, execID string) (bool, int, error) {
 	resp, err := client.ContainerExecInspect(ctx, execID)
 	if err != nil {
 		// If we can't connect, then the daemon probably died.
 		if !apiclient.IsErrConnectionFailed(err) {
-			return err
+			return false, -1, err
 		}
-		return cli.StatusError{StatusCode: -1}
+		return false, -1, nil
 	}
-	status := resp.ExitCode
-	if status != 0 {
-		return cli.StatusError{StatusCode: status}
-	}
-	return nil
+
+	return resp.Running, resp.ExitCode, nil
 }

 // parseExec parses the specified args for the specified command and generates
 // an ExecConfig from it.
-func parseExec(opts execOptions, configFile *configfile.ConfigFile) *types.ExecConfig {
+func parseExec(opts *execOptions, execCmd []string) (*types.ExecConfig, error) {
 	execConfig := &types.ExecConfig{
 		User:       opts.user,
 		Privileged: opts.privileged,
 		Tty:        opts.tty,
-		Cmd:        opts.command,
+		Cmd:        execCmd,
 		Detach:     opts.detach,
-		Env:        opts.env.GetAll(),
-		WorkingDir: opts.workdir,
 	}

 	// If -d is not set, attach to everything by default
@ -205,10 +212,9 @@ func parseExec(opts execOptions, configFile *configfile.ConfigFile) *types.ExecC
 		}
 	}

-	if opts.detachKeys != "" {
-		execConfig.DetachKeys = opts.detachKeys
-	} else {
-		execConfig.DetachKeys = configFile.DetachKeys
+	if opts.env != nil {
+		execConfig.Env = opts.env.GetAll()
 	}
-	return execConfig
+
+	return execConfig, nil
 }
--- a/components/cli/cli/command/container/exec_test.go
+++ b/components/cli/cli/command/container/exec_test.go
@ -4,203 +4,120 @@ import (
 	"io/ioutil"
 	"testing"

-	"github.com/docker/cli/cli"
-	"github.com/docker/cli/cli/config/configfile"
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/cli/opts"
+	"github.com/docker/cli/cli/internal/test"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
-	"golang.org/x/net/context"
+	"github.com/stretchr/testify/require"
 )

-func withDefaultOpts(options execOptions) execOptions {
-	options.env = opts.NewListOpts(opts.ValidateEnv)
-	if len(options.command) == 0 {
-		options.command = []string{"command"}
-	}
-	return options
+type arguments struct {
+	options execOptions
+	execCmd []string
 }

 func TestParseExec(t *testing.T) {
-	testcases := []struct {
-		options    execOptions
-		configFile configfile.ConfigFile
-		expected   types.ExecConfig
-	}{
+	valids := map[*arguments]*types.ExecConfig{
 		{
-			expected: types.ExecConfig{
-				Cmd:          []string{"command"},
-				AttachStdout: true,
-				AttachStderr: true,
-			},
-			options: withDefaultOpts(execOptions{}),
+			execCmd: []string{"command"},
+		}: {
+			Cmd:          []string{"command"},
+			AttachStdout: true,
+			AttachStderr: true,
 		},
 		{
-			expected: types.ExecConfig{
-				Cmd:          []string{"command1", "command2"},
-				AttachStdout: true,
-				AttachStderr: true,
-			},
-			options: withDefaultOpts(execOptions{
-				command: []string{"command1", "command2"},
-			}),
+			execCmd: []string{"command1", "command2"},
+		}: {
+			Cmd:          []string{"command1", "command2"},
+			AttachStdout: true,
+			AttachStderr: true,
 		},
 		{
-			options: withDefaultOpts(execOptions{
+			options: execOptions{
 				interactive: true,
 				tty:         true,
 				user:        "uid",
-			}),
-			expected: types.ExecConfig{
-				User:         "uid",
-				AttachStdin:  true,
-				AttachStdout: true,
-				AttachStderr: true,
-				Tty:          true,
-				Cmd:          []string{"command"},
 			},
+			execCmd: []string{"command"},
+		}: {
+			User:         "uid",
+			AttachStdin:  true,
+			AttachStdout: true,
+			AttachStderr: true,
+			Tty:          true,
+			Cmd:          []string{"command"},
 		},
 		{
-			options: withDefaultOpts(execOptions{detach: true}),
-			expected: types.ExecConfig{
-				Detach: true,
-				Cmd:    []string{"command"},
+			options: execOptions{
+				detach: true,
 			},
+			execCmd: []string{"command"},
+		}: {
+			AttachStdin:  false,
+			AttachStdout: false,
+			AttachStderr: false,
+			Detach:       true,
+			Cmd:          []string{"command"},
 		},
 		{
-			options: withDefaultOpts(execOptions{
+			options: execOptions{
 				tty:         true,
 				interactive: true,
 				detach:      true,
-			}),
-			expected: types.ExecConfig{
-				Detach: true,
-				Tty:    true,
-				Cmd:    []string{"command"},
-			},
-		},
-		{
-			options:    withDefaultOpts(execOptions{detach: true}),
-			configFile: configfile.ConfigFile{DetachKeys: "de"},
-			expected: types.ExecConfig{
-				Cmd:        []string{"command"},
-				DetachKeys: "de",
-				Detach:     true,
-			},
-		},
-		{
-			options: withDefaultOpts(execOptions{
-				detach:     true,
-				detachKeys: "ab",
-			}),
-			configFile: configfile.ConfigFile{DetachKeys: "de"},
-			expected: types.ExecConfig{
-				Cmd:        []string{"command"},
-				DetachKeys: "ab",
-				Detach:     true,
 			},
+			execCmd: []string{"command"},
+		}: {
+			AttachStdin:  false,
+			AttachStdout: false,
+			AttachStderr: false,
+			Detach:       true,
+			Tty:          true,
+			Cmd:          []string{"command"},
 		},
 	}

-	for _, testcase := range testcases {
-		execConfig := parseExec(testcase.options, &testcase.configFile)
-		assert.Check(t, is.DeepEqual(testcase.expected, *execConfig))
-	}
-}
-
-func TestRunExec(t *testing.T) {
-	var testcases = []struct {
-		doc           string
-		options       execOptions
-		client        fakeClient
-		expectedError string
-		expectedOut   string
-		expectedErr   string
-	}{
-		{
-			doc: "successful detach",
-			options: withDefaultOpts(execOptions{
-				container: "thecontainer",
-				detach:    true,
-			}),
-			client: fakeClient{execCreateFunc: execCreateWithID},
-		},
-		{
-			doc:     "inspect error",
-			options: newExecOptions(),
-			client: fakeClient{
-				inspectFunc: func(string) (types.ContainerJSON, error) {
-					return types.ContainerJSON{}, errors.New("failed inspect")
-				},
-			},
-			expectedError: "failed inspect",
-		},
-		{
-			doc:           "missing exec ID",
-			options:       newExecOptions(),
-			expectedError: "exec ID empty",
-		},
-	}
-
-	for _, testcase := range testcases {
-		t.Run(testcase.doc, func(t *testing.T) {
-			cli := test.NewFakeCli(&testcase.client)
-
-			err := runExec(cli, testcase.options)
-			if testcase.expectedError != "" {
-				assert.ErrorContains(t, err, testcase.expectedError)
-			} else {
-				if !assert.Check(t, err) {
-					return
-				}
-			}
-			assert.Check(t, is.Equal(testcase.expectedOut, cli.OutBuffer().String()))
-			assert.Check(t, is.Equal(testcase.expectedErr, cli.ErrBuffer().String()))
-		})
-	}
-}
-
-func execCreateWithID(_ string, _ types.ExecConfig) (types.IDResponse, error) {
-	return types.IDResponse{ID: "execid"}, nil
-}
-
-func TestGetExecExitStatus(t *testing.T) {
-	execID := "the exec id"
-	expecatedErr := errors.New("unexpected error")
-
-	testcases := []struct {
-		inspectError  error
-		exitCode      int
-		expectedError error
-	}{
-		{
-			inspectError: nil,
-			exitCode:     0,
-		},
-		{
-			inspectError:  expecatedErr,
-			expectedError: expecatedErr,
-		},
-		{
-			exitCode:      15,
-			expectedError: cli.StatusError{StatusCode: 15},
-		},
-	}
-
-	for _, testcase := range testcases {
-		client := &fakeClient{
-			execInspectFunc: func(id string) (types.ContainerExecInspect, error) {
-				assert.Check(t, is.Equal(execID, id))
-				return types.ContainerExecInspect{ExitCode: testcase.exitCode}, testcase.inspectError
-			},
+	for valid, expectedExecConfig := range valids {
+		execConfig, err := parseExec(&valid.options, valid.execCmd)
+		require.NoError(t, err)
+		if !compareExecConfig(expectedExecConfig, execConfig) {
+			t.Fatalf("Expected [%v] for %v, got [%v]", expectedExecConfig, valid, execConfig)
 		}
-		err := getExecExitStatus(context.Background(), client, execID)
-		assert.Check(t, is.Equal(testcase.expectedError, err))
 	}
 }

+func compareExecConfig(config1 *types.ExecConfig, config2 *types.ExecConfig) bool {
+	if config1.AttachStderr != config2.AttachStderr {
+		return false
+	}
+	if config1.AttachStdin != config2.AttachStdin {
+		return false
+	}
+	if config1.AttachStdout != config2.AttachStdout {
+		return false
+	}
+	if config1.Detach != config2.Detach {
+		return false
+	}
+	if config1.Privileged != config2.Privileged {
+		return false
+	}
+	if config1.Tty != config2.Tty {
+		return false
+	}
+	if config1.User != config2.User {
+		return false
+	}
+	if len(config1.Cmd) != len(config2.Cmd) {
+		return false
+	}
+	for index, value := range config1.Cmd {
+		if value != config2.Cmd[index] {
+			return false
+		}
+	}
+	return true
+}
+
 func TestNewExecCommandErrors(t *testing.T) {
 	testCases := []struct {
 		name                 string
@ -218,10 +135,10 @@ func TestNewExecCommandErrors(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{inspectFunc: tc.containerInspectFunc})
+		cli := test.NewFakeCli(&fakeClient{containerInspectFunc: tc.containerInspectFunc})
 		cmd := NewExecCommand(cli)
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
--- a/components/cli/cli/command/container/export.go
+++ b/components/cli/cli/command/container/export.go
@ -16,7 +16,7 @@ type exportOptions struct {
 }

 // NewExportCommand creates a new `docker export` command
-func NewExportCommand(dockerCli command.Cli) *cobra.Command {
+func NewExportCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts exportOptions

 	cmd := &cobra.Command{
@ -36,7 +36,7 @@ func NewExportCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runExport(dockerCli command.Cli, opts exportOptions) error {
+func runExport(dockerCli *command.DockerCli, opts exportOptions) error {
 	if opts.output == "" && dockerCli.Out().IsTerminal() {
 		return errors.New("cowardly refusing to save to a terminal. Use the -o flag or redirect")
 	}
--- a/components/cli/cli/command/container/hijack.go
+++ b/components/cli/cli/command/container/hijack.go
@ -6,12 +6,12 @@ import (
 	"runtime"
 	"sync"

+	"github.com/Sirupsen/logrus"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/ioutils"
 	"github.com/docker/docker/pkg/stdcopy"
 	"github.com/docker/docker/pkg/term"
-	"github.com/sirupsen/logrus"
 	"golang.org/x/net/context"
 )

@ -185,7 +185,6 @@ func setRawTerminal(streams command.Streams) error {
 	return streams.Out().SetRawTerminal()
 }

-// nolint: unparam
 func restoreTerminal(streams command.Streams, in io.Closer) error {
 	streams.In().RestoreTerminal()
 	streams.Out().RestoreTerminal()
--- a/components/cli/cli/command/container/inspect.go
+++ b/components/cli/cli/command/container/inspect.go
@ -15,7 +15,7 @@ type inspectOptions struct {
 }

 // newInspectCommand creates a new cobra.Command for `docker container inspect`
-func newInspectCommand(dockerCli command.Cli) *cobra.Command {
+func newInspectCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts inspectOptions

 	cmd := &cobra.Command{
@ -35,7 +35,7 @@ func newInspectCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runInspect(dockerCli command.Cli, opts inspectOptions) error {
+func runInspect(dockerCli *command.DockerCli, opts inspectOptions) error {
 	client := dockerCli.Client()
 	ctx := context.Background()

--- a/components/cli/cli/command/container/kill.go
+++ b/components/cli/cli/command/container/kill.go
@ -18,7 +18,7 @@ type killOptions struct {
 }

 // NewKillCommand creates a new cobra.Command for `docker kill`
-func NewKillCommand(dockerCli command.Cli) *cobra.Command {
+func NewKillCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts killOptions

 	cmd := &cobra.Command{
@ -36,7 +36,7 @@ func NewKillCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runKill(dockerCli command.Cli, opts *killOptions) error {
+func runKill(dockerCli *command.DockerCli, opts *killOptions) error {
 	var errs []string
 	ctx := context.Background()
 	errChan := parallelOperation(ctx, opts.containers, func(ctx context.Context, container string) error {
--- a/components/cli/cli/command/container/list.go
+++ b/components/cli/cli/command/container/list.go
@ -7,8 +7,8 @@ import (
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/cli/command/formatter"
 	"github.com/docker/cli/opts"
-	"github.com/docker/cli/templates"
 	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/pkg/templates"
 	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
 )
@ -25,7 +25,7 @@ type psOptions struct {
 }

 // NewPsCommand creates a new cobra.Command for `docker ps`
-func NewPsCommand(dockerCli command.Cli) *cobra.Command {
+func NewPsCommand(dockerCli *command.DockerCli) *cobra.Command {
 	options := psOptions{filter: opts.NewFilterOpt()}

 	cmd := &cobra.Command{
@ -51,7 +51,7 @@ func NewPsCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func newListCommand(dockerCli command.Cli) *cobra.Command {
+func newListCommand(dockerCli *command.DockerCli) *cobra.Command {
 	cmd := *NewPsCommand(dockerCli)
 	cmd.Aliases = []string{"ps", "list"}
 	cmd.Use = "ls [OPTIONS]"
@ -109,7 +109,7 @@ func buildContainerListOptions(opts *psOptions) (*types.ContainerListOptions, er
 	return options, nil
 }

-func runPs(dockerCli command.Cli, options *psOptions) error {
+func runPs(dockerCli *command.DockerCli, options *psOptions) error {
 	ctx := context.Background()

 	listOptions, err := buildContainerListOptions(options)
--- a/components/cli/cli/command/container/list_test.go
+++ b/components/cli/cli/command/container/list_test.go
@ -1,164 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"io/ioutil"
-	"testing"
-
-	"github.com/docker/cli/cli/config/configfile"
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/docker/api/types"
-	// Import builders to get the builder function as package function
-	. "github.com/docker/cli/internal/test/builders"
-	"github.com/gotestyourself/gotestyourself/assert"
-	"github.com/gotestyourself/gotestyourself/golden"
-)
-
-func TestContainerListErrors(t *testing.T) {
-	testCases := []struct {
-		args              []string
-		flags             map[string]string
-		containerListFunc func(types.ContainerListOptions) ([]types.Container, error)
-		expectedError     string
-	}{
-		{
-			flags: map[string]string{
-				"format": "{{invalid}}",
-			},
-			expectedError: `function "invalid" not defined`,
-		},
-		{
-			flags: map[string]string{
-				"format": "{{join}}",
-			},
-			expectedError: `wrong number of args for join`,
-		},
-		{
-			containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-				return nil, fmt.Errorf("error listing containers")
-			},
-			expectedError: "error listing containers",
-		},
-	}
-	for _, tc := range testCases {
-		cmd := newListCommand(
-			test.NewFakeCli(&fakeClient{
-				containerListFunc: tc.containerListFunc,
-			}),
-		)
-		cmd.SetArgs(tc.args)
-		for key, value := range tc.flags {
-			cmd.Flags().Set(key, value)
-		}
-		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
-	}
-}
-
-func TestContainerListWithoutFormat(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1"),
-				*Container("c2", WithName("foo")),
-				*Container("c3", WithPort(80, 80, TCP), WithPort(81, 81, TCP), WithPort(82, 82, TCP)),
-				*Container("c4", WithPort(81, 81, UDP)),
-				*Container("c5", WithPort(82, 82, IP("8.8.8.8"), TCP)),
-			}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-without-format.golden")
-}
-
-func TestContainerListNoTrunc(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1"),
-				*Container("c2", WithName("foo/bar")),
-			}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	cmd.Flags().Set("no-trunc", "true")
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-without-format-no-trunc.golden")
-}
-
-// Test for GitHub issue docker/docker#21772
-func TestContainerListNamesMultipleTime(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1"),
-				*Container("c2", WithName("foo/bar")),
-			}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	cmd.Flags().Set("format", "{{.Names}} {{.Names}}")
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-format-name-name.golden")
-}
-
-// Test for GitHub issue docker/docker#30291
-func TestContainerListFormatTemplateWithArg(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1", WithLabel("some.label", "value")),
-				*Container("c2", WithName("foo/bar"), WithLabel("foo", "bar")),
-			}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	cmd.Flags().Set("format", `{{.Names}} {{.Label "some.label"}}`)
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-format-with-arg.golden")
-}
-
-func TestContainerListFormatSizeSetsOption(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(options types.ContainerListOptions) ([]types.Container, error) {
-			assert.Check(t, options.Size)
-			return []types.Container{}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	cmd.Flags().Set("format", `{{.Size}}`)
-	assert.NilError(t, cmd.Execute())
-}
-
-func TestContainerListWithConfigFormat(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1", WithLabel("some.label", "value")),
-				*Container("c2", WithName("foo/bar"), WithLabel("foo", "bar")),
-			}, nil
-		},
-	})
-	cli.SetConfigFile(&configfile.ConfigFile{
-		PsFormat: "{{ .Names }} {{ .Image }} {{ .Labels }}",
-	})
-	cmd := newListCommand(cli)
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-with-config-format.golden")
-}
-
-func TestContainerListWithFormat(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1", WithLabel("some.label", "value")),
-				*Container("c2", WithName("foo/bar"), WithLabel("foo", "bar")),
-			}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	cmd.Flags().Set("format", "{{ .Names }} {{ .Image }} {{ .Labels }}")
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-with-format.golden")
-}
--- a/components/cli/cli/command/container/logs.go
+++ b/components/cli/cli/command/container/logs.go
@ -14,7 +14,6 @@ import (
 type logsOptions struct {
 	follow     bool
 	since      string
-	until      string
 	timestamps bool
 	details    bool
 	tail       string
@ -23,7 +22,7 @@ type logsOptions struct {
 }

 // NewLogsCommand creates a new cobra.Command for `docker logs`
-func NewLogsCommand(dockerCli command.Cli) *cobra.Command {
+func NewLogsCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts logsOptions

 	cmd := &cobra.Command{
@ -39,22 +38,19 @@ func NewLogsCommand(dockerCli command.Cli) *cobra.Command {
 	flags := cmd.Flags()
 	flags.BoolVarP(&opts.follow, "follow", "f", false, "Follow log output")
 	flags.StringVar(&opts.since, "since", "", "Show logs since timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)")
-	flags.StringVar(&opts.until, "until", "", "Show logs before a timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)")
-	flags.SetAnnotation("until", "version", []string{"1.35"})
 	flags.BoolVarP(&opts.timestamps, "timestamps", "t", false, "Show timestamps")
 	flags.BoolVar(&opts.details, "details", false, "Show extra details provided to logs")
 	flags.StringVar(&opts.tail, "tail", "all", "Number of lines to show from the end of the logs")
 	return cmd
 }

-func runLogs(dockerCli command.Cli, opts *logsOptions) error {
+func runLogs(dockerCli *command.DockerCli, opts *logsOptions) error {
 	ctx := context.Background()

 	options := types.ContainerLogsOptions{
 		ShowStdout: true,
 		ShowStderr: true,
 		Since:      opts.since,
-		Until:      opts.until,
 		Timestamps: opts.timestamps,
 		Follow:     opts.follow,
 		Tail:       opts.tail,
--- a/components/cli/cli/command/container/logs_test.go
+++ b/components/cli/cli/command/container/logs_test.go
@ -1,62 +0,0 @@
-package container
-
-import (
-	"io"
-	"io/ioutil"
-	"strings"
-	"testing"
-
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-)
-
-var logFn = func(expectedOut string) func(string, types.ContainerLogsOptions) (io.ReadCloser, error) {
-	return func(container string, opts types.ContainerLogsOptions) (io.ReadCloser, error) {
-		return ioutil.NopCloser(strings.NewReader(expectedOut)), nil
-	}
-}
-
-func TestRunLogs(t *testing.T) {
-	inspectFn := func(containerID string) (types.ContainerJSON, error) {
-		return types.ContainerJSON{
-			Config:            &container.Config{Tty: true},
-			ContainerJSONBase: &types.ContainerJSONBase{State: &types.ContainerState{Running: false}},
-		}, nil
-	}
-
-	var testcases = []struct {
-		doc           string
-		options       *logsOptions
-		client        fakeClient
-		expectedError string
-		expectedOut   string
-		expectedErr   string
-	}{
-		{
-			doc:         "successful logs",
-			expectedOut: "foo",
-			options:     &logsOptions{},
-			client:      fakeClient{logFunc: logFn("foo"), inspectFunc: inspectFn},
-		},
-	}
-
-	for _, testcase := range testcases {
-		t.Run(testcase.doc, func(t *testing.T) {
-			cli := test.NewFakeCli(&testcase.client)
-
-			err := runLogs(cli, testcase.options)
-			if testcase.expectedError != "" {
-				assert.ErrorContains(t, err, testcase.expectedError)
-			} else {
-				if !assert.Check(t, err) {
-					return
-				}
-			}
-			assert.Check(t, is.Equal(testcase.expectedOut, cli.OutBuffer().String()))
-			assert.Check(t, is.Equal(testcase.expectedErr, cli.ErrBuffer().String()))
-		})
-	}
-}
--- a/components/cli/cli/command/container/opts.go
+++ b/components/cli/cli/command/container/opts.go
@ -11,6 +11,7 @@ import (
 	"strings"
 	"time"

+	"github.com/Sirupsen/logrus"
 	"github.com/docker/cli/cli/compose/loader"
 	"github.com/docker/cli/opts"
 	"github.com/docker/docker/api/types/container"
@ -19,7 +20,6 @@ import (
 	"github.com/docker/docker/pkg/signal"
 	"github.com/docker/go-connections/nat"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
 )

@ -145,7 +145,7 @@ func addFlags(flags *pflag.FlagSet) *containerOptions {
 		expose:            opts.NewListOpts(nil),
 		extraHosts:        opts.NewListOpts(opts.ValidateExtraHost),
 		groupAdd:          opts.NewListOpts(nil),
-		labels:            opts.NewListOpts(nil),
+		labels:            opts.NewListOpts(opts.ValidateEnv),
 		labelsFile:        opts.NewListOpts(nil),
 		linkLocalIPs:      opts.NewListOpts(nil),
 		links:             opts.NewListOpts(opts.ValidateLink),
@ -274,7 +274,7 @@ func addFlags(flags *pflag.FlagSet) *containerOptions {

 	// Low-level execution (cgroups, namespaces, ...)
 	flags.StringVar(&copts.cgroupParent, "cgroup-parent", "", "Optional parent cgroup for the container")
-	flags.StringVar(&copts.ipcMode, "ipc", "", "IPC mode to use")
+	flags.StringVar(&copts.ipcMode, "ipc", "", "IPC namespace to use")
 	flags.StringVar(&copts.isolation, "isolation", "", "Container isolation technology")
 	flags.StringVar(&copts.pidMode, "pid", "", "PID namespace to use")
 	flags.Var(&copts.shmSize, "shm-size", "Size of /dev/shm")
@ -410,7 +410,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions) (*containerConfig, err
 	}

 	// collect all the environment variables for the container
-	envVariables, err := opts.ReadKVEnvStrings(copts.envFile.GetAll(), copts.env.GetAll())
+	envVariables, err := opts.ReadKVStrings(copts.envFile.GetAll(), copts.env.GetAll())
 	if err != nil {
 		return nil, err
 	}
@ -421,6 +421,11 @@ func parse(flags *pflag.FlagSet, copts *containerOptions) (*containerConfig, err
 		return nil, err
 	}

+	ipcMode := container.IpcMode(copts.ipcMode)
+	if !ipcMode.Valid() {
+		return nil, errors.Errorf("--ipc: invalid IPC mode")
+	}
+
 	pidMode := container.PidMode(copts.pidMode)
 	if !pidMode.Valid() {
 		return nil, errors.Errorf("--pid: invalid PID mode")
@ -579,7 +584,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions) (*containerConfig, err
 		ExtraHosts:     copts.extraHosts.GetAll(),
 		VolumesFrom:    copts.volumesFrom.GetAll(),
 		NetworkMode:    container.NetworkMode(copts.netMode),
-		IpcMode:        container.IpcMode(copts.ipcMode),
+		IpcMode:        ipcMode,
 		PidMode:        pidMode,
 		UTSMode:        utsMode,
 		UsernsMode:     usernsMode,
--- a/components/cli/cli/command/container/opts_test.go
+++ b/components/cli/cli/command/container/opts_test.go
@ -1,6 +1,8 @@
 package container

 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"os"
@ -11,11 +13,13 @@ import (

 	"github.com/docker/docker/api/types/container"
 	networktypes "github.com/docker/docker/api/types/network"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/docker/docker/runconfig"
 	"github.com/docker/go-connections/nat"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 func TestValidateAttach(t *testing.T) {
@ -42,9 +46,11 @@ func TestValidateAttach(t *testing.T) {
 	}
 }

-// nolint: unparam
 func parseRun(args []string) (*container.Config, *container.HostConfig, *networktypes.NetworkingConfig, error) {
-	flags, copts := setupRunFlags()
+	flags := pflag.NewFlagSet("run", pflag.ContinueOnError)
+	flags.SetOutput(ioutil.Discard)
+	flags.Usage = nil
+	copts := addFlags(flags)
 	if err := flags.Parse(args); err != nil {
 		return nil, nil, nil, err
 	}
@ -56,22 +62,14 @@ func parseRun(args []string) (*container.Config, *container.HostConfig, *network
 	return containerConfig.Config, containerConfig.HostConfig, containerConfig.NetworkingConfig, err
 }

-func setupRunFlags() (*pflag.FlagSet, *containerOptions) {
-	flags := pflag.NewFlagSet("run", pflag.ContinueOnError)
-	flags.SetOutput(ioutil.Discard)
-	flags.Usage = nil
-	copts := addFlags(flags)
-	return flags, copts
-}
-
 func parseMustError(t *testing.T, args string) {
 	_, _, _, err := parseRun(strings.Split(args+" ubuntu bash", " "))
-	assert.ErrorContains(t, err, "", args)
+	assert.Error(t, err, args)
 }

 func mustParse(t *testing.T, args string) (*container.Config, *container.HostConfig) {
 	config, hostConfig, _, err := parseRun(append(strings.Split(args, " "), "ubuntu", "bash"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 	return config, hostConfig
 }

@ -117,7 +115,7 @@ func TestParseRunWithInvalidArgs(t *testing.T) {
 }

 // nolint: gocyclo
-func TestParseWithVolumes(t *testing.T) {
+func TestParseRunVolumes(t *testing.T) {

 	// A single volume
 	arr, tryit := setupPlatformVolume([]string{`/tmp`}, []string{`c:\tmp`})
@ -137,19 +135,19 @@ func TestParseWithVolumes(t *testing.T) {
 		t.Fatalf("Error parsing volume flags, %s is missing from volumes. Received %v", arr[1], config.Volumes)
 	}

-	// A single bind mount
+	// A single bind-mount
 	arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp`}, []string{os.Getenv("TEMP") + `:c:\containerTmp`})
 	if config, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || hostConfig.Binds[0] != arr[0] {
 		t.Fatalf("Error parsing volume flags, %q should mount-bind the path before the colon into the path after the colon. Received %v %v", arr[0], hostConfig.Binds, config.Volumes)
 	}

-	// Two bind mounts.
+	// Two bind-mounts.
 	arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp`, `/hostVar:/containerVar`}, []string{os.Getenv("ProgramData") + `:c:\ContainerPD`, os.Getenv("TEMP") + `:c:\containerTmp`})
 	if _, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || compareRandomizedStrings(hostConfig.Binds[0], hostConfig.Binds[1], arr[0], arr[1]) != nil {
 		t.Fatalf("Error parsing volume flags, `%s and %s` did not mount-bind correctly. Received %v", arr[0], arr[1], hostConfig.Binds)
 	}

-	// Two bind mounts, first read-only, second read-write.
+	// Two bind-mounts, first read-only, second read-write.
 	// TODO Windows: The Windows version uses read-write as that's the only mode it supports. Can change this post TP4
 	arr, tryit = setupPlatformVolume(
 		[]string{`/hostTmp:/containerTmp:ro`, `/hostVar:/containerVar:rw`},
@ -231,27 +229,26 @@ func TestParseWithMacAddress(t *testing.T) {
 	}
 }

-func TestRunFlagsParseWithMemory(t *testing.T) {
-	flags, _ := setupRunFlags()
-	args := []string{"--memory=invalid", "img", "cmd"}
-	err := flags.Parse(args)
-	assert.ErrorContains(t, err, `invalid argument "invalid" for "-m, --memory" flag`)
+func TestParseWithMemory(t *testing.T) {
+	invalidMemory := "--memory=invalid"
+	_, _, _, err := parseRun([]string{invalidMemory, "img", "cmd"})
+	testutil.ErrorContains(t, err, invalidMemory)

 	_, hostconfig := mustParse(t, "--memory=1G")
-	assert.Check(t, is.Equal(int64(1073741824), hostconfig.Memory))
+	assert.Equal(t, int64(1073741824), hostconfig.Memory)
 }

 func TestParseWithMemorySwap(t *testing.T) {
-	flags, _ := setupRunFlags()
-	args := []string{"--memory-swap=invalid", "img", "cmd"}
-	err := flags.Parse(args)
-	assert.ErrorContains(t, err, `invalid argument "invalid" for "--memory-swap" flag`)
+	invalidMemory := "--memory-swap=invalid"
+
+	_, _, _, err := parseRun([]string{invalidMemory, "img", "cmd"})
+	testutil.ErrorContains(t, err, invalidMemory)

 	_, hostconfig := mustParse(t, "--memory-swap=1G")
-	assert.Check(t, is.Equal(int64(1073741824), hostconfig.MemorySwap))
+	assert.Equal(t, int64(1073741824), hostconfig.MemorySwap)

 	_, hostconfig = mustParse(t, "--memory-swap=-1")
-	assert.Check(t, is.Equal(int64(-1), hostconfig.MemorySwap))
+	assert.Equal(t, int64(-1), hostconfig.MemorySwap)
 }

 func TestParseHostname(t *testing.T) {
@ -369,43 +366,47 @@ func TestParseDevice(t *testing.T) {
 }

 func TestParseModes(t *testing.T) {
+	// ipc ko
+	_, _, _, err := parseRun([]string{"--ipc=container:", "img", "cmd"})
+	testutil.ErrorContains(t, err, "--ipc: invalid IPC mode")
+
+	// ipc ok
+	_, hostconfig, _, err := parseRun([]string{"--ipc=host", "img", "cmd"})
+	require.NoError(t, err)
+	if !hostconfig.IpcMode.Valid() {
+		t.Fatalf("Expected a valid IpcMode, got %v", hostconfig.IpcMode)
+	}
+
 	// pid ko
-	flags, copts := setupRunFlags()
-	args := []string{"--pid=container:", "img", "cmd"}
-	assert.NilError(t, flags.Parse(args))
-	_, err := parse(flags, copts)
-	assert.ErrorContains(t, err, "--pid: invalid PID mode")
+	_, _, _, err = parseRun([]string{"--pid=container:", "img", "cmd"})
+	testutil.ErrorContains(t, err, "--pid: invalid PID mode")

 	// pid ok
-	_, hostconfig, _, err := parseRun([]string{"--pid=host", "img", "cmd"})
-	assert.NilError(t, err)
+	_, hostconfig, _, err = parseRun([]string{"--pid=host", "img", "cmd"})
+	require.NoError(t, err)
 	if !hostconfig.PidMode.Valid() {
 		t.Fatalf("Expected a valid PidMode, got %v", hostconfig.PidMode)
 	}

 	// uts ko
 	_, _, _, err = parseRun([]string{"--uts=container:", "img", "cmd"})
-	assert.ErrorContains(t, err, "--uts: invalid UTS mode")
+	testutil.ErrorContains(t, err, "--uts: invalid UTS mode")

 	// uts ok
 	_, hostconfig, _, err = parseRun([]string{"--uts=host", "img", "cmd"})
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	if !hostconfig.UTSMode.Valid() {
 		t.Fatalf("Expected a valid UTSMode, got %v", hostconfig.UTSMode)
 	}
-}

-func TestRunFlagsParseShmSize(t *testing.T) {
 	// shm-size ko
-	flags, _ := setupRunFlags()
-	args := []string{"--shm-size=a128m", "img", "cmd"}
-	expectedErr := `invalid argument "a128m" for "--shm-size" flag: invalid size: 'a128m'`
-	err := flags.Parse(args)
-	assert.ErrorContains(t, err, expectedErr)
+	expectedErr := `invalid argument "a128m" for --shm-size=a128m: invalid size: 'a128m'`
+	_, _, _, err = parseRun([]string{"--shm-size=a128m", "img", "cmd"})
+	testutil.ErrorContains(t, err, expectedErr)

 	// shm-size ok
-	_, hostconfig, _, err := parseRun([]string{"--shm-size=128m", "img", "cmd"})
-	assert.NilError(t, err)
+	_, hostconfig, _, err = parseRun([]string{"--shm-size=128m", "img", "cmd"})
+	require.NoError(t, err)
 	if hostconfig.ShmSize != 134217728 {
 		t.Fatalf("Expected a valid ShmSize, got %d", hostconfig.ShmSize)
 	}
@ -594,6 +595,161 @@ func TestParseEntryPoint(t *testing.T) {
 	}
 }

+// This tests the cases for binds which are generated through
+// DecodeContainerConfig rather than Parse()
+// nolint: gocyclo
+func TestDecodeContainerConfigVolumes(t *testing.T) {
+
+	// Root to root
+	bindsOrVols, _ := setupPlatformVolume([]string{`/:/`}, []string{os.Getenv("SystemDrive") + `\:c:\`})
+	if _, _, err := callDecodeContainerConfig(nil, bindsOrVols); err == nil {
+		t.Fatalf("binds %v should have failed", bindsOrVols)
+	}
+	if _, _, err := callDecodeContainerConfig(bindsOrVols, nil); err == nil {
+		t.Fatalf("volume %v should have failed", bindsOrVols)
+	}
+
+	// No destination path
+	bindsOrVols, _ = setupPlatformVolume([]string{`/tmp:`}, []string{os.Getenv("TEMP") + `\:`})
+	if _, _, err := callDecodeContainerConfig(nil, bindsOrVols); err == nil {
+		t.Fatalf("binds %v should have failed", bindsOrVols)
+	}
+	if _, _, err := callDecodeContainerConfig(bindsOrVols, nil); err == nil {
+		t.Fatalf("volume %v should have failed", bindsOrVols)
+	}
+
+	//	// No destination path or mode
+	bindsOrVols, _ = setupPlatformVolume([]string{`/tmp::`}, []string{os.Getenv("TEMP") + `\::`})
+	if _, _, err := callDecodeContainerConfig(nil, bindsOrVols); err == nil {
+		t.Fatalf("binds %v should have failed", bindsOrVols)
+	}
+	if _, _, err := callDecodeContainerConfig(bindsOrVols, nil); err == nil {
+		t.Fatalf("volume %v should have failed", bindsOrVols)
+	}
+
+	// A whole lot of nothing
+	bindsOrVols = []string{`:`}
+	if _, _, err := callDecodeContainerConfig(nil, bindsOrVols); err == nil {
+		t.Fatalf("binds %v should have failed", bindsOrVols)
+	}
+	if _, _, err := callDecodeContainerConfig(bindsOrVols, nil); err == nil {
+		t.Fatalf("volume %v should have failed", bindsOrVols)
+	}
+
+	// A whole lot of nothing with no mode
+	bindsOrVols = []string{`::`}
+	if _, _, err := callDecodeContainerConfig(nil, bindsOrVols); err == nil {
+		t.Fatalf("binds %v should have failed", bindsOrVols)
+	}
+	if _, _, err := callDecodeContainerConfig(bindsOrVols, nil); err == nil {
+		t.Fatalf("volume %v should have failed", bindsOrVols)
+	}
+
+	// Too much including an invalid mode
+	wTmp := os.Getenv("TEMP")
+	bindsOrVols, _ = setupPlatformVolume([]string{`/tmp:/tmp:/tmp:/tmp`}, []string{wTmp + ":" + wTmp + ":" + wTmp + ":" + wTmp})
+	if _, _, err := callDecodeContainerConfig(nil, bindsOrVols); err == nil {
+		t.Fatalf("binds %v should have failed", bindsOrVols)
+	}
+	if _, _, err := callDecodeContainerConfig(bindsOrVols, nil); err == nil {
+		t.Fatalf("volume %v should have failed", bindsOrVols)
+	}
+
+	// Windows specific error tests
+	if runtime.GOOS == "windows" {
+		// Volume which does not include a drive letter
+		bindsOrVols = []string{`\tmp`}
+		if _, _, err := callDecodeContainerConfig(nil, bindsOrVols); err == nil {
+			t.Fatalf("binds %v should have failed", bindsOrVols)
+		}
+		if _, _, err := callDecodeContainerConfig(bindsOrVols, nil); err == nil {
+			t.Fatalf("volume %v should have failed", bindsOrVols)
+		}
+
+		// Root to C-Drive
+		bindsOrVols = []string{os.Getenv("SystemDrive") + `\:c:`}
+		if _, _, err := callDecodeContainerConfig(nil, bindsOrVols); err == nil {
+			t.Fatalf("binds %v should have failed", bindsOrVols)
+		}
+		if _, _, err := callDecodeContainerConfig(bindsOrVols, nil); err == nil {
+			t.Fatalf("volume %v should have failed", bindsOrVols)
+		}
+
+		// Container path that does not include a drive letter
+		bindsOrVols = []string{`c:\windows:\somewhere`}
+		if _, _, err := callDecodeContainerConfig(nil, bindsOrVols); err == nil {
+			t.Fatalf("binds %v should have failed", bindsOrVols)
+		}
+		if _, _, err := callDecodeContainerConfig(bindsOrVols, nil); err == nil {
+			t.Fatalf("volume %v should have failed", bindsOrVols)
+		}
+	}
+
+	// Linux-specific error tests
+	if runtime.GOOS != "windows" {
+		// Just root
+		bindsOrVols = []string{`/`}
+		if _, _, err := callDecodeContainerConfig(nil, bindsOrVols); err == nil {
+			t.Fatalf("binds %v should have failed", bindsOrVols)
+		}
+		if _, _, err := callDecodeContainerConfig(bindsOrVols, nil); err == nil {
+			t.Fatalf("volume %v should have failed", bindsOrVols)
+		}
+
+		// A single volume that looks like a bind mount passed in Volumes.
+		// This should be handled as a bind mount, not a volume.
+		vols := []string{`/foo:/bar`}
+		if config, hostConfig, err := callDecodeContainerConfig(vols, nil); err != nil {
+			t.Fatal("Volume /foo:/bar should have succeeded as a volume name")
+		} else if hostConfig.Binds != nil {
+			t.Fatalf("Error parsing volume flags, /foo:/bar should not mount-bind anything. Received %v", hostConfig.Binds)
+		} else if _, exists := config.Volumes[vols[0]]; !exists {
+			t.Fatalf("Error parsing volume flags, /foo:/bar is missing from volumes. Received %v", config.Volumes)
+		}
+
+	}
+}
+
+// callDecodeContainerConfig is a utility function used by TestDecodeContainerConfigVolumes
+// to call DecodeContainerConfig. It effectively does what a client would
+// do when calling the daemon by constructing a JSON stream of a
+// ContainerConfigWrapper which is populated by the set of volume specs
+// passed into it. It returns a config and a hostconfig which can be
+// validated to ensure DecodeContainerConfig has manipulated the structures
+// correctly.
+func callDecodeContainerConfig(volumes []string, binds []string) (*container.Config, *container.HostConfig, error) {
+	var (
+		b   []byte
+		err error
+		c   *container.Config
+		h   *container.HostConfig
+	)
+	w := runconfig.ContainerConfigWrapper{
+		Config: &container.Config{
+			Volumes: map[string]struct{}{},
+		},
+		HostConfig: &container.HostConfig{
+			NetworkMode: "none",
+			Binds:       binds,
+		},
+	}
+	for _, v := range volumes {
+		w.Config.Volumes[v] = struct{}{}
+	}
+	if b, err = json.Marshal(w); err != nil {
+		return nil, nil, errors.Errorf("Error on marshal %s", err.Error())
+	}
+	c, h, _, err = runconfig.DecodeContainerConfig(bytes.NewReader(b))
+	if err != nil {
+		return nil, nil, errors.Errorf("Error parsing %s: %v", string(b), err)
+	}
+	if c == nil || h == nil {
+		return nil, nil, errors.Errorf("Empty config or hostconfig")
+	}
+
+	return c, h, err
+}
+
 func TestValidateDevice(t *testing.T) {
 	valid := []string{
 		"/home",
--- a/components/cli/cli/command/container/pause.go
+++ b/components/cli/cli/command/container/pause.go
@ -16,7 +16,7 @@ type pauseOptions struct {
 }

 // NewPauseCommand creates a new cobra.Command for `docker pause`
-func NewPauseCommand(dockerCli command.Cli) *cobra.Command {
+func NewPauseCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts pauseOptions

 	return &cobra.Command{
@ -30,7 +30,7 @@ func NewPauseCommand(dockerCli command.Cli) *cobra.Command {
 	}
 }

-func runPause(dockerCli command.Cli, opts *pauseOptions) error {
+func runPause(dockerCli *command.DockerCli, opts *pauseOptions) error {
 	ctx := context.Background()

 	var errs []string
--- a/components/cli/cli/command/container/port.go
+++ b/components/cli/cli/command/container/port.go
@ -19,7 +19,7 @@ type portOptions struct {
 }

 // NewPortCommand creates a new cobra.Command for `docker port`
-func NewPortCommand(dockerCli command.Cli) *cobra.Command {
+func NewPortCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts portOptions

 	cmd := &cobra.Command{
@ -37,7 +37,7 @@ func NewPortCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runPort(dockerCli command.Cli, opts *portOptions) error {
+func runPort(dockerCli *command.DockerCli, opts *portOptions) error {
 	ctx := context.Background()

 	c, err := dockerCli.Client().ContainerInspect(ctx, opts.container)
--- a/components/cli/cli/command/container/prune.go
+++ b/components/cli/cli/command/container/prune.go
@ -35,7 +35,7 @@ func NewPruneCommand(dockerCli command.Cli) *cobra.Command {
 			fmt.Fprintln(dockerCli.Out(), "Total reclaimed space:", units.HumanSize(float64(spaceReclaimed)))
 			return nil
 		},
-		Annotations: map[string]string{"version": "1.25"},
+		Tags: map[string]string{"version": "1.25"},
 	}

 	flags := cmd.Flags()
@ -52,12 +52,12 @@ func runPrune(dockerCli command.Cli, options pruneOptions) (spaceReclaimed uint6
 	pruneFilters := command.PruneFilters(dockerCli, options.filter.Value())

 	if !options.force && !command.PromptForConfirmation(dockerCli.In(), dockerCli.Out(), warning) {
-		return 0, "", nil
+		return
 	}

 	report, err := dockerCli.Client().ContainersPrune(context.Background(), pruneFilters)
 	if err != nil {
-		return 0, "", err
+		return
 	}

 	if len(report.ContainersDeleted) > 0 {
@ -68,7 +68,7 @@ func runPrune(dockerCli command.Cli, options pruneOptions) (spaceReclaimed uint6
 		spaceReclaimed = report.SpaceReclaimed
 	}

-	return spaceReclaimed, output, nil
+	return
 }

 // RunPrune calls the Container Prune API
--- a/components/cli/cli/command/container/ps_test.go
+++ b/components/cli/cli/command/container/ps_test.go
@ -4,14 +4,13 @@ import (
 	"testing"

 	"github.com/docker/cli/opts"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )

 func TestBuildContainerListOptions(t *testing.T) {
 	filters := opts.NewFilterOpt()
-	assert.NilError(t, filters.Set("foo=bar"))
-	assert.NilError(t, filters.Set("baz=foo"))
+	assert.NoError(t, filters.Set("foo=bar"))
+	assert.NoError(t, filters.Set("baz=foo"))

 	contexts := []struct {
 		psOpts          *psOptions
@ -102,12 +101,12 @@ func TestBuildContainerListOptions(t *testing.T) {

 	for _, c := range contexts {
 		options, err := buildContainerListOptions(c.psOpts)
-		assert.NilError(t, err)
+		assert.NoError(t, err)

-		assert.Check(t, is.Equal(c.expectedAll, options.All))
-		assert.Check(t, is.Equal(c.expectedSize, options.Size))
-		assert.Check(t, is.Equal(c.expectedLimit, options.Limit))
-		assert.Check(t, is.Equal(len(c.expectedFilters), options.Filters.Len()))
+		assert.Equal(t, c.expectedAll, options.All)
+		assert.Equal(t, c.expectedSize, options.Size)
+		assert.Equal(t, c.expectedLimit, options.Limit)
+		assert.Equal(t, len(c.expectedFilters), options.Filters.Len())

 		for k, v := range c.expectedFilters {
 			f := options.Filters
--- a/components/cli/cli/command/container/rename.go
+++ b/components/cli/cli/command/container/rename.go
@ -17,7 +17,7 @@ type renameOptions struct {
 }

 // NewRenameCommand creates a new cobra.Command for `docker rename`
-func NewRenameCommand(dockerCli command.Cli) *cobra.Command {
+func NewRenameCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts renameOptions

 	cmd := &cobra.Command{
@ -33,7 +33,7 @@ func NewRenameCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runRename(dockerCli command.Cli, opts *renameOptions) error {
+func runRename(dockerCli *command.DockerCli, opts *renameOptions) error {
 	ctx := context.Background()

 	oldName := strings.TrimSpace(opts.oldName)
--- a/components/cli/cli/command/container/restart.go
+++ b/components/cli/cli/command/container/restart.go
@ -20,7 +20,7 @@ type restartOptions struct {
 }

 // NewRestartCommand creates a new cobra.Command for `docker restart`
-func NewRestartCommand(dockerCli command.Cli) *cobra.Command {
+func NewRestartCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts restartOptions

 	cmd := &cobra.Command{
@ -39,7 +39,7 @@ func NewRestartCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runRestart(dockerCli command.Cli, opts *restartOptions) error {
+func runRestart(dockerCli *command.DockerCli, opts *restartOptions) error {
 	ctx := context.Background()
 	var errs []string
 	var timeout *time.Duration
--- a/components/cli/cli/command/container/rm.go
+++ b/components/cli/cli/command/container/rm.go
@ -21,7 +21,7 @@ type rmOptions struct {
 }

 // NewRmCommand creates a new cobra.Command for `docker rm`
-func NewRmCommand(dockerCli command.Cli) *cobra.Command {
+func NewRmCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts rmOptions

 	cmd := &cobra.Command{
@ -41,7 +41,7 @@ func NewRmCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runRm(dockerCli command.Cli, opts *rmOptions) error {
+func runRm(dockerCli *command.DockerCli, opts *rmOptions) error {
 	ctx := context.Background()

 	var errs []string
--- a/components/cli/cli/command/container/run.go
+++ b/components/cli/cli/command/container/run.go
@ -10,29 +10,30 @@ import (
 	"strings"
 	"syscall"

+	"github.com/Sirupsen/logrus"
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/opts"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/pkg/promise"
 	"github.com/docker/docker/pkg/signal"
 	"github.com/docker/docker/pkg/term"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"golang.org/x/net/context"
 )

 type runOptions struct {
-	createOptions
 	detach     bool
 	sigProxy   bool
+	name       string
 	detachKeys string
 }

 // NewRunCommand create a new `docker run` command
-func NewRunCommand(dockerCli command.Cli) *cobra.Command {
+func NewRunCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts runOptions
 	var copts *containerOptions

@ -62,8 +63,7 @@ func NewRunCommand(dockerCli command.Cli) *cobra.Command {
 	// with hostname
 	flags.Bool("help", false, "Print usage")

-	command.AddPlatformFlag(flags, &opts.platform)
-	command.AddTrustVerificationFlags(flags, &opts.untrusted, dockerCli.ContentTrustEnabled())
+	command.AddTrustVerificationFlags(flags)
 	copts = addFlags(flags)
 	return cmd
 }
@ -97,7 +97,7 @@ func isLocalhost(ip string) bool {
 	return localhostIPRegexp.MatchString(ip)
 }

-func runRun(dockerCli command.Cli, flags *pflag.FlagSet, ropts *runOptions, copts *containerOptions) error {
+func runRun(dockerCli *command.DockerCli, flags *pflag.FlagSet, ropts *runOptions, copts *containerOptions) error {
 	proxyConfig := dockerCli.ConfigFile().ParseProxyConfig(dockerCli.Client().DaemonHost(), copts.env.GetAll())
 	newEnv := []string{}
 	for k, v := range proxyConfig {
@ -118,7 +118,7 @@ func runRun(dockerCli command.Cli, flags *pflag.FlagSet, ropts *runOptions, copt
 }

 // nolint: gocyclo
-func runContainer(dockerCli command.Cli, opts *runOptions, copts *containerOptions, containerConfig *containerConfig) error {
+func runContainer(dockerCli *command.DockerCli, opts *runOptions, copts *containerOptions, containerConfig *containerConfig) error {
 	config := containerConfig.Config
 	hostConfig := containerConfig.HostConfig
 	stdout, stderr := dockerCli.Out(), dockerCli.Err()
@ -161,7 +161,7 @@ func runContainer(dockerCli command.Cli, opts *runOptions, copts *containerOptio

 	ctx, cancelFun := context.WithCancel(context.Background())

-	createResponse, err := createContainer(ctx, dockerCli, containerConfig, &opts.createOptions)
+	createResponse, err := createContainer(ctx, dockerCli, containerConfig, opts.name)
 	if err != nil {
 		reportError(stderr, cmdPath, err.Error(), true)
 		return runStartContainerErr(err)
@ -291,27 +291,22 @@ func attachContainer(
 		return nil, errAttach
 	}

-	ch := make(chan error, 1)
-	*errCh = ch
+	*errCh = promise.Go(func() error {
+		streamer := hijackedIOStreamer{
+			streams:      dockerCli,
+			inputStream:  in,
+			outputStream: out,
+			errorStream:  cerr,
+			resp:         resp,
+			tty:          config.Tty,
+			detachKeys:   options.DetachKeys,
+		}

-	go func() {
-		ch <- func() error {
-			streamer := hijackedIOStreamer{
-				streams:      dockerCli,
-				inputStream:  in,
-				outputStream: out,
-				errorStream:  cerr,
-				resp:         resp,
-				tty:          config.Tty,
-				detachKeys:   options.DetachKeys,
-			}
-
-			if errHijack := streamer.stream(ctx); errHijack != nil {
-				return errHijack
-			}
-			return errAttach
-		}()
-	}()
+		if errHijack := streamer.stream(ctx); errHijack != nil {
+			return errHijack
+		}
+		return errAttach
+	})
 	return resp.Close, nil
 }

--- a/components/cli/cli/command/container/run_test.go
+++ b/components/cli/cli/command/container/run_test.go
@ -1,73 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/cli/internal/test/notary"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/network"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-)
-
-func TestRunLabel(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		createContainerFunc: func(_ *container.Config, _ *container.HostConfig, _ *network.NetworkingConfig, _ string) (container.ContainerCreateCreatedBody, error) {
-			return container.ContainerCreateCreatedBody{
-				ID: "id",
-			}, nil
-		},
-		Version: "1.36",
-	})
-	cmd := NewRunCommand(cli)
-	cmd.Flags().Set("detach", "true")
-	cmd.SetArgs([]string{"--label", "foo", "busybox"})
-	assert.NilError(t, cmd.Execute())
-}
-
-func TestRunCommandWithContentTrustErrors(t *testing.T) {
-	testCases := []struct {
-		name          string
-		args          []string
-		expectedError string
-		notaryFunc    test.NotaryClientFuncType
-	}{
-		{
-			name:          "offline-notary-server",
-			notaryFunc:    notary.GetOfflineNotaryRepository,
-			expectedError: "client is offline",
-			args:          []string{"image:tag"},
-		},
-		{
-			name:          "uninitialized-notary-server",
-			notaryFunc:    notary.GetUninitializedNotaryRepository,
-			expectedError: "remote trust data does not exist",
-			args:          []string{"image:tag"},
-		},
-		{
-			name:          "empty-notary-server",
-			notaryFunc:    notary.GetEmptyTargetsNotaryRepository,
-			expectedError: "No valid trust data for tag",
-			args:          []string{"image:tag"},
-		},
-	}
-	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{
-			createContainerFunc: func(config *container.Config,
-				hostConfig *container.HostConfig,
-				networkingConfig *network.NetworkingConfig,
-				containerName string,
-			) (container.ContainerCreateCreatedBody, error) {
-				return container.ContainerCreateCreatedBody{}, fmt.Errorf("shouldn't try to pull image")
-			},
-		}, test.EnableContentTrust)
-		cli.SetNotaryClient(tc.notaryFunc)
-		cmd := NewRunCommand(cli)
-		cmd.SetArgs(tc.args)
-		err := cmd.Execute()
-		assert.Assert(t, err != nil)
-		assert.Assert(t, is.Contains(cli.ErrBuffer().String(), tc.expectedError))
-	}
-}
--- a/components/cli/cli/command/container/start.go
+++ b/components/cli/cli/command/container/start.go
@ -9,6 +9,7 @@ import (
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/pkg/promise"
 	"github.com/docker/docker/pkg/signal"
 	"github.com/docker/docker/pkg/term"
 	"github.com/pkg/errors"
@ -27,7 +28,7 @@ type startOptions struct {
 }

 // NewStartCommand creates a new cobra.Command for `docker start`
-func NewStartCommand(dockerCli command.Cli) *cobra.Command {
+func NewStartCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts startOptions

 	cmd := &cobra.Command{
@ -53,7 +54,7 @@ func NewStartCommand(dockerCli command.Cli) *cobra.Command {
 }

 // nolint: gocyclo
-func runStart(dockerCli command.Cli, opts *startOptions) error {
+func runStart(dockerCli *command.DockerCli, opts *startOptions) error {
 	ctx, cancelFun := context.WithCancel(context.Background())

 	if opts.attach || opts.openStdin {
@ -102,28 +103,23 @@ func runStart(dockerCli command.Cli, opts *startOptions) error {
 			return errAttach
 		}
 		defer resp.Close()
+		cErr := promise.Go(func() error {
+			streamer := hijackedIOStreamer{
+				streams:      dockerCli,
+				inputStream:  in,
+				outputStream: dockerCli.Out(),
+				errorStream:  dockerCli.Err(),
+				resp:         resp,
+				tty:          c.Config.Tty,
+				detachKeys:   options.DetachKeys,
+			}

-		cErr := make(chan error, 1)
-
-		go func() {
-			cErr <- func() error {
-				streamer := hijackedIOStreamer{
-					streams:      dockerCli,
-					inputStream:  in,
-					outputStream: dockerCli.Out(),
-					errorStream:  dockerCli.Err(),
-					resp:         resp,
-					tty:          c.Config.Tty,
-					detachKeys:   options.DetachKeys,
-				}
-
-				errHijack := streamer.stream(ctx)
-				if errHijack == nil {
-					return errAttach
-				}
-				return errHijack
-			}()
-		}()
+			errHijack := streamer.stream(ctx)
+			if errHijack == nil {
+				return errAttach
+			}
+			return errHijack
+		})

 		// 3. We should open a channel for receiving status code of the container
 		// no matter it's detached, removed on daemon side(--rm) or exit normally.
@ -181,7 +177,7 @@ func runStart(dockerCli command.Cli, opts *startOptions) error {
 	return nil
 }

-func startContainersWithoutAttachments(ctx context.Context, dockerCli command.Cli, containers []string) error {
+func startContainersWithoutAttachments(ctx context.Context, dockerCli *command.DockerCli, containers []string) error {
 	var failedContainers []string
 	for _, container := range containers {
 		if err := dockerCli.Client().ContainerStart(ctx, container, types.ContainerStartOptions{}); err != nil {
--- a/components/cli/cli/command/container/stats.go
+++ b/components/cli/cli/command/container/stats.go
@ -21,13 +21,12 @@ import (
 type statsOptions struct {
 	all        bool
 	noStream   bool
-	noTrunc    bool
 	format     string
 	containers []string
 }

 // NewStatsCommand creates a new cobra.Command for `docker stats`
-func NewStatsCommand(dockerCli command.Cli) *cobra.Command {
+func NewStatsCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts statsOptions

 	cmd := &cobra.Command{
@ -43,7 +42,6 @@ func NewStatsCommand(dockerCli command.Cli) *cobra.Command {
 	flags := cmd.Flags()
 	flags.BoolVarP(&opts.all, "all", "a", false, "Show all containers (default shows just running)")
 	flags.BoolVar(&opts.noStream, "no-stream", false, "Disable streaming stats and only pull the first result")
-	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Do not truncate output")
 	flags.StringVar(&opts.format, "format", "", "Pretty-print images using a Go template")
 	return cmd
 }
@ -51,7 +49,7 @@ func NewStatsCommand(dockerCli command.Cli) *cobra.Command {
 // runStats displays a live stream of resource usage statistics for one or more containers.
 // This shows real-time information on CPU usage, memory usage, and network I/O.
 // nolint: gocyclo
-func runStats(dockerCli command.Cli, opts *statsOptions) error {
+func runStats(dockerCli *command.DockerCli, opts *statsOptions) error {
 	showAll := len(opts.containers) == 0
 	closeChan := make(chan error)

@ -216,7 +214,7 @@ func runStats(dockerCli command.Cli, opts *statsOptions) error {
 			ccstats = append(ccstats, c.GetStatistics())
 		}
 		cStats.mu.Unlock()
-		if err = formatter.ContainerStatsWrite(statsCtx, ccstats, daemonOSType, !opts.noTrunc); err != nil {
+		if err = formatter.ContainerStatsWrite(statsCtx, ccstats, daemonOSType); err != nil {
 			break
 		}
 		if len(cStats.cs) == 0 && !showAll {
--- a/components/cli/cli/command/container/stats_helpers.go
+++ b/components/cli/cli/command/container/stats_helpers.go
@ -7,11 +7,11 @@ import (
 	"sync"
 	"time"

+	"github.com/Sirupsen/logrus"
 	"github.com/docker/cli/cli/command/formatter"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/client"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 	"golang.org/x/net/context"
 )

@ -200,8 +200,7 @@ func calculateCPUPercentWindows(v *types.StatsJSON) float64 {
 	return 0.00
 }

-func calculateBlockIO(blkio types.BlkioStats) (uint64, uint64) {
-	var blkRead, blkWrite uint64
+func calculateBlockIO(blkio types.BlkioStats) (blkRead uint64, blkWrite uint64) {
 	for _, bioEntry := range blkio.IoServiceBytesRecursive {
 		switch strings.ToLower(bioEntry.Op) {
 		case "read":
@ -210,7 +209,7 @@ func calculateBlockIO(blkio types.BlkioStats) (uint64, uint64) {
 			blkWrite = blkWrite + bioEntry.Value
 		}
 	}
-	return blkRead, blkWrite
+	return
 }

 func calculateNetwork(network map[string]types.NetworkStats) (float64, float64) {
--- a/components/cli/cli/command/container/stats_helpers_test.go
+++ b/components/cli/cli/command/container/stats_helpers_test.go
@ -1,11 +1,10 @@
 package container

 import (
-	"fmt"
 	"testing"

 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
+	"github.com/stretchr/testify/assert"
 )

 func TestCalculateMemUsageUnixNoCache(t *testing.T) {
@ -16,7 +15,7 @@ func TestCalculateMemUsageUnixNoCache(t *testing.T) {
 	result := calculateMemUsageUnixNoCache(stats)

 	// Then
-	assert.Assert(t, inDelta(100.0, result, 1e-6))
+	assert.InDelta(t, 100.0, result, 1e-6)
 }

 func TestCalculateMemPercentUnixNoCache(t *testing.T) {
@ -28,20 +27,10 @@ func TestCalculateMemPercentUnixNoCache(t *testing.T) {
 	// When and Then
 	t.Run("Limit is set", func(t *testing.T) {
 		result := calculateMemPercentUnixNoCache(someLimit, used)
-		assert.Assert(t, inDelta(70.0, result, 1e-6))
+		assert.InDelta(t, 70.0, result, 1e-6)
 	})
 	t.Run("No limit, no cgroup data", func(t *testing.T) {
 		result := calculateMemPercentUnixNoCache(noLimit, used)
-		assert.Assert(t, inDelta(0.0, result, 1e-6))
+		assert.InDelta(t, 0.0, result, 1e-6)
 	})
 }
-
-func inDelta(x, y, delta float64) func() (bool, string) {
-	return func() (bool, string) {
-		diff := x - y
-		if diff < -delta || diff > delta {
-			return false, fmt.Sprintf("%f != %f within %f", x, y, delta)
-		}
-		return true, ""
-	}
-}
--- a/components/cli/cli/command/container/stop.go
+++ b/components/cli/cli/command/container/stop.go
@ -20,7 +20,7 @@ type stopOptions struct {
 }

 // NewStopCommand creates a new cobra.Command for `docker stop`
-func NewStopCommand(dockerCli command.Cli) *cobra.Command {
+func NewStopCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts stopOptions

 	cmd := &cobra.Command{
@ -39,7 +39,7 @@ func NewStopCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runStop(dockerCli command.Cli, opts *stopOptions) error {
+func runStop(dockerCli *command.DockerCli, opts *stopOptions) error {
 	ctx := context.Background()

 	var timeout *time.Duration
--- a/components/cli/cli/command/container/testdata/container-list-format-name-name.golden
+++ b/components/cli/cli/command/container/testdata/container-list-format-name-name.golden
@ -1,2 +0,0 @@
-c1 c1
-c2 c2
--- a/components/cli/cli/command/container/testdata/container-list-format-with-arg.golden
+++ b/components/cli/cli/command/container/testdata/container-list-format-with-arg.golden
@ -1,2 +0,0 @@
-c1 value
-c2 
--- a/components/cli/cli/command/container/testdata/container-list-with-config-format.golden
+++ b/components/cli/cli/command/container/testdata/container-list-with-config-format.golden
@ -1,2 +0,0 @@
-c1 busybox:latest some.label=value
-c2 busybox:latest foo=bar
--- a/components/cli/cli/command/container/testdata/container-list-with-format.golden
+++ b/components/cli/cli/command/container/testdata/container-list-with-format.golden
@ -1,2 +0,0 @@
-c1 busybox:latest some.label=value
-c2 busybox:latest foo=bar
--- a/components/cli/cli/command/container/testdata/container-list-without-format-no-trunc.golden
+++ b/components/cli/cli/command/container/testdata/container-list-without-format-no-trunc.golden
@ -1,3 +0,0 @@
-CONTAINER ID        IMAGE               COMMAND             CREATED                  STATUS              PORTS               NAMES
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second                             c1
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second                             c2,foo/bar
--- a/components/cli/cli/command/container/testdata/container-list-without-format.golden
+++ b/components/cli/cli/command/container/testdata/container-list-without-format.golden
@ -1,6 +0,0 @@
-CONTAINER ID        IMAGE               COMMAND             CREATED                  STATUS              PORTS                NAMES
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second                              c1
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second                              c2
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second         80-82/tcp            c3
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second         81/udp               c4
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second         8.8.8.8:82->82/tcp   c5
--- a/components/cli/cli/command/container/top.go
+++ b/components/cli/cli/command/container/top.go
@ -18,7 +18,7 @@ type topOptions struct {
 }

 // NewTopCommand creates a new cobra.Command for `docker top`
-func NewTopCommand(dockerCli command.Cli) *cobra.Command {
+func NewTopCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts topOptions

 	cmd := &cobra.Command{
@ -38,7 +38,7 @@ func NewTopCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runTop(dockerCli command.Cli, opts *topOptions) error {
+func runTop(dockerCli *command.DockerCli, opts *topOptions) error {
 	ctx := context.Background()

 	procList, err := dockerCli.Client().ContainerTop(ctx, opts.container, opts.args)
--- a/components/cli/cli/command/container/tty.go
+++ b/components/cli/cli/command/container/tty.go
@ -7,11 +7,11 @@ import (
 	"runtime"
 	"time"

+	"github.com/Sirupsen/logrus"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/client"
 	"github.com/docker/docker/pkg/signal"
-	"github.com/sirupsen/logrus"
 	"golang.org/x/net/context"
 )

--- a/components/cli/cli/command/container/unpause.go
+++ b/components/cli/cli/command/container/unpause.go
@ -16,7 +16,7 @@ type unpauseOptions struct {
 }

 // NewUnpauseCommand creates a new cobra.Command for `docker unpause`
-func NewUnpauseCommand(dockerCli command.Cli) *cobra.Command {
+func NewUnpauseCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts unpauseOptions

 	cmd := &cobra.Command{
@ -31,7 +31,7 @@ func NewUnpauseCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runUnpause(dockerCli command.Cli, opts *unpauseOptions) error {
+func runUnpause(dockerCli *command.DockerCli, opts *unpauseOptions) error {
 	ctx := context.Background()

 	var errs []string
--- a/components/cli/cli/command/container/update.go
+++ b/components/cli/cli/command/container/update.go
@ -35,7 +35,7 @@ type updateOptions struct {
 }

 // NewUpdateCommand creates a new cobra.Command for `docker update`
-func NewUpdateCommand(dockerCli command.Cli) *cobra.Command {
+func NewUpdateCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var options updateOptions

 	cmd := &cobra.Command{
@ -72,7 +72,7 @@ func NewUpdateCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runUpdate(dockerCli command.Cli, options *updateOptions) error {
+func runUpdate(dockerCli *command.DockerCli, options *updateOptions) error {
 	var err error

 	if options.nFlag == 0 {
--- a/components/cli/cli/command/container/utils.go
+++ b/components/cli/cli/command/container/utils.go
@ -3,17 +3,18 @@ package container
 import (
 	"strconv"

+	"github.com/Sirupsen/logrus"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/events"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/versions"
-	"github.com/sirupsen/logrus"
+	clientapi "github.com/docker/docker/client"
 	"golang.org/x/net/context"
 )

-func waitExitOrRemoved(ctx context.Context, dockerCli command.Cli, containerID string, waitRemove bool) <-chan int {
+func waitExitOrRemoved(ctx context.Context, dockerCli *command.DockerCli, containerID string, waitRemove bool) <-chan int {
 	if len(containerID) == 0 {
 		// containerID can never be empty
 		panic("Internal Error: waitExitOrRemoved needs a containerID as parameter")
@ -37,12 +38,7 @@ func waitExitOrRemoved(ctx context.Context, dockerCli command.Cli, containerID s
 	go func() {
 		select {
 		case result := <-resultC:
-			if result.Error != nil {
-				logrus.Errorf("Error waiting for container: %v", result.Error.Message)
-				statusC <- 125
-			} else {
-				statusC <- int(result.StatusCode)
-			}
+			statusC <- int(result.StatusCode)
 		case err := <-errC:
 			logrus.Errorf("error waiting for container: %v", err)
 			statusC <- 125
@ -52,7 +48,7 @@ func waitExitOrRemoved(ctx context.Context, dockerCli command.Cli, containerID s
 	return statusC
 }

-func legacyWaitExitOrRemoved(ctx context.Context, dockerCli command.Cli, containerID string, waitRemove bool) <-chan int {
+func legacyWaitExitOrRemoved(ctx context.Context, dockerCli *command.DockerCli, containerID string, waitRemove bool) <-chan int {
 	var removeErr error
 	statusChan := make(chan int)
 	exitCode := 125
@ -129,6 +125,20 @@ func legacyWaitExitOrRemoved(ctx context.Context, dockerCli command.Cli, contain
 	return statusChan
 }

+// getExitCode performs an inspect on the container. It returns
+// the running state and the exit code.
+func getExitCode(ctx context.Context, dockerCli command.Cli, containerID string) (bool, int, error) {
+	c, err := dockerCli.Client().ContainerInspect(ctx, containerID)
+	if err != nil {
+		// If we can't connect, then the daemon probably died.
+		if !clientapi.IsErrConnectionFailed(err) {
+			return false, -1, err
+		}
+		return false, -1, nil
+	}
+	return c.State.Running, c.State.ExitCode, nil
+}
+
 func parallelOperation(ctx context.Context, containers []string, op func(ctx context.Context, container string) error) chan error {
 	if len(containers) == 0 {
 		return nil
--- a/components/cli/cli/command/container/utils_test.go
+++ b/components/cli/cli/command/container/utils_test.go
@ -1,70 +0,0 @@
-package container
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/docker/api"
-	"github.com/docker/docker/api/types/container"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/pkg/errors"
-	"golang.org/x/net/context"
-)
-
-func waitFn(cid string) (<-chan container.ContainerWaitOKBody, <-chan error) {
-	resC := make(chan container.ContainerWaitOKBody)
-	errC := make(chan error, 1)
-	var res container.ContainerWaitOKBody
-
-	go func() {
-		switch {
-		case strings.Contains(cid, "exit-code-42"):
-			res.StatusCode = 42
-			resC <- res
-		case strings.Contains(cid, "non-existent"):
-			err := errors.Errorf("No such container: %v", cid)
-			errC <- err
-		case strings.Contains(cid, "wait-error"):
-			res.Error = &container.ContainerWaitOKBodyError{Message: "removal failed"}
-			resC <- res
-		default:
-			// normal exit
-			resC <- res
-		}
-	}()
-
-	return resC, errC
-}
-
-func TestWaitExitOrRemoved(t *testing.T) {
-	testcases := []struct {
-		cid      string
-		exitCode int
-	}{
-		{
-			cid:      "normal-container",
-			exitCode: 0,
-		},
-		{
-			cid:      "give-me-exit-code-42",
-			exitCode: 42,
-		},
-		{
-			cid:      "i-want-a-wait-error",
-			exitCode: 125,
-		},
-		{
-			cid:      "non-existent-container-id",
-			exitCode: 125,
-		},
-	}
-
-	client := test.NewFakeCli(&fakeClient{waitFunc: waitFn, Version: api.DefaultVersion})
-	for _, testcase := range testcases {
-		statusC := waitExitOrRemoved(context.Background(), client, testcase.cid, true)
-		exitCode := <-statusC
-		assert.Check(t, is.Equal(testcase.exitCode, exitCode))
-	}
-}
--- a/components/cli/cli/command/container/wait.go
+++ b/components/cli/cli/command/container/wait.go
@ -16,7 +16,7 @@ type waitOptions struct {
 }

 // NewWaitCommand creates a new cobra.Command for `docker wait`
-func NewWaitCommand(dockerCli command.Cli) *cobra.Command {
+func NewWaitCommand(dockerCli *command.DockerCli) *cobra.Command {
 	var opts waitOptions

 	cmd := &cobra.Command{
@ -32,7 +32,7 @@ func NewWaitCommand(dockerCli command.Cli) *cobra.Command {
 	return cmd
 }

-func runWait(dockerCli command.Cli, opts *waitOptions) error {
+func runWait(dockerCli *command.DockerCli, opts *waitOptions) error {
 	ctx := context.Background()

 	var errs []string
--- a/components/cli/cli/command/events_utils.go
+++ b/components/cli/cli/command/events_utils.go
@ -3,8 +3,8 @@ package command
 import (
 	"sync"

+	"github.com/Sirupsen/logrus"
 	eventtypes "github.com/docker/docker/api/types/events"
-	"github.com/sirupsen/logrus"
 )

 // EventHandler is abstract interface for user to customize
--- a/components/cli/cli/command/formatter/checkpoint_test.go
+++ b/components/cli/cli/command/formatter/checkpoint_test.go
@ -5,7 +5,7 @@ import (
 	"testing"

 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
+	"github.com/stretchr/testify/assert"
 )

 func TestCheckpointContextFormatWrite(t *testing.T) {
@ -46,7 +46,10 @@ checkpoint-3:
 		out := bytes.NewBufferString("")
 		testcase.context.Output = out
 		err := CheckpointWrite(testcase.context, checkpoints)
-		assert.NilError(t, err)
-		assert.Equal(t, out.String(), testcase.expected)
+		if err != nil {
+			assert.Error(t, err, testcase.expected)
+		} else {
+			assert.Equal(t, out.String(), testcase.expected)
+		}
 	}
 }
--- a/components/cli/cli/command/formatter/config_test.go
+++ b/components/cli/cli/command/formatter/config_test.go
@ -6,8 +6,7 @@ import (
 	"time"

 	"github.com/docker/docker/api/types/swarm"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )

 func TestConfigContextFormatWrite(t *testing.T) {
@ -56,9 +55,9 @@ id_rsa
 		out := bytes.NewBufferString("")
 		testcase.context.Output = out
 		if err := ConfigWrite(testcase.context, configs); err != nil {
-			assert.ErrorContains(t, err, testcase.expected)
+			assert.Error(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(out.String(), testcase.expected))
+			assert.Equal(t, out.String(), testcase.expected)
 		}
 	}
 }
--- a/components/cli/cli/command/formatter/container.go
+++ b/components/cli/cli/command/formatter/container.go
@ -10,6 +10,7 @@ import (
 	"github.com/docker/distribution/reference"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
+	"github.com/docker/docker/pkg/stringutils"
 	"github.com/docker/go-units"
 )

@ -164,7 +165,7 @@ func (c *containerContext) Image() string {
 func (c *containerContext) Command() string {
 	command := c.c.Command
 	if c.trunc {
-		command = Ellipsis(command, 20)
+		command = stringutils.Ellipsis(command, 20)
 	}
 	return strconv.Quote(command)
 }
@ -226,7 +227,7 @@ func (c *containerContext) Mounts() string {
 			name = m.Name
 		}
 		if c.trunc {
-			name = Ellipsis(name, 15)
+			name = stringutils.Ellipsis(name, 15)
 		}
 		mounts = append(mounts, name)
 	}
--- a/components/cli/cli/command/formatter/container_test.go
+++ b/components/cli/cli/command/formatter/container_test.go
@ -10,9 +10,8 @@ import (

 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 func TestContainerPsContext(t *testing.T) {
@ -66,7 +65,7 @@ func TestContainerPsContext(t *testing.T) {
 					Source: "/a/path",
 				},
 			},
-		}, true, "this-is-a-long…", ctx.Mounts},
+		}, true, "this-is-a-lo...", ctx.Mounts},
 		{types.Container{
 			Mounts: []types.MountPoint{
 				{
@ -231,7 +230,10 @@ size: 0B
 		// Special headers for customized table format
 		{
 			Context{Format: NewContainerFormat(`table {{truncate .ID 5}}\t{{json .Image}} {{.RunningFor}}/{{title .Status}}/{{pad .Ports 2 2}}.{{upper .Names}} {{lower .Status}}`, false, true)},
-			string(golden.Get(t, "container-context-write-special-headers.golden")),
+			`CONTAINER ID        IMAGE CREATED/STATUS/  PORTS  .NAMES STATUS
+conta               "ubuntu" 24 hours ago//.FOOBAR_BAZ 
+conta               "ubuntu" 24 hours ago//.FOOBAR_BAR 
+`,
 		},
 	}

@ -244,9 +246,9 @@ size: 0B
 		testcase.context.Output = out
 		err := ContainerWrite(testcase.context, containers)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@ -305,7 +307,7 @@ func TestContainerContextWriteWithNoContainers(t *testing.T) {

 	for _, context := range contexts {
 		ContainerWrite(context.context, containers)
-		assert.Check(t, is.Equal(context.expected, out.String()))
+		assert.Equal(t, context.expected, out.String())
 		// Clean buffer
 		out.Reset()
 	}
@ -359,8 +361,8 @@ func TestContainerContextWriteJSON(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var m map[string]interface{}
 		err := json.Unmarshal([]byte(line), &m)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.DeepEqual(expectedJSONs[i], m), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, expectedJSONs[i], m, msg)
 	}
 }

@ -378,8 +380,8 @@ func TestContainerContextWriteJSONField(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var s string
 		err := json.Unmarshal([]byte(line), &s)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.Equal(containers[i].ID, s), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, containers[i].ID, s, msg)
 	}
 }

@ -642,17 +644,14 @@ func TestDisplayablePorts(t *testing.T) {
 					PublicPort:  1024,
 					PrivatePort: 80,
 					Type:        "udp",
-				}, {
-					PrivatePort: 12345,
-					Type:        "sctp",
 				},
 			},
-			"80/tcp, 80/udp, 1024/tcp, 1024/udp, 12345/sctp, 1.1.1.1:1024->80/tcp, 1.1.1.1:1024->80/udp, 2.1.1.1:1024->80/tcp, 2.1.1.1:1024->80/udp, 1.1.1.1:80->1024/tcp, 1.1.1.1:80->1024/udp, 2.1.1.1:80->1024/tcp, 2.1.1.1:80->1024/udp",
+			"80/tcp, 80/udp, 1024/tcp, 1024/udp, 1.1.1.1:1024->80/tcp, 1.1.1.1:1024->80/udp, 2.1.1.1:1024->80/tcp, 2.1.1.1:1024->80/udp, 1.1.1.1:80->1024/tcp, 1.1.1.1:80->1024/udp, 2.1.1.1:80->1024/tcp, 2.1.1.1:80->1024/udp",
 		},
 	}

 	for _, port := range cases {
 		actual := DisplayablePorts(port.ports)
-		assert.Check(t, is.Equal(port.expected, actual))
+		assert.Equal(t, port.expected, actual)
 	}
 }
--- a/components/cli/cli/command/formatter/custom_test.go
+++ b/components/cli/cli/command/formatter/custom_test.go
@ -1,11 +1,9 @@
 package formatter

 import (
+	"reflect"
 	"strings"
 	"testing"
-
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 )

 func compareMultipleValues(t *testing.T, value, expected string) {
@ -24,5 +22,7 @@ func compareMultipleValues(t *testing.T, value, expected string) {
 		keyval := strings.Split(expected, "=")
 		expMap[keyval[0]] = keyval[1]
 	}
-	assert.Check(t, is.DeepEqual(expMap, entriesMap))
+	if !reflect.DeepEqual(expMap, entriesMap) {
+		t.Fatalf("Expected entries: %v, got: %v", expected, value)
+	}
 }
--- a/Show More
+++ b/Show More