Merge pull request #9664 from ulyssessouza/bump-compose-go-1.2.9

Bump compose-go -> v1.2.9

.dockerignore

@@ -1,3 +1,2 @@
-.git/
 bin/
 dist/

.github/workflows/artifacts.yml

@@ -7,10 +7,10 @@ jobs:
     if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/generate-artifacts')
     runs-on: ubuntu-latest
     steps:
-      - name: Set up Go 1.17
+      - name: Set up Go 1.18
         uses: actions/setup-go@v2
         with:
-          go-version: 1.17
+          go-version: 1.18.4
         id: go
 
       - name: Checkout code into the Go module directory
@@ -42,6 +42,12 @@ jobs:
           name: docker-compose-linux-amd64
           path: ${{ github.workspace }}/bin/docker-compose-linux-amd64
 
+      - name: Upload linux-ppc64le binary
+        uses: actions/upload-artifact@v2
+        with:
+          name: docker-compose-linux-ppc64le
+          path: ${{ github.workspace }}/bin/docker-compose-linux-ppc64le
+
       - name: Upload windows-amd64 binary
         uses: actions/upload-artifact@v2
         with:

.github/workflows/ci.yml

@@ -5,6 +5,12 @@ on:
     branches:
       - v2
   pull_request:
+  workflow_dispatch:
+    inputs:
+      debug_enabled:
+        description: 'To run with tmate enter "debug_enabled"'
+        required: false
+        default: "false"
 
 jobs:
   lint:
@@ -13,16 +19,16 @@ jobs:
     env:
       GO111MODULE: "on"
     steps:
-      - name: Set up Go 1.17
+      - name: Set up Go 1.18
         uses: actions/setup-go@v2
         with:
-          go-version: 1.17
+          go-version: 1.18.4
         id: go
 
       - name: Checkout code into the Go module directory
         uses: actions/checkout@v2
 
-      - name: Validate go-mod is up-to-date and license headers
+      - name: Validate go-mod, license headers and docs are up-to-date
         run: make validate
 
       - name: Run golangci-lint
@@ -40,10 +46,10 @@ jobs:
     env:
       GO111MODULE: "on"
     steps:
-      - name: Set up Go 1.17
+      - name: Set up Go 1.18
         uses: actions/setup-go@v2
         with:
-          go-version: 1.17
+          go-version: 1.18.4
         id: go
 
       - name: Checkout code into the Go module directory
@@ -65,10 +71,10 @@ jobs:
     env:
       GO111MODULE: "on"
     steps:
-      - name: Set up Go 1.17
+      - name: Set up Go 1.18
         uses: actions/setup-go@v2
         with:
-          go-version: 1.17
+          go-version: 1.18.4
         id: go
 
       - name: Setup docker CLI
@@ -90,7 +96,7 @@ jobs:
       - name: Build for local E2E
         env:
           BUILD_TAGS: e2e
-        run: make -f builder.Makefile compose-plugin
+        run: make GIT_TAG=e2e-PR-${{ github.event.pull_request.number }}-${{ github.event.pull_request.head.sha }} -f builder.Makefile compose-plugin
 
       - name: E2E Test in plugin mode
         run: make e2e-compose
@@ -101,10 +107,10 @@ jobs:
     env:
       GO111MODULE: "on"
     steps:
-      - name: Set up Go 1.17
+      - name: Set up Go 1.18
         uses: actions/setup-go@v2
         with:
-          go-version: 1.17
+          go-version: 1.18.4
         id: go
 
       - name: Setup docker CLI
@@ -123,7 +129,17 @@ jobs:
       - name: Build for local E2E
         env:
           BUILD_TAGS: e2e
-        run: make -f builder.Makefile compose-plugin
+        run: make GIT_TAG=e2e-PR-${{ github.event.pull_request.number }}-${{ github.event.pull_request.head.sha }} -f builder.Makefile compose-plugin
+
+      - name: Setup tmate session
+        uses: mxschmitt/action-tmate@v3
+        with:
+          limit-access-to-actor: true
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled }}
 
       - name: E2E Test in standalone mode
-        run: make e2e-compose-standalone
+        run: |
+          rm -f /usr/local/bin/docker-compose
+          cp bin/docker-compose /usr/local/bin
+          make e2e-compose-standalone

.github/workflows/docs.yml

@@ -0,0 +1,51 @@
+name: Docs
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  open-pr:
+    runs-on: ubuntu-latest
+    steps:
+      -
+        name: Checkout docs repo
+        uses: actions/checkout@v3
+        with:
+          token: ${{ secrets.GHPAT_DOCS_DISPATCH }}
+          repository: docker/docker.github.io
+          ref: master
+      -
+        name: Prepare
+        run: |
+          rm -rf ./_data/compose-cli/*
+      -
+        name: Build
+        uses: docker/build-push-action@v3
+        with:
+          context: ${{ github.server_url }}/${{ github.repository }}.git#${{ github.event.release.name }}
+          target: docs-reference
+          outputs: ./_data/compose-cli
+      -
+        name: Update compose_version in _config.yml
+        run: |
+          sed -i "s|^compose_version\:.*|compose_version\: \"${{ github.event.release.name }}\"|g" _config.yml
+          cat _config.yml | yq .compose_version
+      -
+        name: Commit changes
+        run: |
+          git add -A .
+      -
+        name: Create PR on docs repo
+        uses: peter-evans/create-pull-request@923ad837f191474af6b1721408744feb989a4c27 # v4.0.4
+        with:
+          token: ${{ secrets.GHPAT_DOCS_DISPATCH }}
+          commit-message: Update Compose reference API to ${{ github.event.release.name }}
+          signoff: true
+          branch: dispatch/compose-api-reference-${{ github.event.release.name }}
+          delete-branch: true
+          title: Update Compose reference API to ${{ github.event.release.name }}
+          body: |
+            Update the Compose reference API documentation to keep in sync with the latest release `${{ github.event.release.name }}`
+          labels: area/Compose
+          draft: false

.github/workflows/release.yaml

@@ -11,10 +11,10 @@ jobs:
   upload-release:
     runs-on: ubuntu-latest
     steps:
-      - name: Set up Go 1.17
+      - name: Set up Go 1.18
         uses: actions/setup-go@v2
         with:
-          go-version: 1.17
+          go-version: 1.18.4
         id: go
 
       - name: Setup docker CLI
@@ -36,7 +36,7 @@ jobs:
         run: make GIT_TAG=${{ github.event.inputs.tag }} -f builder.Makefile cross
 
       - name: Compute checksums
-        run: cd bin; for f in *; do shasum --algorithm 256 $f > $f.sha256; done
+        run: cd bin; for f in *; do shasum --binary --algorithm 256 $f | tee -a checksums.txt > $f.sha256; done
 
       - name: License
         run: cp packaging/* bin/

.golangci.yml

@@ -1,13 +1,13 @@
+run:
+  concurrency: 2
 linters:
-  run:
-    concurrency: 2
-    skip-dirs:
-      - tests/composefiles
   enable-all: false
   disable-all: true
   enable:
     - deadcode
+    - depguard
     - errcheck
+    - gocritic
     - gocyclo
     - gofmt
     - goimports
@@ -26,6 +26,24 @@ linters:
     - unused
     - varcheck
 linters-settings:
+  depguard:
+    list-type: blacklist
+    include-go-root: true
+    packages:
+      # The io/ioutil package has been deprecated.
+      # https://go.dev/doc/go1.16#ioutil
+      - io/ioutil
+  gocritic:
+    # Enable multiple checks by tags, run `GL_DEBUG=gocritic golangci-lint run` to see all tags and checks.
+    # Empty list by default. See https://github.com/go-critic/go-critic#usage -> section "Tags".
+    enabled-tags:
+      - diagnostic
+      - opinionated
+      - style
+    disabled-checks:
+      - paramTypeCombine
+      - unnamedResult
+      - whyNoLint
   gocyclo:
     min-complexity: 16
   lll:

BUILDING.md

@@ -8,7 +8,7 @@
   * [Docker Desktop](https://hub.docker.com/editions/community/docker-ce-desktop-mac)
   * make
 * Linux:
-  * [Docker 19.03 or later](https://docs.docker.com/engine/install/)
+  * [Docker 20.10 or later](https://docs.docker.com/engine/install/)
   * make
 
 ### Building the CLI
@@ -34,15 +34,51 @@ make test
 
 If you need to update a golden file simply do `go test ./... -test.update-golden`.
 
-### End to end tests
+### End-to-end tests
+To run e2e tests, the Compose CLI binary need to be build. All the commands to run e2e tests propose a version
+with the prefix `build-and-e2e` to first build the CLI before executing tests.
 
-To run the end to end tests, run:
+
+Note that this requires a local Docker Engine to be running.
+
+#### Whole end-to-end tests suite
+
+To execute both CLI and standalone e2e tests, run :
+
+```console
+make e2e
+```
+
+Or if you need to build the CLI, run: 
+```console
+make build-and-e2e
+```
+
+#### Plugin end-to-end tests suite
+
+To execute CLI plugin e2e tests, run :
 
 ```console
 make e2e-compose
 ```
 
-Note that this requires a local Docker Engine to be running.
+Or if you need to build the CLI, run:
+```console
+make build-and-e2e-compose
+```
+
+#### Standalone end-to-end tests suite
+
+To execute the standalone CLI e2e tests, run :
+
+```console
+make e2e-compose-standalone
+```
+
+Or if you need to build the CLI, run:
+```console
+make build-and-e2e-compose-standalone
+```
 
 ## Releases
 

Dockerfile

@@ -15,10 +15,12 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-ARG GO_VERSION=1.17-alpine
-ARG GOLANGCI_LINT_VERSION=v1.40.1-alpine
+ARG GO_VERSION=1.18.4-alpine
+ARG GOLANGCI_LINT_VERSION=v1.46.2-alpine
 ARG PROTOC_GEN_GO_VERSION=v1.4.3
 
+FROM --platform=${BUILDPLATFORM} golangci/golangci-lint:${GOLANGCI_LINT_VERSION} AS local-golangci-lint
+
 FROM --platform=${BUILDPLATFORM} golang:${GO_VERSION} AS base
 WORKDIR /compose-cli
 RUN apk add --no-cache -vv \
@@ -34,7 +36,7 @@ RUN --mount=type=cache,target=/go/pkg/mod \
 
 FROM base AS lint
 ENV CGO_ENABLED=0
-COPY --from=golangci/golangci-lint /usr/bin/golangci-lint /usr/bin/golangci-lint
+COPY --from=local-golangci-lint /usr/bin/golangci-lint /usr/bin/golangci-lint
 ARG BUILD_TAGS
 ARG GIT_TAG
 RUN --mount=target=. \
@@ -88,7 +90,7 @@ RUN --mount=target=. \
     make -f builder.Makefile test
 
 FROM base AS check-license-headers
-RUN go get -u github.com/kunalkushwaha/ltag
+RUN go install github.com/kunalkushwaha/ltag@latest
 RUN --mount=target=. \
     make -f builder.Makefile check-license-headers
 
@@ -105,3 +107,9 @@ COPY --from=make-go-mod-tidy /compose-cli/go.sum .
 FROM base AS check-go-mod
 COPY . .
 RUN make -f builder.Makefile check-go-mod
+
+# docs-reference is a target used as remote context to update docs on release
+# with latest changes on docker.github.io.
+# see open-pr job in .github/workflows/docs.yml for more details
+FROM scratch AS docs-reference
+COPY docs/reference/*.yaml .

Makefile

@@ -43,16 +43,32 @@ compose-plugin: ## Compile the compose cli-plugin
 
 .PHONY: e2e-compose
 e2e-compose: ## Run end to end local tests in plugin mode. Set E2E_TEST=TestName to run a single test
+	docker compose version
 	go test $(TEST_FLAGS) -count=1 ./pkg/e2e
 
 .PHONY: e2e-compose-standalone
 e2e-compose-standalone: ## Run End to end local tests in standalone mode. Set E2E_TEST=TestName to run a single test
-	go test $(TEST_FLAGS) -count=1 --tags=standalone ./pkg/e2e
+	docker-compose version
+	go test $(TEST_FLAGS) -v -count=1 -parallel=1 --tags=standalone ./pkg/e2e
 
+.PHONY: build-and-e2e-compose
+build-and-e2e-compose: compose-plugin e2e-compose ## Compile the compose cli-plugin and run end to end local tests in plugin mode. Set E2E_TEST=TestName to run a single test
+
+.PHONY: build-and-e2e-compose-standalone
+build-and-e2e-compose-standalone: compose-plugin e2e-compose-standalone ## Compile the compose cli-plugin and run End to end local tests in standalone mode. Set E2E_TEST=TestName to run a single test
+
+.PHONY: mocks
+mocks:
+	mockgen -destination pkg/mocks/mock_docker_cli.go -package mocks github.com/docker/cli/cli/command Cli
+	mockgen -destination pkg/mocks/mock_docker_api.go -package mocks github.com/docker/docker/client APIClient
+	mockgen -destination pkg/mocks/mock_docker_compose_api.go -package mocks -source=./pkg/api/api.go Service
 
 .PHONY: e2e
 e2e: e2e-compose e2e-compose-standalone ## Run end to end local tests in both modes. Set E2E_TEST=TestName to run a single test
 
+.PHONY: build-and-e2e
+build-and-e2e: compose-plugin e2e-compose e2e-compose-standalone ## Compile the compose cli-plugin and run end to end local tests in both modes. Set E2E_TEST=TestName to run a single test
+
 .PHONY: cross
 cross: ## Compile the CLI for linux, darwin and windows
 	@docker build . --target cross \
@@ -78,6 +94,23 @@ lint: ## run linter(s)
 	--build-arg GIT_TAG=$(GIT_TAG) \
 	--target lint
 
+.PHONY: docs
+docs: ## generate documentation
+	$(eval $@_TMP_OUT := $(shell mktemp -d -t dockercli-output.XXXXXXXXXX))
+	docker build . \
+	--output type=local,dest=$($@_TMP_OUT) \
+	-f ./docs/docs.Dockerfile \
+	--target update
+	rm -rf ./docs/internal
+	cp -R "$($@_TMP_OUT)"/out/* ./docs/
+	rm -rf "$($@_TMP_OUT)"/*
+
+.PHONY: validate-docs
+validate-docs: ## validate the doc does not change
+	@docker build . \
+	-f ./docs/docs.Dockerfile \
+	--target validate
+
 .PHONY: check-dependencies
 check-dependencies: ## check dependency updates
 	go list -u -m -f '{{if not .Indirect}}{{if .Update}}{{.}}{{end}}{{end}}' all
@@ -94,7 +127,7 @@ go-mod-tidy: ## Run go mod tidy in a container and output resulting go.mod and g
 validate-go-mod: ## Validate go.mod and go.sum are up-to-date
 	@docker build . --target check-go-mod
 
-validate: validate-go-mod validate-headers ## Validate sources
+validate: validate-go-mod validate-headers validate-docs ## Validate sources
 
 pre-commit: validate check-dependencies lint compose-plugin test e2e-compose
 

builder.Makefile

@@ -47,6 +47,7 @@ compose-plugin:
 .PHONY: cross
 cross:
 	GOOS=linux   GOARCH=amd64 $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-linux-x86_64 ./cmd
+	GOOS=linux   GOARCH=ppc64le $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-linux-ppc64le ./cmd
 	GOOS=linux   GOARCH=arm64 $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-linux-aarch64 ./cmd
 	GOOS=linux   GOARM=6 GOARCH=arm $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-linux-armv6 ./cmd
 	GOOS=linux   GOARM=7 GOARCH=arm $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-linux-armv7 ./cmd
@@ -70,7 +71,3 @@ check-license-headers:
 .PHONY: check-go-mod
 check-go-mod:
 	./scripts/validate/check-go-mod
-
-.PHONY: yamldocs
-yamldocs:
-	go run docs/yaml/main/generate.go

cmd/compatibility/convert.go

@@ -50,7 +50,7 @@ func Convert(args []string) []string {
 	l := len(args)
 	for i := 0; i < l; i++ {
 		arg := args[i]
-		if arg[0] != '-' {
+		if len(arg) > 0 && arg[0] != '-' {
 			// not a top-level flag anymore, keep the rest of the command unmodified
 			if arg == compose.PluginName {
 				i++
@@ -58,17 +58,18 @@ func Convert(args []string) []string {
 			command = append(command, args[i:]...)
 			break
 		}
-		if arg == "--verbose" {
+
+		switch arg {
+		case "--verbose":
 			arg = "--debug"
-		}
-		if arg == "-h" {
+		case "-h":
 			// docker cli has deprecated -h to avoid ambiguity with -H, while docker-compose still support it
 			arg = "--help"
-		}
-		if arg == "--version" || arg == "-v" {
+		case "--version", "-v":
 			// redirect --version pseudo-command to actual command
 			arg = "version"
 		}
+
 		if contains(getBoolFlags(), arg) {
 			rootFlags = append(rootFlags, arg)
 			continue

cmd/compatibility/convert_test.go

@@ -43,11 +43,21 @@ func Test_convert(t *testing.T) {
 			args: []string{"--host", "tcp://1.2.3.4", "up"},
 			want: []string{"--host", "tcp://1.2.3.4", "compose", "up"},
 		},
+		{
+			name: "compose --verbose",
+			args: []string{"--verbose"},
+			want: []string{"--debug", "compose"},
+		},
 		{
 			name: "compose --version",
 			args: []string{"--version"},
 			want: []string{"compose", "version"},
 		},
+		{
+			name: "compose -v",
+			args: []string{"-v"},
+			want: []string{"compose", "version"},
+		},
 		{
 			name: "help",
 			args: []string{"-h"},
@@ -68,6 +78,11 @@ func Test_convert(t *testing.T) {
 			args: []string{"--log-level", "INFO", "up"},
 			want: []string{"--log-level", "INFO", "compose", "up"},
 		},
+		{
+			name: "empty string argument",
+			args: []string{"--project-directory", "", "ps"},
+			want: []string{"compose", "--project-directory", "", "ps"},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

cmd/compose/build.go

@@ -23,6 +23,7 @@ import (
 	"strings"
 
 	"github.com/compose-spec/compose-go/cli"
+	"github.com/compose-spec/compose-go/loader"
 	"github.com/compose-spec/compose-go/types"
 	buildx "github.com/docker/buildx/util/progress"
 	"github.com/docker/compose/v2/pkg/utils"
@@ -40,6 +41,28 @@ type buildOptions struct {
 	args     []string
 	noCache  bool
 	memory   string
+	ssh      string
+}
+
+func (opts buildOptions) toAPIBuildOptions(services []string) (api.BuildOptions, error) {
+	var SSHKeys []types.SSHKey
+	var err error
+	if opts.ssh != "" {
+		SSHKeys, err = loader.ParseShortSSHSyntax(opts.ssh)
+		if err != nil {
+			return api.BuildOptions{}, err
+		}
+	}
+
+	return api.BuildOptions{
+		Pull:     opts.pull,
+		Progress: opts.progress,
+		Args:     types.NewMappingWithEquals(opts.args),
+		NoCache:  opts.noCache,
+		Quiet:    opts.quiet,
+		Services: services,
+		SSHs:     SSHKeys,
+	}, nil
 }
 
 var printerModes = []string{
@@ -73,7 +96,10 @@ func buildCommand(p *projectOptions, backend api.Service) *cobra.Command {
 			}
 			return nil
 		}),
-		RunE: Adapt(func(ctx context.Context, args []string) error {
+		RunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
+			if cmd.Flags().Changed("ssh") && opts.ssh == "" {
+				opts.ssh = "default"
+			}
 			return runBuild(ctx, backend, opts, args)
 		}),
 		ValidArgsFunction: serviceCompletion(p),
@@ -82,6 +108,7 @@ func buildCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	cmd.Flags().BoolVar(&opts.pull, "pull", false, "Always attempt to pull a newer version of the image.")
 	cmd.Flags().StringVar(&opts.progress, "progress", buildx.PrinterModeAuto, fmt.Sprintf(`Set type of progress output (%s)`, strings.Join(printerModes, ", ")))
 	cmd.Flags().StringArrayVar(&opts.args, "build-arg", []string{}, "Set build-time variables for services.")
+	cmd.Flags().StringVar(&opts.ssh, "ssh", "", "Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent)")
 	cmd.Flags().Bool("parallel", true, "Build images in parallel. DEPRECATED")
 	cmd.Flags().MarkHidden("parallel") //nolint:errcheck
 	cmd.Flags().Bool("compress", true, "Compress the build context using gzip. DEPRECATED")
@@ -103,12 +130,9 @@ func runBuild(ctx context.Context, backend api.Service, opts buildOptions, servi
 		return err
 	}
 
-	return backend.Build(ctx, project, api.BuildOptions{
-		Pull:     opts.pull,
-		Progress: opts.progress,
-		Args:     types.NewMappingWithEquals(opts.args),
-		NoCache:  opts.noCache,
-		Quiet:    opts.quiet,
-		Services: services,
-	})
+	apiBuildOptions, err := opts.toAPIBuildOptions(services)
+	if err != nil {
+		return err
+	}
+	return backend.Build(ctx, project, apiBuildOptions)
 }

cmd/compose/compose.go

@@ -27,8 +27,10 @@ import (
 
 	"github.com/compose-spec/compose-go/cli"
 	"github.com/compose-spec/compose-go/types"
+	composegoutils "github.com/compose-spec/compose-go/utils"
 	dockercli "github.com/docker/cli/cli"
 	"github.com/docker/cli/cli-plugins/manager"
+	"github.com/docker/cli/cli/command"
 	"github.com/morikuni/aec"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -88,9 +90,6 @@ func Adapt(fn Command) func(cmd *cobra.Command, args []string) error {
 	})
 }
 
-// Warning is a global warning to be displayed to user on command failure
-var Warning string
-
 type projectOptions struct {
 	ProjectName   string
 	Profiles      []string
@@ -131,8 +130,8 @@ func (o *projectOptions) addProjectFlags(f *pflag.FlagSet) {
 	f.StringVarP(&o.ProjectName, "project-name", "p", "", "Project name")
 	f.StringArrayVarP(&o.ConfigPaths, "file", "f", []string{}, "Compose configuration files")
 	f.StringVar(&o.EnvFile, "env-file", "", "Specify an alternate environment file.")
-	f.StringVar(&o.ProjectDir, "project-directory", "", "Specify an alternate working directory\n(default: the path of the Compose file)")
-	f.StringVar(&o.WorkDir, "workdir", "", "DEPRECATED! USE --project-directory INSTEAD.\nSpecify an alternate working directory\n(default: the path of the Compose file)")
+	f.StringVar(&o.ProjectDir, "project-directory", "", "Specify an alternate working directory\n(default: the path of the, first specified, Compose file)")
+	f.StringVar(&o.WorkDir, "workdir", "", "DEPRECATED! USE --project-directory INSTEAD.\nSpecify an alternate working directory\n(default: the path of the, first specified, Compose file)")
 	f.BoolVar(&o.Compatibility, "compatibility", false, "Run compose in backward compatibility mode")
 	_ = f.MarkHidden("workdir")
 }
@@ -142,6 +141,11 @@ func (o *projectOptions) toProjectName() (string, error) {
 		return o.ProjectName, nil
 	}
 
+	envProjectName := os.Getenv("COMPOSE_PROJECT_NAME")
+	if envProjectName != "" {
+		return envProjectName, nil
+	}
+
 	project, err := o.toProject(nil)
 	if err != nil {
 		return "", err
@@ -166,7 +170,10 @@ func (o *projectOptions) toProject(services []string, po ...cli.ProjectOptionsFn
 
 	ef := o.EnvFile
 	if ef != "" && !filepath.IsAbs(ef) {
-		ef = filepath.Join(project.WorkingDir, o.EnvFile)
+		ef, err = filepath.Abs(ef)
+		if err != nil {
+			return nil, err
+		}
 	}
 	for i, s := range project.Services {
 		s.CustomLabels = map[string]string{
@@ -207,9 +214,9 @@ func (o *projectOptions) toProjectOptions(po ...cli.ProjectOptionsFn) (*cli.Proj
 	return cli.NewProjectOptions(o.ConfigPaths,
 		append(po,
 			cli.WithWorkingDirectory(o.ProjectDir),
+			cli.WithOsEnv,
 			cli.WithEnvFile(o.EnvFile),
 			cli.WithDotEnv,
-			cli.WithOsEnv,
 			cli.WithConfigFileEnv,
 			cli.WithDefaultConfigPath,
 			cli.WithName(o.ProjectName))...)
@@ -224,7 +231,7 @@ func RunningAsStandalone() bool {
 }
 
 // RootCommand returns the compose command with its child commands
-func RootCommand(backend api.Service) *cobra.Command {
+func RootCommand(dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := projectOptions{}
 	var (
 		ansi    string
@@ -232,11 +239,11 @@ func RootCommand(backend api.Service) *cobra.Command {
 		verbose bool
 		version bool
 	)
-	command := &cobra.Command{
+	c := &cobra.Command{
 		Short:            "Docker Compose",
 		Use:              PluginName,
 		TraverseChildren: true,
-		// By default (no Run/RunE in parent command) for typos in subcommands, cobra displays the help of parent command but exit(0) !
+		// By default (no Run/RunE in parent c) for typos in subcommands, cobra displays the help of parent c but exit(0) !
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) == 0 {
 				return cmd.Help()
@@ -251,6 +258,10 @@ func RootCommand(backend api.Service) *cobra.Command {
 			}
 		},
 		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+			err := setEnvWithDotEnv(&opts)
+			if err != nil {
+				return err
+			}
 			parent := cmd.Root()
 			if parent != nil {
 				parentPrerun := parent.PersistentPreRunE
@@ -266,7 +277,7 @@ func RootCommand(backend api.Service) *cobra.Command {
 					return errors.New(`cannot specify DEPRECATED "--no-ansi" and "--ansi". Please use only "--ansi"`)
 				}
 				ansi = "never"
-				fmt.Fprint(os.Stderr, aec.Apply("option '--no-ansi' is DEPRECATED ! Please use '--ansi' instead.\n", aec.RedF))
+				fmt.Fprint(os.Stderr, "option '--no-ansi' is DEPRECATED ! Please use '--ansi' instead.\n")
 			}
 			if verbose {
 				logrus.SetLevel(logrus.TraceLevel)
@@ -289,7 +300,7 @@ func RootCommand(backend api.Service) *cobra.Command {
 		},
 	}
 
-	command.AddCommand(
+	c.AddCommand(
 		upCommand(&opts, backend),
 		downCommand(&opts, backend),
 		startCommand(&opts, backend),
@@ -300,9 +311,9 @@ func RootCommand(backend api.Service) *cobra.Command {
 		logsCommand(&opts, backend),
 		convertCommand(&opts, backend),
 		killCommand(&opts, backend),
-		runCommand(&opts, backend),
+		runCommand(&opts, dockerCli, backend),
 		removeCommand(&opts, backend),
-		execCommand(&opts, backend),
+		execCommand(&opts, dockerCli, backend),
 		pauseCommand(&opts, backend),
 		unpauseCommand(&opts, backend),
 		topCommand(&opts, backend),
@@ -316,14 +327,38 @@ func RootCommand(backend api.Service) *cobra.Command {
 		createCommand(&opts, backend),
 		copyCommand(&opts, backend),
 	)
-	command.Flags().SetInterspersed(false)
-	opts.addProjectFlags(command.Flags())
-	command.Flags().StringVar(&ansi, "ansi", "auto", `Control when to print ANSI control characters ("never"|"always"|"auto")`)
-	command.Flags().BoolVarP(&version, "version", "v", false, "Show the Docker Compose version information")
-	command.Flags().MarkHidden("version") //nolint:errcheck
-	command.Flags().BoolVar(&noAnsi, "no-ansi", false, `Do not print ANSI control characters (DEPRECATED)`)
-	command.Flags().MarkHidden("no-ansi") //nolint:errcheck
-	command.Flags().BoolVar(&verbose, "verbose", false, "Show more output")
-	command.Flags().MarkHidden("verbose") //nolint:errcheck
-	return command
+	c.Flags().SetInterspersed(false)
+	opts.addProjectFlags(c.Flags())
+	c.Flags().StringVar(&ansi, "ansi", "auto", `Control when to print ANSI control characters ("never"|"always"|"auto")`)
+	c.Flags().BoolVarP(&version, "version", "v", false, "Show the Docker Compose version information")
+	c.Flags().MarkHidden("version") //nolint:errcheck
+	c.Flags().BoolVar(&noAnsi, "no-ansi", false, `Do not print ANSI control characters (DEPRECATED)`)
+	c.Flags().MarkHidden("no-ansi") //nolint:errcheck
+	c.Flags().BoolVar(&verbose, "verbose", false, "Show more output")
+	c.Flags().MarkHidden("verbose") //nolint:errcheck
+	return c
+}
+
+func setEnvWithDotEnv(prjOpts *projectOptions) error {
+	options, err := prjOpts.toProjectOptions()
+	if err != nil {
+		return compose.WrapComposeError(err)
+	}
+	workingDir, err := options.GetWorkingDir()
+	if err != nil {
+		return err
+	}
+
+	envFromFile, err := cli.GetEnvFromFile(composegoutils.GetAsEqualsMap(os.Environ()), workingDir, options.EnvFile)
+	if err != nil {
+		return err
+	}
+	for k, v := range envFromFile {
+		if _, ok := os.LookupEnv(k); !ok {
+			if err := os.Setenv(k, v); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
 }

cmd/compose/cp.go

@@ -55,7 +55,7 @@ func copyCommand(p *projectOptions, backend api.Service) *cobra.Command {
 			}
 			return nil
 		}),
-		RunE: Adapt(func(ctx context.Context, args []string) error {
+		RunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
 			opts.source = args[0]
 			opts.destination = args[1]
 			return runCopy(ctx, backend, opts)
@@ -64,8 +64,10 @@ func copyCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	}
 
 	flags := copyCmd.Flags()
-	flags.IntVar(&opts.index, "index", 1, "Index of the container if there are multiple instances of a service [default: 1].")
+	flags.IntVar(&opts.index, "index", 0, "Index of the container if there are multiple instances of a service .")
 	flags.BoolVar(&opts.all, "all", false, "Copy to all the containers of the service.")
+	flags.MarkHidden("all")                                                                                                      //nolint:errcheck
+	flags.MarkDeprecated("all", "By default all the containers of the service will get the source file/directory to be copied.") //nolint:errcheck
 	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)")
 

cmd/compose/down.go

@@ -59,17 +59,17 @@ func downCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runDown(ctx, backend, opts)
 		}),
+		Args:              cobra.NoArgs,
 		ValidArgsFunction: noCompletion(),
 	}
 	flags := downCmd.Flags()
-	removeOrphans := utils.StringToBool(os.Getenv("COMPOSE_REMOVE_ORPHANS "))
+	removeOrphans := utils.StringToBool(os.Getenv("COMPOSE_REMOVE_ORPHANS"))
 	flags.BoolVar(&opts.removeOrphans, "remove-orphans", removeOrphans, "Remove containers for services not defined in the Compose file.")
 	flags.IntVarP(&opts.timeout, "timeout", "t", 10, "Specify a shutdown timeout in seconds")
 	flags.BoolVarP(&opts.volumes, "volumes", "v", false, " Remove named volumes declared in the `volumes` section of the Compose file and anonymous volumes attached to containers.")
 	flags.StringVar(&opts.images, "rmi", "", `Remove images used by services. "local" remove only images that don't have a custom tag ("local"|"all")`)
 	flags.SetNormalizeFunc(func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		switch name {
-		case "volume":
+		if name == "volume" {
 			name = "volumes"
 			logrus.Warn("--volume is deprecated, please use --volumes")
 		}

cmd/compose/exec.go

@@ -21,6 +21,7 @@ import (
 
 	"github.com/compose-spec/compose-go/types"
 	"github.com/docker/cli/cli"
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/compose"
 	"github.com/spf13/cobra"
@@ -34,14 +35,15 @@ type execOpts struct {
 	environment []string
 	workingDir  string
 
-	noTty      bool
-	user       string
-	detach     bool
-	index      int
-	privileged bool
+	noTty       bool
+	user        string
+	detach      bool
+	index       int
+	privileged  bool
+	interactive bool
 }
 
-func execCommand(p *projectOptions, backend api.Service) *cobra.Command {
+func execCommand(p *projectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := execOpts{
 		composeOptions: &composeOptions{
 			projectOptions: p,
@@ -67,12 +69,12 @@ func execCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	runCmd.Flags().IntVar(&opts.index, "index", 1, "index of the container if there are multiple instances of a service [default: 1].")
 	runCmd.Flags().BoolVarP(&opts.privileged, "privileged", "", false, "Give extended privileges to the process.")
 	runCmd.Flags().StringVarP(&opts.user, "user", "u", "", "Run the command as this user.")
-	runCmd.Flags().BoolVarP(&opts.noTty, "no-TTY", "T", false, "Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.")
+	runCmd.Flags().BoolVarP(&opts.noTty, "no-TTY", "T", !dockerCli.Out().IsTerminal(), "Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.")
 	runCmd.Flags().StringVarP(&opts.workingDir, "workdir", "w", "", "Path to workdir directory for this command.")
 
-	runCmd.Flags().BoolP("interactive", "i", true, "Keep STDIN open even if not attached. DEPRECATED")
+	runCmd.Flags().BoolVarP(&opts.interactive, "interactive", "i", true, "Keep STDIN open even if not attached.")
 	runCmd.Flags().MarkHidden("interactive") //nolint:errcheck
-	runCmd.Flags().BoolP("tty", "t", true, "Allocate a pseudo-TTY. DEPRECATED")
+	runCmd.Flags().BoolP("tty", "t", true, "Allocate a pseudo-TTY.")
 	runCmd.Flags().MarkHidden("tty") //nolint:errcheck
 
 	runCmd.Flags().SetInterspersed(false)
@@ -102,6 +104,7 @@ func runExec(ctx context.Context, backend api.Service, opts execOpts) error {
 		Index:       opts.index,
 		Detach:      opts.detach,
 		WorkingDir:  opts.workingDir,
+		Interactive: opts.interactive,
 	}
 
 	exitCode, err := backend.Exec(ctx, projectName, execOpts)

cmd/compose/kill.go

@@ -19,25 +19,44 @@ package compose
 import (
 	"context"
 
-	"github.com/compose-spec/compose-go/types"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
 )
 
+type killOptions struct {
+	*projectOptions
+	signal string
+}
+
 func killCommand(p *projectOptions, backend api.Service) *cobra.Command {
-	var opts api.KillOptions
+	opts := killOptions{
+		projectOptions: p,
+	}
 	cmd := &cobra.Command{
 		Use:   "kill [options] [SERVICE...]",
 		Short: "Force stop service containers.",
-		RunE: p.WithProject(func(ctx context.Context, project *types.Project) error {
-			return backend.Kill(ctx, project, opts)
+		RunE: Adapt(func(ctx context.Context, args []string) error {
+			return runKill(ctx, backend, opts, args)
 		}),
 		ValidArgsFunction: serviceCompletion(p),
 	}
 
 	flags := cmd.Flags()
-	flags.StringVarP(&opts.Signal, "signal", "s", "SIGKILL", "SIGNAL to send to the container.")
+	flags.StringVarP(&opts.signal, "signal", "s", "SIGKILL", "SIGNAL to send to the container.")
 
 	return cmd
 }
+
+func runKill(ctx context.Context, backend api.Service, opts killOptions, services []string) error {
+	projectName, err := opts.toProjectName()
+	if err != nil {
+		return err
+	}
+
+	return backend.Kill(ctx, projectName, api.KillOptions{
+		Services: services,
+		Signal:   opts.signal,
+	})
+
+}

cmd/compose/list.go

@@ -39,19 +39,19 @@ type lsOptions struct {
 }
 
 func listCommand(backend api.Service) *cobra.Command {
-	opts := lsOptions{Filter: opts.NewFilterOpt()}
+	lsOpts := lsOptions{Filter: opts.NewFilterOpt()}
 	lsCmd := &cobra.Command{
 		Use:   "ls",
 		Short: "List running compose projects",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runList(ctx, backend, opts)
+			return runList(ctx, backend, lsOpts)
 		}),
 		ValidArgsFunction: noCompletion(),
 	}
-	lsCmd.Flags().StringVar(&opts.Format, "format", "pretty", "Format the output. Values: [pretty | json].")
-	lsCmd.Flags().BoolVarP(&opts.Quiet, "quiet", "q", false, "Only display IDs.")
-	lsCmd.Flags().Var(&opts.Filter, "filter", "Filter output based on conditions provided.")
-	lsCmd.Flags().BoolVarP(&opts.All, "all", "a", false, "Show all stopped Compose projects")
+	lsCmd.Flags().StringVar(&lsOpts.Format, "format", "pretty", "Format the output. Values: [pretty | json].")
+	lsCmd.Flags().BoolVarP(&lsOpts.Quiet, "quiet", "q", false, "Only display IDs.")
+	lsCmd.Flags().Var(&lsOpts.Filter, "filter", "Filter output based on conditions provided.")
+	lsCmd.Flags().BoolVarP(&lsOpts.All, "all", "a", false, "Show all stopped Compose projects")
 
 	return lsCmd
 }
@@ -60,18 +60,18 @@ var acceptedListFilters = map[string]bool{
 	"name": true,
 }
 
-func runList(ctx context.Context, backend api.Service, opts lsOptions) error {
-	filters := opts.Filter.Value()
+func runList(ctx context.Context, backend api.Service, lsOpts lsOptions) error {
+	filters := lsOpts.Filter.Value()
 	err := filters.Validate(acceptedListFilters)
 	if err != nil {
 		return err
 	}
 
-	stackList, err := backend.List(ctx, api.ListOptions{All: opts.All})
+	stackList, err := backend.List(ctx, api.ListOptions{All: lsOpts.All})
 	if err != nil {
 		return err
 	}
-	if opts.Quiet {
+	if lsOpts.Quiet {
 		for _, s := range stackList {
 			fmt.Println(s.Name)
 		}
@@ -90,7 +90,7 @@ func runList(ctx context.Context, backend api.Service, opts lsOptions) error {
 	}
 
 	view := viewFromStackList(stackList)
-	return formatter.Print(view, opts.Format, os.Stdout, func(w io.Writer) {
+	return formatter.Print(view, lsOpts.Format, os.Stdout, func(w io.Writer) {
 		for _, stack := range view {
 			_, _ = fmt.Fprintf(w, "%s\t%s\t%s\n", stack.Name, stack.Status, stack.ConfigFiles)
 		}

cmd/compose/ps.go

@@ -27,6 +27,7 @@ import (
 
 	"github.com/docker/compose/v2/cmd/formatter"
 	"github.com/docker/compose/v2/pkg/utils"
+	"github.com/docker/docker/api/types"
 
 	formatter2 "github.com/docker/cli/cli/command/formatter"
 	"github.com/pkg/errors"
@@ -81,12 +82,11 @@ func psCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	}
 	flags := psCmd.Flags()
 	flags.StringVar(&opts.Format, "format", "pretty", "Format the output. Values: [pretty | json]")
-	flags.StringVar(&opts.Filter, "filter", "", "Filter services by a property. Deprecated, use --status instead")
+	flags.StringVar(&opts.Filter, "filter", "", "Filter services by a property (supported filters: status).")
 	flags.StringArrayVar(&opts.Status, "status", []string{}, "Filter services by status. Values: [paused | restarting | removing | running | dead | created | exited]")
 	flags.BoolVarP(&opts.Quiet, "quiet", "q", false, "Only display IDs")
 	flags.BoolVar(&opts.Services, "services", false, "Display services")
 	flags.BoolVarP(&opts.All, "all", "a", false, "Show all stopped containers (including those created by the run command)")
-	flags.Lookup("filter").Hidden = true
 	return psCmd
 }
 
@@ -140,14 +140,14 @@ SERVICES:
 	}
 
 	return formatter.Print(containers, opts.Format, os.Stdout,
-		writter(containers),
+		writer(containers),
 		"NAME", "COMMAND", "SERVICE", "STATUS", "PORTS")
 }
 
-func writter(containers []api.ContainerSummary) func(w io.Writer) {
+func writer(containers []api.ContainerSummary) func(w io.Writer) {
 	return func(w io.Writer) {
 		for _, container := range containers {
-			ports := DisplayablePorts(container)
+			ports := displayablePorts(container)
 			status := container.State
 			if status == "running" && container.Health != "" {
 				status = fmt.Sprintf("%s (%s)", container.State, container.Health)
@@ -179,72 +179,20 @@ func hasStatus(c api.ContainerSummary, statuses []string) bool {
 	return false
 }
 
-type portRange struct {
-	pStart   int
-	pEnd     int
-	tStart   int
-	tEnd     int
-	IP       string
-	protocol string
-}
-
-func (pr portRange) String() string {
-	var (
-		pub string
-		tgt string
-	)
-
-	if pr.pEnd > pr.pStart {
-		pub = fmt.Sprintf("%s:%d-%d->", pr.IP, pr.pStart, pr.pEnd)
-	} else if pr.pStart > 0 {
-		pub = fmt.Sprintf("%s:%d->", pr.IP, pr.pStart)
-	}
-	if pr.tEnd > pr.tStart {
-		tgt = fmt.Sprintf("%d-%d", pr.tStart, pr.tEnd)
-	} else {
-		tgt = fmt.Sprintf("%d", pr.tStart)
-	}
-	return fmt.Sprintf("%s%s/%s", pub, tgt, pr.protocol)
-}
-
-// DisplayablePorts is copy pasted from https://github.com/docker/cli/pull/581/files
-func DisplayablePorts(c api.ContainerSummary) string {
+func displayablePorts(c api.ContainerSummary) string {
 	if c.Publishers == nil {
 		return ""
 	}
 
-	sort.Sort(c.Publishers)
-
-	pr := portRange{}
-	ports := []string{}
-	for _, p := range c.Publishers {
-		prIsRange := pr.tEnd != pr.tStart
-		tOverlaps := p.TargetPort <= pr.tEnd
-
-		// Start a new port-range if:
-		// - the protocol is different from the current port-range
-		// - published or target port are not consecutive to the current port-range
-		// - the current port-range is a _range_, and the target port overlaps with the current range's target-ports
-		if p.Protocol != pr.protocol || p.URL != pr.IP || p.PublishedPort-pr.pEnd > 1 || p.TargetPort-pr.tEnd > 1 || prIsRange && tOverlaps {
-			// start a new port-range, and print the previous port-range (if any)
-			if pr.pStart > 0 {
-				ports = append(ports, pr.String())
-			}
-			pr = portRange{
-				pStart:   p.PublishedPort,
-				pEnd:     p.PublishedPort,
-				tStart:   p.TargetPort,
-				tEnd:     p.TargetPort,
-				protocol: p.Protocol,
-				IP:       p.URL,
-			}
-			continue
+	ports := make([]types.Port, len(c.Publishers))
+	for i, pub := range c.Publishers {
+		ports[i] = types.Port{
+			IP:          pub.URL,
+			PrivatePort: uint16(pub.TargetPort),
+			PublicPort:  uint16(pub.PublishedPort),
+			Type:        pub.Protocol,
 		}
-		pr.pEnd = p.PublishedPort
-		pr.tEnd = p.TargetPort
 	}
-	if pr.tStart > 0 {
-		ports = append(ports, pr.String())
-	}
-	return strings.Join(ports, ", ")
+
+	return formatter2.DisplayablePorts(ports)
 }

cmd/compose/ps_test.go

@@ -0,0 +1,84 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/mocks"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPsPretty(t *testing.T) {
+	ctx := context.Background()
+	origStdout := os.Stdout
+	t.Cleanup(func() {
+		os.Stdout = origStdout
+	})
+	dir := t.TempDir()
+	f, err := os.Create(filepath.Join(dir, "output.txt"))
+	if err != nil {
+		t.Fatal("could not create output file")
+	}
+	defer func() { _ = f.Close() }()
+
+	os.Stdout = f
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	backend := mocks.NewMockService(ctrl)
+	backend.EXPECT().
+		Ps(gomock.Eq(ctx), gomock.Any(), gomock.Any()).
+		DoAndReturn(func(ctx context.Context, projectName string, options api.PsOptions) ([]api.ContainerSummary, error) {
+			return []api.ContainerSummary{
+				{
+					ID:   "abc123",
+					Name: "ABC",
+					Publishers: api.PortPublishers{
+						{
+							TargetPort:    8080,
+							PublishedPort: 8080,
+							Protocol:      "tcp",
+						},
+						{
+							TargetPort:    8443,
+							PublishedPort: 8443,
+							Protocol:      "tcp",
+						},
+					},
+				},
+			}, nil
+		}).AnyTimes()
+
+	opts := psOptions{projectOptions: &projectOptions{ProjectName: "test"}}
+	err = runPs(ctx, backend, nil, opts)
+	assert.NoError(t, err)
+
+	_, err = f.Seek(0, 0)
+	assert.NoError(t, err)
+
+	output := make([]byte, 256)
+	_, err = f.Read(output)
+	assert.NoError(t, err)
+
+	assert.Contains(t, string(output), "8080/tcp, 8443/tcp")
+}

cmd/compose/run.go

@@ -24,6 +24,7 @@ import (
 	cgo "github.com/compose-spec/compose-go/cli"
 	"github.com/compose-spec/compose-go/loader"
 	"github.com/compose-spec/compose-go/types"
+	"github.com/docker/cli/cli/command"
 	"github.com/mattn/go-shellwords"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -62,6 +63,9 @@ func (opts runOptions) apply(project *types.Project) error {
 	if err != nil {
 		return err
 	}
+
+	target.Tty = !opts.noTty
+	target.StdinOpen = opts.interactive
 	if !opts.servicePorts {
 		target.Ports = []types.ServicePortConfig{}
 	}
@@ -103,7 +107,7 @@ func (opts runOptions) apply(project *types.Project) error {
 	return nil
 }
 
-func runCommand(p *projectOptions, backend api.Service) *cobra.Command {
+func runCommand(p *projectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
 	opts := runOptions{
 		composeOptions: &composeOptions{
 			projectOptions: p,
@@ -146,7 +150,7 @@ func runCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	flags.StringArrayVarP(&opts.environment, "env", "e", []string{}, "Set environment variables")
 	flags.StringArrayVarP(&opts.labels, "label", "l", []string{}, "Add or override a label")
 	flags.BoolVar(&opts.Remove, "rm", false, "Automatically remove the container when it exits")
-	flags.BoolVarP(&opts.noTty, "no-TTY", "T", false, "Disable pseudo-noTty allocation. By default docker compose run allocates a TTY")
+	flags.BoolVarP(&opts.noTty, "no-TTY", "T", !dockerCli.Out().IsTerminal(), "Disable pseudo-TTY allocation (default: auto-detected).")
 	flags.StringVar(&opts.name, "name", "", " Assign a name to the container")
 	flags.StringVarP(&opts.user, "user", "u", "", "Run as specified username or uid")
 	flags.StringVarP(&opts.workdir, "workdir", "w", "", "Working directory inside the container")
@@ -207,6 +211,7 @@ func runRun(ctx context.Context, backend api.Service, project *types.Project, op
 		Detach:            opts.Detach,
 		AutoRemove:        opts.Remove,
 		Tty:               !opts.noTty,
+		Interactive:       opts.interactive,
 		WorkingDir:        opts.workdir,
 		User:              opts.user,
 		Environment:       opts.environment,
@@ -257,7 +262,9 @@ func startDependencies(ctx context.Context, backend api.Service, project types.P
 	}
 
 	if len(dependencies) > 0 {
-		return backend.Start(ctx, project.Name, api.StartOptions{})
+		return backend.Start(ctx, project.Name, api.StartOptions{
+			Project: &project,
+		})
 	}
 	return nil
 }

cmd/compose/up.go

@@ -185,6 +185,9 @@ func runUp(ctx context.Context, backend api.Service, createOptions createOptions
 	if upOptions.attachDependencies {
 		attachTo = project.ServiceNames()
 	}
+	if len(attachTo) == 0 {
+		attachTo = project.ServiceNames()
+	}
 
 	create := api.CreateOptions{
 		Services:             services,
@@ -204,6 +207,7 @@ func runUp(ctx context.Context, backend api.Service, createOptions createOptions
 	return backend.Up(ctx, project, api.UpOptions{
 		Create: create,
 		Start: api.StartOptions{
+			Project:      project,
 			Attach:       consumer,
 			AttachTo:     attachTo,
 			ExitCodeFrom: upOptions.exitCodeFrom,
@@ -215,18 +219,20 @@ func runUp(ctx context.Context, backend api.Service, createOptions createOptions
 
 func setServiceScale(project *types.Project, name string, replicas uint64) error {
 	for i, s := range project.Services {
-		if s.Name == name {
-			service, err := project.GetService(name)
-			if err != nil {
-				return err
-			}
-			if service.Deploy == nil {
-				service.Deploy = &types.DeployConfig{}
-			}
-			service.Deploy.Replicas = &replicas
-			project.Services[i] = service
-			return nil
+		if s.Name != name {
+			continue
 		}
+
+		service, err := project.GetService(name)
+		if err != nil {
+			return err
+		}
+		if service.Deploy == nil {
+			service.Deploy = &types.DeployConfig{}
+		}
+		service.Deploy.Replicas = &replicas
+		project.Services[i] = service
+		return nil
 	}
 	return fmt.Errorf("unknown service %q", name)
 }

cmd/formatter/logs.go

@@ -27,6 +27,16 @@ import (
 	"github.com/docker/compose/v2/pkg/api"
 )
 
+// LogConsumer consume logs from services and format them
+type logConsumer struct {
+	ctx        context.Context
+	presenters sync.Map // map[string]*presenter
+	width      int
+	writer     io.Writer
+	color      bool
+	prefix     bool
+}
+
 // NewLogConsumer creates a new LogConsumer
 func NewLogConsumer(ctx context.Context, w io.Writer, color bool, prefix bool) api.LogConsumer {
 	return &logConsumer{
@@ -79,14 +89,14 @@ func (l *logConsumer) Log(container, service, message string) {
 	}
 	p := l.getPresenter(container)
 	for _, line := range strings.Split(message, "\n") {
-		fmt.Fprintf(l.writer, "%s %s\n", p.prefix, line) // nolint:errcheck
+		fmt.Fprintf(l.writer, "%s%s\n", p.prefix, line) //nolint:errcheck
 	}
 }
 
 func (l *logConsumer) Status(container, msg string) {
 	p := l.getPresenter(container)
 	s := p.colors(fmt.Sprintf("%s %s\n", container, msg))
-	l.writer.Write([]byte(s)) // nolint:errcheck
+	l.writer.Write([]byte(s)) //nolint:errcheck
 }
 
 func (l *logConsumer) computeWidth() {
@@ -101,16 +111,6 @@ func (l *logConsumer) computeWidth() {
 	l.width = width + 1
 }
 
-// LogConsumer consume logs from services and format them
-type logConsumer struct {
-	ctx        context.Context
-	presenters sync.Map // map[string]*presenter
-	width      int
-	writer     io.Writer
-	color      bool
-	prefix     bool
-}
-
 type presenter struct {
 	colors colorFunc
 	name   string
@@ -118,5 +118,5 @@ type presenter struct {
 }
 
 func (p *presenter) setPrefix(width int) {
-	p.prefix = p.colors(fmt.Sprintf("%-"+strconv.Itoa(width)+"s |", p.name))
+	p.prefix = p.colors(fmt.Sprintf("%-"+strconv.Itoa(width)+"s | ", p.name))
 }

cmd/main.go

@@ -32,15 +32,10 @@ import (
 	"github.com/docker/compose/v2/pkg/compose"
 )
 
-func init() {
-	commands.Warning = "The new 'docker compose' command is currently experimental. " +
-		"To provide feedback or request new features please open issues at https://github.com/docker/compose"
-}
-
 func pluginMain() {
 	plugin.Run(func(dockerCli command.Cli) *cobra.Command {
 		lazyInit := api.NewServiceProxy()
-		cmd := commands.RootCommand(lazyInit)
+		cmd := commands.RootCommand(dockerCli, lazyInit)
 		originalPreRun := cmd.PersistentPreRunE
 		cmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
 			if err := plugin.PersistentPreRunE(cmd, args); err != nil {
@@ -68,7 +63,7 @@ func pluginMain() {
 }
 
 func main() {
-	if commands.RunningAsStandalone() {
+	if plugin.RunningStandalone() {
 		os.Args = append([]string{"docker"}, compatibility.Convert(os.Args[1:])...)
 	}
 	pluginMain()

docs/docs.Dockerfile

@@ -0,0 +1,57 @@
+# syntax=docker/dockerfile:1.3-labs
+
+
+#   Copyright 2020 Docker Compose CLI authors
+
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+
+#       http://www.apache.org/licenses/LICENSE-2.0
+
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+ARG GO_VERSION=1.18.4
+ARG FORMATS=md,yaml
+
+FROM --platform=${BUILDPLATFORM} golang:${GO_VERSION}-alpine AS docsgen
+WORKDIR /src
+RUN --mount=target=. \
+  --mount=target=/root/.cache,type=cache \
+  go build -o /out/docsgen ./docs/yaml/main/generate.go
+
+FROM --platform=${BUILDPLATFORM} alpine AS gen
+RUN apk add --no-cache rsync git
+WORKDIR /src
+COPY --from=docsgen /out/docsgen /usr/bin
+ARG FORMATS
+RUN --mount=target=/context \
+  --mount=target=.,type=tmpfs <<EOT
+set -e
+rsync -a /context/. .
+docsgen --formats "$FORMATS" --source "docs/reference"
+mkdir /out
+cp -r docs/reference /out
+EOT
+
+FROM scratch AS update
+COPY --from=gen /out /out
+
+FROM gen AS validate
+RUN --mount=target=/context \
+  --mount=target=.,type=tmpfs <<EOT
+set -e
+rsync -a /context/. .
+git add -A
+rm -rf docs/reference/*
+cp -rf /out/* ./docs/
+if [ -n "$(git status --porcelain -- docs/reference)" ]; then
+  echo >&2 'ERROR: Docs result differs. Please update with "make docs"'
+  git status --porcelain -- docs/reference
+  exit 1
+fi
+EOT

docs/reference/compose.md

@@ -44,7 +44,7 @@ Docker Compose
 | `-f`, `--file` | `stringArray` |  | Compose configuration files |
 | `--profile` | `stringArray` |  | Specify a profile to enable |
 | `--project-directory` | `string` |  | Specify an alternate working directory
-(default: the path of the Compose file) |
+(default: the path of the, first specified, Compose file) |
 | `-p`, `--project-name` | `string` |  | Project name |
 
 

docs/reference/compose_build.md

@@ -12,6 +12,7 @@ Build or rebuild services
 | `--progress` | `string` | `auto` | Set type of progress output (auto, tty, plain, quiet) |
 | `--pull` |  |  | Always attempt to pull a newer version of the image. |
 | `-q`, `--quiet` |  |  | Don't print anything to STDOUT |
+| `--ssh` | `string` |  | Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent) |
 
 
 <!---MARKER_GEN_END-->

docs/reference/compose_cp.md

@@ -7,10 +7,9 @@ Copy files/folders between a service container and the local filesystem
 
 | Name | Type | Default | Description |
 | --- | --- | --- | --- |
-| `--all` |  |  | Copy to all the containers of the service. |
 | `-a`, `--archive` |  |  | Archive mode (copy all uid/gid information) |
 | `-L`, `--follow-link` |  |  | Always follow symbol link in SRC_PATH |
-| `--index` | `int` | `1` | Index of the container if there are multiple instances of a service [default: 1]. |
+| `--index` | `int` | `0` | Index of the container if there are multiple instances of a service . |
 
 
 <!---MARKER_GEN_END-->

docs/reference/compose_ps.md

@@ -8,10 +8,11 @@ List containers
 | Name | Type | Default | Description |
 | --- | --- | --- | --- |
 | `-a`, `--all` |  |  | Show all stopped containers (including those created by the run command) |
-| `--format` | `string` | `pretty` | Format the output. Values: [pretty \| json] |
+| [`--filter`](#filter) | `string` |  | Filter services by a property (supported filters: status). |
+| [`--format`](#format) | `string` | `pretty` | Format the output. Values: [pretty \| json] |
 | `-q`, `--quiet` |  |  | Only display IDs |
 | `--services` |  |  | Display services |
-| `--status` | `stringArray` |  | Filter services by status. Values: [paused \| restarting \| removing \| running \| dead \| created \| exited] |
+| [`--status`](#status) | `stringArray` |  | Filter services by status. Values: [paused \| restarting \| removing \| running \| dead \| created \| exited] |
 
 
 <!---MARKER_GEN_END-->
@@ -19,10 +20,98 @@ List containers
 ## Description
 
 Lists containers for a Compose project, with current status and exposed ports.
+By default, both running and stopped containers are shown:
 
 ```console
 $ docker compose ps
-NAME                SERVICE             STATUS              PORTS
-example_foo_1       foo                 running (healthy)   0.0.0.0:8000->80/tcp
-example_bar_1       bar                 exited (1)
+NAME           COMMAND                  SERVICE   STATUS       PORTS
+example-bar-1  "/docker-entrypoint.…"   bar       exited (0)
+example-foo-1  "/docker-entrypoint.…"   foo       running      0.0.0.0:8080->80/tcp
 ```
+
+## Examples
+
+### <a name="format"></a> Format the output (--format)
+
+By default, the `docker compose ps` command uses a table ("pretty") format to
+show the containers. The `--format` flag allows you to specify alternative
+presentations for the output. Currently supported options are `pretty` (default),
+and `json`, which outputs information about the containers as a JSON array:
+
+```console
+$ docker compose ps --format json
+[{"ID":"1553b0236cf4d2715845f053a4ee97042c4f9a2ef655731ee34f1f7940eaa41a","Name":"example-bar-1","Command":"/docker-entrypoint.sh nginx -g 'daemon off;'","Project":"example","Service":"bar","State":"exited","Health":"","ExitCode":0,"Publishers":null},{"ID":"f02a4efaabb67416e1ff127d51c4b5578634a0ad5743bd65225ff7d1909a3fa0","Name":"example-foo-1","Command":"/docker-entrypoint.sh nginx -g 'daemon off;'","Project":"example","Service":"foo","State":"running","Health":"","ExitCode":0,"Publishers":[{"URL":"0.0.0.0","TargetPort":80,"PublishedPort":8080,"Protocol":"tcp"}]}]
+```
+
+The JSON output allows you to use the information in other tools for further
+processing, for example, using the [`jq` utility](https://stedolan.github.io/jq/){:target="_blank" rel="noopener" class="_"}
+to pretty-print the JSON:
+
+```console
+$ docker compose ps --format json | jq .
+[
+  {
+    "ID": "1553b0236cf4d2715845f053a4ee97042c4f9a2ef655731ee34f1f7940eaa41a",
+    "Name": "example-bar-1",
+    "Command": "/docker-entrypoint.sh nginx -g 'daemon off;'",
+    "Project": "example",
+    "Service": "bar",
+    "State": "exited",
+    "Health": "",
+    "ExitCode": 0,
+    "Publishers": null
+  },
+  {
+    "ID": "f02a4efaabb67416e1ff127d51c4b5578634a0ad5743bd65225ff7d1909a3fa0",
+    "Name": "example-foo-1",
+    "Command": "/docker-entrypoint.sh nginx -g 'daemon off;'",
+    "Project": "example",
+    "Service": "foo",
+    "State": "running",
+    "Health": "",
+    "ExitCode": 0,
+    "Publishers": [
+      {
+        "URL": "0.0.0.0",
+        "TargetPort": 80,
+        "PublishedPort": 8080,
+        "Protocol": "tcp"
+      }
+    ]
+  }
+]
+```
+
+### <a name="status"></a> Filter containers by status (--status)
+
+Use the `--status` flag to filter the list of containers by status. For example,
+to show only containers that are running, or only containers that have exited:
+
+```console
+$ docker compose ps --status=running
+NAME           COMMAND                  SERVICE   STATUS       PORTS
+example-foo-1  "/docker-entrypoint.…"   foo       running      0.0.0.0:8080->80/tcp
+
+$ docker compose ps --status=exited
+NAME           COMMAND                  SERVICE   STATUS       PORTS
+example-bar-1  "/docker-entrypoint.…"   bar       exited (0)
+```
+
+### <a name="filter"></a> Filter containers by status (--filter)
+
+The [`--status` flag](#status) is a convenience shorthand for the `--filter status=<status>`
+flag. The example below is the equivalent to the example from the previous section,
+this time using the `--filter` flag:
+
+```console
+$ docker compose ps --filter status=running
+NAME           COMMAND                  SERVICE   STATUS       PORTS
+example-foo-1  "/docker-entrypoint.…"   foo       running      0.0.0.0:8080->80/tcp
+
+$ docker compose ps --filter status=running
+NAME           COMMAND                  SERVICE   STATUS       PORTS
+example-bar-1  "/docker-entrypoint.…"   bar       exited (0)
+```
+
+The `docker compose ps` command currently only supports the `--filter status=<status>`
+option, but additional filter options may be added in future.

docs/reference/compose_pull.md

@@ -61,4 +61,4 @@ $ docker compose pull db
    ⠹ f63c47038e66 Waiting                                                  9.3s
    ⠹ 77a0c198cde5 Waiting                                                  9.3s
    ⠹ c8752d5b785c Waiting                                                  9.3s
-``̀`
+```

docs/reference/compose_run.md

@@ -13,7 +13,7 @@ Run a one-off command on a service.
 | `-i`, `--interactive` |  |  | Keep STDIN open even if not attached. |
 | `-l`, `--label` | `stringArray` |  | Add or override a label |
 | `--name` | `string` |  |  Assign a name to the container |
-| `-T`, `--no-TTY` |  |  | Disable pseudo-noTty allocation. By default docker compose run allocates a TTY |
+| `-T`, `--no-TTY` |  |  | Disable pseudo-TTY allocation (default: auto-detected). |
 | `--no-deps` |  |  | Don't start linked services. |
 | `-p`, `--publish` | `stringArray` |  | Publish a container's port(s) to the host. |
 | `--quiet-pull` |  |  | Pull without printing progress information. |

docs/reference/docker_compose.yaml

@@ -222,7 +222,7 @@ options:
   value_type: string
   description: |-
     Specify an alternate working directory
-    (default: the path of the Compose file)
+    (default: the path of the, first specified, Compose file)
   deprecated: false
   hidden: false
   experimental: false
@@ -265,7 +265,7 @@ options:
   description: |-
     DEPRECATED! USE --project-directory INSTEAD.
     Specify an alternate working directory
-    (default: the path of the Compose file)
+    (default: the path of the, first specified, Compose file)
   deprecated: false
   hidden: true
   experimental: false

docs/reference/docker_compose_build.yaml

@@ -117,6 +117,16 @@ options:
   experimentalcli: false
   kubernetes: false
   swarm: false
+- option: ssh
+  value_type: string
+  description: |
+    Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent)
+  deprecated: false
+  hidden: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_cp.yaml

@@ -10,8 +10,8 @@ options:
   value_type: bool
   default_value: "false"
   description: Copy to all the containers of the service.
-  deprecated: false
-  hidden: false
+  deprecated: true
+  hidden: true
   experimental: false
   experimentalcli: false
   kubernetes: false
@@ -40,9 +40,9 @@ options:
   swarm: false
 - option: index
   value_type: int
-  default_value: "1"
+  default_value: "0"
   description: |
-    Index of the container if there are multiple instances of a service [default: 1].
+    Index of the container if there are multiple instances of a service .
   deprecated: false
   hidden: false
   experimental: false

docs/reference/docker_compose_exec.yaml

@@ -46,7 +46,7 @@ options:
   shorthand: i
   value_type: bool
   default_value: "true"
-  description: Keep STDIN open even if not attached. DEPRECATED
+  description: Keep STDIN open even if not attached.
   deprecated: false
   hidden: true
   experimental: false
@@ -56,7 +56,7 @@ options:
 - option: no-TTY
   shorthand: T
   value_type: bool
-  default_value: "false"
+  default_value: "true"
   description: |
     Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.
   deprecated: false
@@ -79,7 +79,7 @@ options:
   shorthand: t
   value_type: bool
   default_value: "true"
-  description: Allocate a pseudo-TTY. DEPRECATED
+  description: Allocate a pseudo-TTY.
   deprecated: false
   hidden: true
   experimental: false

docs/reference/docker_compose_ps.yaml

@@ -2,12 +2,13 @@ command: docker compose ps
 short: List containers
 long: |-
   Lists containers for a Compose project, with current status and exposed ports.
+  By default, both running and stopped containers are shown:
 
   ```console
   $ docker compose ps
-  NAME                SERVICE             STATUS              PORTS
-  example_foo_1       foo                 running (healthy)   0.0.0.0:8000->80/tcp
-  example_bar_1       bar                 exited (1)
+  NAME           COMMAND                  SERVICE   STATUS       PORTS
+  example-bar-1  "/docker-entrypoint.…"   bar       exited (0)
+  example-foo-1  "/docker-entrypoint.…"   foo       running      0.0.0.0:8080->80/tcp
   ```
 usage: docker compose ps [SERVICE...]
 pname: docker compose
@@ -27,9 +28,10 @@ options:
   swarm: false
 - option: filter
   value_type: string
-  description: Filter services by a property. Deprecated, use --status instead
+  description: 'Filter services by a property (supported filters: status).'
+  details_url: '#filter'
   deprecated: false
-  hidden: true
+  hidden: false
   experimental: false
   experimentalcli: false
   kubernetes: false
@@ -38,6 +40,7 @@ options:
   value_type: string
   default_value: pretty
   description: 'Format the output. Values: [pretty | json]'
+  details_url: '#format'
   deprecated: false
   hidden: false
   experimental: false
@@ -70,12 +73,98 @@ options:
   default_value: '[]'
   description: |
     Filter services by status. Values: [paused | restarting | removing | running | dead | created | exited]
+  details_url: '#status'
   deprecated: false
   hidden: false
   experimental: false
   experimentalcli: false
   kubernetes: false
   swarm: false
+examples: |-
+  ### Format the output (--format) {#format}
+
+  By default, the `docker compose ps` command uses a table ("pretty") format to
+  show the containers. The `--format` flag allows you to specify alternative
+  presentations for the output. Currently supported options are `pretty` (default),
+  and `json`, which outputs information about the containers as a JSON array:
+
+  ```console
+  $ docker compose ps --format json
+  [{"ID":"1553b0236cf4d2715845f053a4ee97042c4f9a2ef655731ee34f1f7940eaa41a","Name":"example-bar-1","Command":"/docker-entrypoint.sh nginx -g 'daemon off;'","Project":"example","Service":"bar","State":"exited","Health":"","ExitCode":0,"Publishers":null},{"ID":"f02a4efaabb67416e1ff127d51c4b5578634a0ad5743bd65225ff7d1909a3fa0","Name":"example-foo-1","Command":"/docker-entrypoint.sh nginx -g 'daemon off;'","Project":"example","Service":"foo","State":"running","Health":"","ExitCode":0,"Publishers":[{"URL":"0.0.0.0","TargetPort":80,"PublishedPort":8080,"Protocol":"tcp"}]}]
+  ```
+
+  The JSON output allows you to use the information in other tools for further
+  processing, for example, using the [`jq` utility](https://stedolan.github.io/jq/){:target="_blank" rel="noopener" class="_"}
+  to pretty-print the JSON:
+
+  ```console
+  $ docker compose ps --format json | jq .
+  [
+    {
+      "ID": "1553b0236cf4d2715845f053a4ee97042c4f9a2ef655731ee34f1f7940eaa41a",
+      "Name": "example-bar-1",
+      "Command": "/docker-entrypoint.sh nginx -g 'daemon off;'",
+      "Project": "example",
+      "Service": "bar",
+      "State": "exited",
+      "Health": "",
+      "ExitCode": 0,
+      "Publishers": null
+    },
+    {
+      "ID": "f02a4efaabb67416e1ff127d51c4b5578634a0ad5743bd65225ff7d1909a3fa0",
+      "Name": "example-foo-1",
+      "Command": "/docker-entrypoint.sh nginx -g 'daemon off;'",
+      "Project": "example",
+      "Service": "foo",
+      "State": "running",
+      "Health": "",
+      "ExitCode": 0,
+      "Publishers": [
+        {
+          "URL": "0.0.0.0",
+          "TargetPort": 80,
+          "PublishedPort": 8080,
+          "Protocol": "tcp"
+        }
+      ]
+    }
+  ]
+  ```
+
+  ### Filter containers by status (--status) {#status}
+
+  Use the `--status` flag to filter the list of containers by status. For example,
+  to show only containers that are running, or only containers that have exited:
+
+  ```console
+  $ docker compose ps --status=running
+  NAME           COMMAND                  SERVICE   STATUS       PORTS
+  example-foo-1  "/docker-entrypoint.…"   foo       running      0.0.0.0:8080->80/tcp
+
+  $ docker compose ps --status=exited
+  NAME           COMMAND                  SERVICE   STATUS       PORTS
+  example-bar-1  "/docker-entrypoint.…"   bar       exited (0)
+  ```
+
+  ### Filter containers by status (--filter) {#filter}
+
+  The [`--status` flag](#status) is a convenience shorthand for the `--filter status=<status>`
+  flag. The example below is the equivalent to the example from the previous section,
+  this time using the `--filter` flag:
+
+  ```console
+  $ docker compose ps --filter status=running
+  NAME           COMMAND                  SERVICE   STATUS       PORTS
+  example-foo-1  "/docker-entrypoint.…"   foo       running      0.0.0.0:8080->80/tcp
+
+  $ docker compose ps --filter status=running
+  NAME           COMMAND                  SERVICE   STATUS       PORTS
+  example-bar-1  "/docker-entrypoint.…"   bar       exited (0)
+  ```
+
+  The `docker compose ps` command currently only supports the `--filter status=<status>`
+  option, but additional filter options may be added in future.
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_pull.yaml

@@ -98,7 +98,7 @@ examples: |-
      ⠹ f63c47038e66 Waiting                                                  9.3s
      ⠹ 77a0c198cde5 Waiting                                                  9.3s
      ⠹ c8752d5b785c Waiting                                                  9.3s
-  ``̀`
+  ```
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_run.yaml

@@ -124,9 +124,8 @@ options:
 - option: no-TTY
   shorthand: T
   value_type: bool
-  default_value: "false"
-  description: |
-    Disable pseudo-noTty allocation. By default docker compose run allocates a TTY
+  default_value: "true"
+  description: 'Disable pseudo-TTY allocation (default: auto-detected).'
   deprecated: false
   hidden: false
   experimental: false

docs/yaml/main/generate.go

@@ -22,16 +22,21 @@ import (
 	"path/filepath"
 
 	clidocstool "github.com/docker/cli-docs-tool"
+	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/cmd/compose"
 	"github.com/spf13/cobra"
 )
 
 func generateDocs(opts *options) error {
+	dockerCLI, err := command.NewDockerCli()
+	if err != nil {
+		return err
+	}
 	cmd := &cobra.Command{
 		Use:               "docker",
 		DisableAutoGenTag: true,
 	}
-	cmd.AddCommand(compose.RootCommand(nil))
+	cmd.AddCommand(compose.RootCommand(dockerCLI, nil))
 	disableFlagsInUseLine(cmd)
 
 	tool, err := clidocstool.New(clidocstool.Options{

go.mod

@@ -1,144 +1,153 @@
 module github.com/docker/compose/v2
 
-go 1.17
+go 1.18
 
 require (
-	github.com/AlecAivazis/survey/v2 v2.3.2
+	github.com/AlecAivazis/survey/v2 v2.3.5
 	github.com/buger/goterm v1.0.4
-	github.com/cnabio/cnab-to-oci v0.3.1-beta1
-	github.com/compose-spec/compose-go v1.1.0
+	github.com/cnabio/cnab-to-oci v0.3.5
+	github.com/compose-spec/compose-go v1.2.9
 	github.com/containerd/console v1.0.3
-	github.com/containerd/containerd v1.6.1
+	github.com/containerd/containerd v1.6.6
 	github.com/distribution/distribution/v3 v3.0.0-20210316161203-a01c71e2477e
-	github.com/docker/buildx v0.7.1
-	github.com/docker/cli v20.10.12+incompatible
+	github.com/docker/buildx v0.8.2 // when updating, also update the replace rules accordingly
+	github.com/docker/cli v20.10.17+incompatible
 	github.com/docker/cli-docs-tool v0.4.0
-	github.com/docker/docker v20.10.7+incompatible
+	github.com/docker/docker v20.10.17+incompatible
 	github.com/docker/go-connections v0.4.0
 	github.com/docker/go-units v0.4.0
 	github.com/golang/mock v1.6.0
 	github.com/hashicorp/go-multierror v1.1.1
-	github.com/hashicorp/go-version v1.3.0
+	github.com/hashicorp/go-version v1.6.0
 	github.com/mattn/go-isatty v0.0.14
 	github.com/mattn/go-shellwords v1.0.12
-	github.com/moby/buildkit v0.9.1-0.20211019185819-8778943ac3da
+	github.com/moby/buildkit v0.10.1-0.20220403220257-10e6f94bf90d
 	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6
 	github.com/morikuni/aec v1.0.0
 	github.com/opencontainers/go-digest v1.0.0
-	github.com/opencontainers/image-spec v1.0.2
+	github.com/opencontainers/image-spec v1.0.3-0.20211202183452-c5a74bcca799
 	github.com/pkg/errors v0.9.1
 	github.com/sanathkr/go-yaml v0.0.0-20170819195128-ed9d249f429b
-	github.com/sirupsen/logrus v1.8.1
-	github.com/spf13/cobra v1.3.0
+	github.com/sirupsen/logrus v1.9.0
+	github.com/spf13/cobra v1.5.0
 	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.7.0
-	github.com/theupdateframework/notary v0.6.1
+	github.com/stretchr/testify v1.8.0
+	github.com/theupdateframework/notary v0.7.0
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 	gotest.tools v2.2.0+incompatible
-	gotest.tools/v3 v3.1.0
+	gotest.tools/v3 v3.3.0
 )
 
 require (
 	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
 	github.com/Masterminds/semver v1.5.0 // indirect
-	github.com/Microsoft/go-winio v0.5.1 // indirect
-	github.com/agl/ed25519 v0.0.0-20170116200512-5312a6153412 // indirect
+	github.com/Microsoft/go-winio v0.5.2 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.1.2 // indirect
-	github.com/cnabio/cnab-go v0.10.0-beta1 // indirect
+	github.com/cnabio/cnab-go v0.23.4 // indirect
 	github.com/containerd/continuity v0.2.2 // indirect
+	github.com/containerd/ttrpc v1.1.0 // indirect
 	github.com/containerd/typeurl v1.0.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/docker/distribution v2.8.0+incompatible // indirect
+	github.com/docker/distribution v2.8.1+incompatible // indirect
 	github.com/docker/docker-credential-helpers v0.6.4 // indirect
 	github.com/docker/go v1.5.1-1.0.20160303222718-d30aec9fd63c // indirect
 	github.com/docker/go-metrics v0.0.1 // indirect
 	github.com/felixge/httpsnoop v1.0.2 // indirect
-	github.com/fvbommel/sortorder v1.0.1 // indirect
+	github.com/fvbommel/sortorder v1.0.2 // indirect
 	github.com/go-logr/logr v1.2.2 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/gofrs/flock v0.8.0 // indirect
-	github.com/gogo/googleapis v1.4.0 // indirect
+	github.com/gogo/googleapis v1.4.1 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/go-cmp v0.5.6 // indirect
+	github.com/google/go-cmp v0.5.7 // indirect
 	github.com/google/gofuzz v1.2.0 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/gorilla/mux v1.8.0 // indirect
 	github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 // indirect
 	github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
-	github.com/imdario/mergo v0.3.12 // indirect
+	github.com/imdario/mergo v0.3.13 // indirect
 	github.com/inconshreveable/mousetrap v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
-	github.com/klauspost/compress v1.13.5 // indirect
+	github.com/klauspost/compress v1.15.1 // indirect
 	github.com/mattn/go-colorable v0.1.12 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
-	github.com/miekg/pkcs11 v1.0.3 // indirect
-	github.com/mitchellh/mapstructure v1.4.3 // indirect
+	github.com/miekg/pkcs11 v1.1.1 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/moby/locker v1.0.1 // indirect
-	github.com/moby/sys/mount v0.2.0 // indirect
-	github.com/moby/sys/mountinfo v0.5.0 // indirect
 	github.com/moby/sys/signal v0.6.0 // indirect
 	github.com/moby/sys/symlink v0.2.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/opencontainers/runc v1.1.0 // indirect
+	github.com/opencontainers/runc v1.1.2 // indirect
 	github.com/pelletier/go-toml v1.9.4 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/client_golang v1.11.0 // indirect
+	github.com/prometheus/client_golang v1.12.1 // indirect
 	github.com/prometheus/client_model v0.2.0 // indirect
-	github.com/prometheus/common v0.30.0 // indirect
+	github.com/prometheus/common v0.32.1 // indirect
 	github.com/prometheus/procfs v0.7.3 // indirect
-	github.com/qri-io/jsonpointer v0.1.0 // indirect
-	github.com/qri-io/jsonschema v0.1.1 // indirect
-	github.com/sergi/go-diff v1.1.0 // indirect
-	github.com/tonistiigi/fsutil v0.0.0-20210818161904-4442383b5028 // indirect
+	github.com/qri-io/jsonpointer v0.1.1 // indirect
+	github.com/qri-io/jsonschema v0.2.2-0.20210831022256-780655b2ba0e // indirect
+	github.com/tonistiigi/fsutil v0.0.0-20220315205639-9ed612626da3 // indirect
 	github.com/tonistiigi/units v0.0.0-20180711220420-6950e57a87ea // indirect
 	github.com/tonistiigi/vt100 v0.0.0-20210615222946-8066bb97264f // indirect
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
 	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
-	go.opentelemetry.io/contrib v0.21.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.28.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.21.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.21.0 // indirect
-	go.opentelemetry.io/otel v1.3.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.3.0 // indirect
-	go.opentelemetry.io/otel/internal/metric v0.21.0 // indirect
-	go.opentelemetry.io/otel/metric v0.21.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.3.0 // indirect
-	go.opentelemetry.io/otel/trace v1.3.0 // indirect
-	go.opentelemetry.io/proto/otlp v0.11.0 // indirect
-	golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 // indirect
-	golang.org/x/net v0.0.0-20211216030914-fe4d6282115f // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.29.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.29.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.29.0 // indirect
+	go.opentelemetry.io/otel v1.4.1 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.4.1 // indirect
+	go.opentelemetry.io/otel/internal/metric v0.27.0 // indirect
+	go.opentelemetry.io/otel/metric v0.27.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.4.1 // indirect
+	go.opentelemetry.io/otel/trace v1.4.1 // indirect
+	go.opentelemetry.io/proto/otlp v0.12.0 // indirect
+	golang.org/x/crypto v0.0.0-20220214200702-86341886e292 // indirect
+	golang.org/x/net v0.0.0-20220225172249-27dd8689420f // indirect
 	golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8 // indirect
-	golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e // indirect
-	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b // indirect
+	golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect
+	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
 	golang.org/x/text v0.3.7 // indirect
-	golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac // indirect
+	golang.org/x/time v0.0.0-20220210224613-90d013bbcef8 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa // indirect
-	google.golang.org/grpc v1.43.0 // indirect
+	google.golang.org/genproto v0.0.0-20220314164441-57ef72a4c106 // indirect
+	google.golang.org/grpc v1.45.0 // indirect
 	google.golang.org/protobuf v1.27.1 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
-	k8s.io/apimachinery v0.22.5 // indirect
-	k8s.io/client-go v0.22.5 // indirect
-	k8s.io/klog/v2 v2.30.0 // indirect
-	k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b // indirect
-	sigs.k8s.io/structured-merge-diff/v4 v4.1.2 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+	k8s.io/apimachinery v0.24.1 // indirect; see replace for the actual version used
+	k8s.io/client-go v0.24.1 // indirect; see replace for the actual version used
+	k8s.io/klog/v2 v2.60.1 // indirect
+	k8s.io/utils v0.0.0-20220210201930-3a6ce19ff2f9 // indirect
+	sigs.k8s.io/structured-merge-diff/v4 v4.2.1 // indirect
 	sigs.k8s.io/yaml v1.2.0 // indirect
 )
 
-// (for buildx)
-replace (
-	github.com/docker/cli => github.com/docker/cli v20.10.3-0.20210702143511-f782d1355eff+incompatible
-	github.com/docker/docker => github.com/docker/docker v20.10.3-0.20220121014307-40bb9831756f+incompatible
-	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc => github.com/tonistiigi/opentelemetry-go-contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.0.0-20210714055410-d010b05b4939
-	go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace => github.com/tonistiigi/opentelemetry-go-contrib/instrumentation/net/http/httptrace/otelhttptrace v0.0.0-20210714055410-d010b05b4939
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp => github.com/tonistiigi/opentelemetry-go-contrib/instrumentation/net/http/otelhttp v0.0.0-20210714055410-d010b05b4939
+require (
+	github.com/cyberphone/json-canonicalization v0.0.0-20210303052042-6bc126869bf4 // indirect
+	github.com/zmap/zcrypto v0.0.0-20220605182715-4dfcec6e9a8c // indirect
+	github.com/zmap/zlint v1.1.0 // indirect
+)
+
+replace (
+	github.com/docker/cli => github.com/docker/cli v20.10.3-0.20220309205733-2b52f62e9627+incompatible
+	github.com/docker/docker => github.com/docker/docker v20.10.3-0.20220309172631-83b51522df43+incompatible
+
+	github.com/opencontainers/runc => github.com/opencontainers/runc v1.1.2 // Can be removed on next bump of containerd to > 1.6.4
+
+	// For k8s dependencies, we use a replace directive, to prevent them being
+	// upgraded to the version specified in containerd, which is not relevant to the
+	// version needed.
+	// See https://github.com/docker/buildx/pull/948 for details.
+	// https://github.com/docker/buildx/blob/v0.8.1/go.mod#L62-L64
+	k8s.io/api => k8s.io/api v0.22.4
+	k8s.io/apimachinery => k8s.io/apimachinery v0.22.4
+	k8s.io/client-go => k8s.io/client-go v0.22.4
 )

pkg/api/api.go

@@ -32,9 +32,9 @@ type Service interface {
 	// Push executes the equivalent ot a `compose push`
 	Push(ctx context.Context, project *types.Project, options PushOptions) error
 	// Pull executes the equivalent of a `compose pull`
-	Pull(ctx context.Context, project *types.Project, opts PullOptions) error
+	Pull(ctx context.Context, project *types.Project, options PullOptions) error
 	// Create executes the equivalent to a `compose create`
-	Create(ctx context.Context, project *types.Project, opts CreateOptions) error
+	Create(ctx context.Context, project *types.Project, options CreateOptions) error
 	// Start executes the equivalent to a `compose start`
 	Start(ctx context.Context, projectName string, options StartOptions) error
 	// Restart restarts containers
@@ -54,25 +54,25 @@ type Service interface {
 	// Convert translate compose model into backend's native format
 	Convert(ctx context.Context, project *types.Project, options ConvertOptions) ([]byte, error)
 	// Kill executes the equivalent to a `compose kill`
-	Kill(ctx context.Context, project *types.Project, options KillOptions) error
+	Kill(ctx context.Context, projectName string, options KillOptions) error
 	// RunOneOffContainer creates a service oneoff container and starts its dependencies
 	RunOneOffContainer(ctx context.Context, project *types.Project, opts RunOptions) (int, error)
 	// Remove executes the equivalent to a `compose rm`
-	Remove(ctx context.Context, project string, options RemoveOptions) error
+	Remove(ctx context.Context, projectName string, options RemoveOptions) error
 	// Exec executes a command in a running service container
-	Exec(ctx context.Context, project string, opts RunOptions) (int, error)
+	Exec(ctx context.Context, projectName string, options RunOptions) (int, error)
 	// Copy copies a file/folder between a service container and the local filesystem
-	Copy(ctx context.Context, project string, options CopyOptions) error
+	Copy(ctx context.Context, projectName string, options CopyOptions) error
 	// Pause executes the equivalent to a `compose pause`
-	Pause(ctx context.Context, project string, options PauseOptions) error
+	Pause(ctx context.Context, projectName string, options PauseOptions) error
 	// UnPause executes the equivalent to a `compose unpause`
-	UnPause(ctx context.Context, project string, options PauseOptions) error
+	UnPause(ctx context.Context, projectName string, options PauseOptions) error
 	// Top executes the equivalent to a `compose top`
 	Top(ctx context.Context, projectName string, services []string) ([]ContainerProcSummary, error)
 	// Events executes the equivalent to a `compose events`
-	Events(ctx context.Context, project string, options EventsOptions) error
+	Events(ctx context.Context, projectName string, options EventsOptions) error
 	// Port executes the equivalent to a `compose port`
-	Port(ctx context.Context, project string, service string, port int, options PortOptions) (string, int, error)
+	Port(ctx context.Context, projectName string, service string, port int, options PortOptions) (string, int, error)
 	// Images executes the equivalent of a `compose images`
 	Images(ctx context.Context, projectName string, options ImagesOptions) ([]ImageSummary, error)
 }
@@ -91,6 +91,8 @@ type BuildOptions struct {
 	Quiet bool
 	// Services passed in the command line to be built
 	Services []string
+	// Ssh authentications passed in the command line
+	SSHs []types.SSHKey
 }
 
 // CreateOptions group options of the Create API
@@ -115,6 +117,8 @@ type CreateOptions struct {
 
 // StartOptions group options of the Start API
 type StartOptions struct {
+	// Project is the compose project used to define this app. Might be nil if user ran `start` just with project name
+	Project *types.Project
 	// Attach to container and forward logs if not nil
 	Attach LogConsumer
 	// AttachTo set the services to attach to
@@ -216,6 +220,7 @@ type RunOptions struct {
 	Detach            bool
 	AutoRemove        bool
 	Tty               bool
+	Interactive       bool
 	WorkingDir        string
 	User              string
 	Environment       []string

pkg/api/errors.go

@@ -21,7 +21,7 @@ import (
 )
 
 const (
-	//ExitCodeLoginRequired exit code when command cannot execute because it requires cloud login
+	// ExitCodeLoginRequired exit code when command cannot execute because it requires cloud login
 	// This will be used by VSCode to detect when creating context if the user needs to login first
 	ExitCodeLoginRequired = 5
 )

pkg/api/proxy.go

@@ -37,7 +37,7 @@ type ServiceProxy struct {
 	PsFn                 func(ctx context.Context, projectName string, options PsOptions) ([]ContainerSummary, error)
 	ListFn               func(ctx context.Context, options ListOptions) ([]Stack, error)
 	ConvertFn            func(ctx context.Context, project *types.Project, options ConvertOptions) ([]byte, error)
-	KillFn               func(ctx context.Context, project *types.Project, options KillOptions) error
+	KillFn               func(ctx context.Context, project string, options KillOptions) error
 	RunOneOffContainerFn func(ctx context.Context, project *types.Project, opts RunOptions) (int, error)
 	RemoveFn             func(ctx context.Context, project string, options RemoveOptions) error
 	ExecFn               func(ctx context.Context, project string, opts RunOptions) (int, error)
@@ -219,14 +219,11 @@ func (s *ServiceProxy) Convert(ctx context.Context, project *types.Project, opti
 }
 
 // Kill implements Service interface
-func (s *ServiceProxy) Kill(ctx context.Context, project *types.Project, options KillOptions) error {
+func (s *ServiceProxy) Kill(ctx context.Context, projectName string, options KillOptions) error {
 	if s.KillFn == nil {
 		return ErrNotImplemented
 	}
-	for _, i := range s.interceptors {
-		i(ctx, project)
-	}
-	return s.KillFn(ctx, project, options)
+	return s.KillFn(ctx, projectName, options)
 }
 
 // RunOneOffContainer implements Service interface
@@ -241,43 +238,43 @@ func (s *ServiceProxy) RunOneOffContainer(ctx context.Context, project *types.Pr
 }
 
 // Remove implements Service interface
-func (s *ServiceProxy) Remove(ctx context.Context, project string, options RemoveOptions) error {
+func (s *ServiceProxy) Remove(ctx context.Context, projectName string, options RemoveOptions) error {
 	if s.RemoveFn == nil {
 		return ErrNotImplemented
 	}
-	return s.RemoveFn(ctx, project, options)
+	return s.RemoveFn(ctx, projectName, options)
 }
 
 // Exec implements Service interface
-func (s *ServiceProxy) Exec(ctx context.Context, project string, options RunOptions) (int, error) {
+func (s *ServiceProxy) Exec(ctx context.Context, projectName string, options RunOptions) (int, error) {
 	if s.ExecFn == nil {
 		return 0, ErrNotImplemented
 	}
-	return s.ExecFn(ctx, project, options)
+	return s.ExecFn(ctx, projectName, options)
 }
 
 // Copy implements Service interface
-func (s *ServiceProxy) Copy(ctx context.Context, project string, options CopyOptions) error {
+func (s *ServiceProxy) Copy(ctx context.Context, projectName string, options CopyOptions) error {
 	if s.CopyFn == nil {
 		return ErrNotImplemented
 	}
-	return s.CopyFn(ctx, project, options)
+	return s.CopyFn(ctx, projectName, options)
 }
 
 // Pause implements Service interface
-func (s *ServiceProxy) Pause(ctx context.Context, project string, options PauseOptions) error {
+func (s *ServiceProxy) Pause(ctx context.Context, projectName string, options PauseOptions) error {
 	if s.PauseFn == nil {
 		return ErrNotImplemented
 	}
-	return s.PauseFn(ctx, project, options)
+	return s.PauseFn(ctx, projectName, options)
 }
 
 // UnPause implements Service interface
-func (s *ServiceProxy) UnPause(ctx context.Context, project string, options PauseOptions) error {
+func (s *ServiceProxy) UnPause(ctx context.Context, projectName string, options PauseOptions) error {
 	if s.UnPauseFn == nil {
 		return ErrNotImplemented
 	}
-	return s.UnPauseFn(ctx, project, options)
+	return s.UnPauseFn(ctx, projectName, options)
 }
 
 // Top implements Service interface
@@ -289,19 +286,19 @@ func (s *ServiceProxy) Top(ctx context.Context, project string, services []strin
 }
 
 // Events implements Service interface
-func (s *ServiceProxy) Events(ctx context.Context, project string, options EventsOptions) error {
+func (s *ServiceProxy) Events(ctx context.Context, projectName string, options EventsOptions) error {
 	if s.EventsFn == nil {
 		return ErrNotImplemented
 	}
-	return s.EventsFn(ctx, project, options)
+	return s.EventsFn(ctx, projectName, options)
 }
 
 // Port implements Service interface
-func (s *ServiceProxy) Port(ctx context.Context, project string, service string, port int, options PortOptions) (string, int, error) {
+func (s *ServiceProxy) Port(ctx context.Context, projectName string, service string, port int, options PortOptions) (string, int, error) {
 	if s.PortFn == nil {
 		return "", 0, ErrNotImplemented
 	}
-	return s.PortFn(ctx, project, service, port, options)
+	return s.PortFn(ctx, projectName, service, port, options)
 }
 
 // Images implements Service interface

pkg/compose/attach.go

@@ -48,7 +48,7 @@ func (s *composeService) attach(ctx context.Context, project *types.Project, lis
 	fmt.Printf("Attaching to %s\n", strings.Join(names, ", "))
 
 	for _, container := range containers {
-		err := s.attachContainer(ctx, container, listener, project)
+		err := s.attachContainer(ctx, container, listener)
 		if err != nil {
 			return nil, err
 		}
@@ -56,13 +56,9 @@ func (s *composeService) attach(ctx context.Context, project *types.Project, lis
 	return containers, err
 }
 
-func (s *composeService) attachContainer(ctx context.Context, container moby.Container, listener api.ContainerEventListener, project *types.Project) error {
+func (s *composeService) attachContainer(ctx context.Context, container moby.Container, listener api.ContainerEventListener) error {
 	serviceName := container.Labels[api.ServiceLabel]
 	containerName := getContainerNameWithoutProject(container)
-	service, err := project.GetService(serviceName)
-	if err != nil {
-		return err
-	}
 
 	listener(api.ContainerEvent{
 		Type:      api.ContainerEventAttach,
@@ -78,7 +74,13 @@ func (s *composeService) attachContainer(ctx context.Context, container moby.Con
 			Line:      line,
 		})
 	})
-	_, _, err = s.attachContainerStreams(ctx, container.ID, service.Tty, nil, w, w)
+
+	inspect, err := s.dockerCli.Client().ContainerInspect(ctx, container.ID)
+	if err != nil {
+		return err
+	}
+
+	_, _, err = s.attachContainerStreams(ctx, container.ID, inspect.Config.Tty, nil, w, w)
 	return err
 }
 
@@ -125,9 +127,9 @@ func (s *composeService) attachContainerStreams(ctx context.Context, container s
 	if stdout != nil {
 		go func() {
 			if tty {
-				io.Copy(stdout, streamOut) // nolint:errcheck
+				io.Copy(stdout, streamOut) //nolint:errcheck
 			} else {
-				stdcopy.StdCopy(stdout, stderr, streamOut) // nolint:errcheck
+				stdcopy.StdCopy(stdout, stderr, streamOut) //nolint:errcheck
 			}
 		}()
 	}

pkg/compose/build.go

@@ -27,11 +27,12 @@ import (
 	_ "github.com/docker/buildx/driver/docker" // required to get default driver registered
 	"github.com/docker/buildx/util/buildflags"
 	xprogress "github.com/docker/buildx/util/progress"
-	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/pkg/urlutil"
 	bclient "github.com/moby/buildkit/client"
 	"github.com/moby/buildkit/session"
 	"github.com/moby/buildkit/session/auth/authprovider"
+	"github.com/moby/buildkit/session/secrets/secretsprovider"
+	"github.com/moby/buildkit/session/sshforward/sshprovider"
 	specs "github.com/opencontainers/image-spec/specs-go/v1"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -60,30 +61,30 @@ func (s *composeService) build(ctx context.Context, project *types.Project, opti
 	}
 
 	for _, service := range services {
-		if service.Build != nil {
-			imageName := getImageName(service, project.Name)
-			imagesToBuild = append(imagesToBuild, imageName)
-			buildOptions, err := s.toBuildOptions(project, service, imageName)
-			if err != nil {
-				return err
-			}
-			buildOptions.Pull = options.Pull
-			buildOptions.BuildArgs = mergeArgs(buildOptions.BuildArgs, args)
-			buildOptions.NoCache = options.NoCache
-			buildOptions.CacheFrom, err = buildflags.ParseCacheEntry(service.Build.CacheFrom)
-			if err != nil {
-				return err
-			}
-
-			for _, image := range service.Build.CacheFrom {
-				buildOptions.CacheFrom = append(buildOptions.CacheFrom, bclient.CacheOptionsEntry{
-					Type:  "registry",
-					Attrs: map[string]string{"ref": image},
-				})
-			}
-
-			opts[imageName] = buildOptions
+		if service.Build == nil {
+			continue
 		}
+		imageName := getImageName(service, project.Name)
+		imagesToBuild = append(imagesToBuild, imageName)
+		buildOptions, err := s.toBuildOptions(project, service, imageName, options.SSHs)
+		if err != nil {
+			return err
+		}
+		buildOptions.Pull = options.Pull
+		buildOptions.BuildArgs = mergeArgs(buildOptions.BuildArgs, args)
+		buildOptions.NoCache = options.NoCache
+		buildOptions.CacheFrom, err = buildflags.ParseCacheEntry(service.Build.CacheFrom)
+		if err != nil {
+			return err
+		}
+
+		for _, image := range service.Build.CacheFrom {
+			buildOptions.CacheFrom = append(buildOptions.CacheFrom, bclient.CacheOptionsEntry{
+				Type:  "registry",
+				Attrs: map[string]string{"ref": image},
+			})
+		}
+		opts[imageName] = buildOptions
 	}
 
 	_, err = s.doBuild(ctx, project, opts, options.Progress)
@@ -160,7 +161,7 @@ func (s *composeService) getBuildOptions(project *types.Project, images map[stri
 			if localImagePresent && service.PullPolicy != types.PullPolicyBuild {
 				continue
 			}
-			opt, err := s.toBuildOptions(project, service, imageName)
+			opt, err := s.toBuildOptions(project, service, imageName, []types.SSHKey{})
 			if err != nil {
 				return nil, err
 			}
@@ -188,37 +189,29 @@ func (s *composeService) getLocalImagesDigests(ctx context.Context, project *typ
 	for name, info := range imgs {
 		images[name] = info.ID
 	}
-	return images, nil
-}
 
-func (s *composeService) serverInfo(ctx context.Context) (command.ServerInfo, error) {
-	ping, err := s.apiClient().Ping(ctx)
-	if err != nil {
-		return command.ServerInfo{}, err
+	for i := range project.Services {
+		imgName := getImageName(project.Services[i], project.Name)
+		digest, ok := images[imgName]
+		if ok {
+			project.Services[i].CustomLabels.Add(api.ImageDigestLabel, digest)
+		}
 	}
-	serverInfo := command.ServerInfo{
-		HasExperimental: ping.Experimental,
-		OSType:          ping.OSType,
-		BuildkitVersion: ping.BuilderVersion,
-	}
-	return serverInfo, err
+
+	return images, nil
 }
 
 func (s *composeService) doBuild(ctx context.Context, project *types.Project, opts map[string]build.Options, mode string) (map[string]string, error) {
 	if len(opts) == 0 {
 		return nil, nil
 	}
-	serverInfo, err := s.serverInfo(ctx)
-	if err != nil {
-		return nil, err
-	}
-	if buildkitEnabled, err := command.BuildKitEnabled(serverInfo); err != nil || !buildkitEnabled {
-		return s.doBuildClassic(ctx, opts)
+	if buildkitEnabled, err := s.dockerCli.BuildKitEnabled(); err != nil || !buildkitEnabled {
+		return s.doBuildClassic(ctx, project, opts)
 	}
 	return s.doBuildBuildkit(ctx, project, opts, mode)
 }
 
-func (s *composeService) toBuildOptions(project *types.Project, service types.ServiceConfig, imageTag string) (build.Options, error) {
+func (s *composeService) toBuildOptions(project *types.Project, service types.ServiceConfig, imageTag string, sshKeys []types.SSHKey) (build.Options, error) {
 	var tags []string
 	tags = append(tags, imageTag)
 
@@ -243,11 +236,47 @@ func (s *composeService) toBuildOptions(project *types.Project, service types.Se
 		plats = append(plats, p)
 	}
 
+	cacheFrom, err := buildflags.ParseCacheEntry(service.Build.CacheFrom)
+	if err != nil {
+		return build.Options{}, err
+	}
+	cacheTo, err := buildflags.ParseCacheEntry(service.Build.CacheTo)
+	if err != nil {
+		return build.Options{}, err
+	}
+
+	sessionConfig := []session.Attachable{
+		authprovider.NewDockerAuthProvider(s.stderr()),
+	}
+	if len(sshKeys) > 0 || len(service.Build.SSH) > 0 {
+		sshAgentProvider, err := sshAgentProvider(append(service.Build.SSH, sshKeys...))
+		if err != nil {
+			return build.Options{}, err
+		}
+		sessionConfig = append(sessionConfig, sshAgentProvider)
+	}
+
+	if len(service.Build.Secrets) > 0 {
+		secretsProvider, err := addSecretsConfig(project, service, sessionConfig)
+		if err != nil {
+			return build.Options{}, err
+		}
+		sessionConfig = append(sessionConfig, secretsProvider)
+	}
+
+	if len(service.Build.Tags) > 0 {
+		tags = append(tags, service.Build.Tags...)
+	}
+
 	return build.Options{
 		Inputs: build.Inputs{
 			ContextPath:    service.Build.Context,
 			DockerfilePath: dockerFilePath(service.Build.Context, service.Build.Dockerfile),
 		},
+		CacheFrom:   cacheFrom,
+		CacheTo:     cacheTo,
+		NoCache:     service.Build.NoCache,
+		Pull:        service.Build.Pull,
 		BuildArgs:   buildArgs,
 		Tags:        tags,
 		Target:      service.Build.Target,
@@ -255,10 +284,8 @@ func (s *composeService) toBuildOptions(project *types.Project, service types.Se
 		Platforms:   plats,
 		Labels:      service.Build.Labels,
 		NetworkMode: service.Build.Network,
-		ExtraHosts:  service.Build.ExtraHosts,
-		Session: []session.Attachable{
-			authprovider.NewDockerAuthProvider(s.stderr()),
-		},
+		ExtraHosts:  service.Build.ExtraHosts.AsList(),
+		Session:     sessionConfig,
 	}, nil
 }
 
@@ -286,9 +313,47 @@ func mergeArgs(m ...types.Mapping) types.Mapping {
 	return merged
 }
 
-func dockerFilePath(context string, dockerfile string) string {
-	if urlutil.IsGitURL(context) || filepath.IsAbs(dockerfile) {
+func dockerFilePath(ctxName string, dockerfile string) string {
+	if urlutil.IsGitURL(ctxName) || filepath.IsAbs(dockerfile) {
 		return dockerfile
 	}
-	return filepath.Join(context, dockerfile)
+	return filepath.Join(ctxName, dockerfile)
+}
+
+func sshAgentProvider(sshKeys types.SSHConfig) (session.Attachable, error) {
+	sshConfig := make([]sshprovider.AgentConfig, 0, len(sshKeys))
+	for _, sshKey := range sshKeys {
+		sshConfig = append(sshConfig, sshprovider.AgentConfig{
+			ID:    sshKey.ID,
+			Paths: []string{sshKey.Path},
+		})
+	}
+	return sshprovider.NewSSHAgentProvider(sshConfig)
+}
+
+func addSecretsConfig(project *types.Project, service types.ServiceConfig, sessionConfig []session.Attachable) (session.Attachable, error) {
+
+	var sources []secretsprovider.Source
+	for _, secret := range service.Build.Secrets {
+		config := project.Secrets[secret.Source]
+		switch {
+		case config.File != "":
+			sources = append(sources, secretsprovider.Source{
+				ID:       secret.Source,
+				FilePath: config.File,
+			})
+		case config.Environment != "":
+			sources = append(sources, secretsprovider.Source{
+				ID:  secret.Source,
+				Env: config.Environment,
+			})
+		default:
+			return nil, fmt.Errorf("build.secrets only supports environment or file-based secrets: %q", secret.Source)
+		}
+	}
+	store, err := secretsprovider.NewStore(sources)
+	if err != nil {
+		return nil, err
+	}
+	return secretsprovider.NewSecretProvider(store), nil
 }

pkg/compose/build_buildkit.go

@@ -45,7 +45,7 @@ func (s *composeService) doBuildBuildkit(ctx context.Context, project *types.Pro
 	// build and will lock
 	progressCtx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	w := xprogress.NewPrinter(progressCtx, os.Stdout, mode)
+	w := xprogress.NewPrinter(progressCtx, s.stdout(), os.Stdout, mode)
 
 	// We rely on buildx "docker" builder integrated in docker engine, so don't need a DockerAPI here
 	response, err := build.Build(ctx, driverInfo, opts, nil, filepath.Dir(s.configFile().Filename), w)

pkg/compose/build_classic.go

@@ -21,12 +21,12 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
 
+	"github.com/compose-spec/compose-go/types"
 	buildx "github.com/docker/buildx/build"
 	"github.com/docker/cli/cli/command/image/build"
 	dockertypes "github.com/docker/docker/api/types"
@@ -41,21 +41,30 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (s *composeService) doBuildClassic(ctx context.Context, opts map[string]buildx.Options) (map[string]string, error) {
+func (s *composeService) doBuildClassic(ctx context.Context, project *types.Project, opts map[string]buildx.Options) (map[string]string, error) {
 	var nameDigests = make(map[string]string)
 	var errs error
-	for name, o := range opts {
+	err := project.WithServices(nil, func(service types.ServiceConfig) error {
+		imageName := getImageName(service, project.Name)
+		o, ok := opts[imageName]
+		if !ok {
+			return nil
+		}
 		digest, err := s.doBuildClassicSimpleImage(ctx, o)
 		if err != nil {
 			errs = multierror.Append(errs, err).ErrorOrNil()
 		}
-		nameDigests[name] = digest
+		nameDigests[imageName] = digest
+		return nil
+	})
+	if err != nil {
+		return nil, err
 	}
 
 	return nameDigests, errs
 }
 
-// nolint: gocyclo
+//nolint: gocyclo
 func (s *composeService) doBuildClassicSimpleImage(ctx context.Context, options buildx.Options) (string, error) {
 	var (
 		buildCtx      io.ReadCloser
@@ -87,7 +96,7 @@ func (s *composeService) doBuildClassicSimpleImage(ctx context.Context, options
 			if err != nil {
 				return "", errors.Errorf("unable to open Dockerfile: %v", err)
 			}
-			defer dockerfileCtx.Close() // nolint:errcheck
+			defer dockerfileCtx.Close() //nolint:errcheck
 		}
 	case urlutil.IsGitURL(specifiedContext):
 		tempDir, relDockerfile, err = build.GetContextFromGitURL(specifiedContext, dockerfileName)
@@ -102,7 +111,7 @@ func (s *composeService) doBuildClassicSimpleImage(ctx context.Context, options
 	}
 
 	if tempDir != "" {
-		defer os.RemoveAll(tempDir) // nolint:errcheck
+		defer os.RemoveAll(tempDir) //nolint:errcheck
 		contextDir = tempDir
 	}
 
@@ -143,17 +152,8 @@ func (s *composeService) doBuildClassicSimpleImage(ctx context.Context, options
 		return "", err
 	}
 
-	// if up to this point nothing has set the context then we must have another
-	// way for sending it(streaming) and set the context to the Dockerfile
-	if dockerfileCtx != nil && buildCtx == nil {
-		buildCtx = dockerfileCtx
-	}
-
 	progressOutput := streamformatter.NewProgressOutput(progBuff)
-	var body io.Reader
-	if buildCtx != nil {
-		body = progress.NewProgressReader(buildCtx, progressOutput, 0, "", "Sending build context to Docker daemon")
-	}
+	body := progress.NewProgressReader(buildCtx, progressOutput, 0, "", "Sending build context to Docker daemon")
 
 	configFile := s.configFile()
 	creds, err := configFile.GetAllCredentials()
@@ -175,7 +175,7 @@ func (s *composeService) doBuildClassicSimpleImage(ctx context.Context, options
 	if err != nil {
 		return "", err
 	}
-	defer response.Body.Close() // nolint:errcheck
+	defer response.Body.Close() //nolint:errcheck
 
 	imageID := ""
 	aux := func(msg jsonmessage.JSONMessage) {
@@ -214,7 +214,7 @@ func (s *composeService) doBuildClassicSimpleImage(ctx context.Context, options
 		if imageID == "" {
 			return "", errors.Errorf("Server did not provide an image ID. Cannot write %s", options.ImageIDFile)
 		}
-		if err := ioutil.WriteFile(options.ImageIDFile, []byte(imageID), 0666); err != nil {
+		if err := os.WriteFile(options.ImageIDFile, []byte(imageID), 0o666); err != nil {
 			return "", err
 		}
 	}

pkg/compose/compose.go

@@ -24,15 +24,15 @@ import (
 	"io"
 	"strings"
 
-	"github.com/docker/compose/v2/pkg/api"
-	"github.com/pkg/errors"
-
 	"github.com/compose-spec/compose-go/types"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/cli/config/configfile"
 	"github.com/docker/cli/cli/streams"
+	"github.com/docker/compose/v2/pkg/api"
 	moby "github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/client"
+	"github.com/pkg/errors"
 	"github.com/sanathkr/go-yaml"
 )
 
@@ -165,7 +165,7 @@ SERVICES:
 				continue SERVICES
 			}
 		}
-		return project, errors.New("no such service: " + qs)
+		return project, errors.Wrapf(api.ErrNotFound, "no such service: %q", qs)
 	}
 	err := project.ForServices(services)
 	if err != nil {
@@ -194,3 +194,39 @@ func (s *composeService) actualState(ctx context.Context, projectName string, se
 	}
 	return containers, project, nil
 }
+
+func (s *composeService) actualVolumes(ctx context.Context, projectName string) (types.Volumes, error) {
+	volumes, err := s.apiClient().VolumeList(ctx, filters.NewArgs(projectFilter(projectName)))
+	if err != nil {
+		return nil, err
+	}
+
+	actual := types.Volumes{}
+	for _, vol := range volumes.Volumes {
+		actual[vol.Labels[api.VolumeLabel]] = types.VolumeConfig{
+			Name:   vol.Name,
+			Driver: vol.Driver,
+			Labels: vol.Labels,
+		}
+	}
+	return actual, nil
+}
+
+func (s *composeService) actualNetworks(ctx context.Context, projectName string) (types.Networks, error) {
+	networks, err := s.apiClient().NetworkList(ctx, moby.NetworkListOptions{
+		Filters: filters.NewArgs(projectFilter(projectName)),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	actual := types.Networks{}
+	for _, net := range networks {
+		actual[net.Labels[api.NetworkLabel]] = types.NetworkConfig{
+			Name:   net.Name,
+			Driver: net.Driver,
+			Labels: net.Labels,
+		}
+	}
+	return actual, nil
+}

pkg/compose/containers.go

@@ -18,14 +18,13 @@ package compose
 
 import (
 	"context"
+	"fmt"
 	"sort"
-	"strconv"
-
-	moby "github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
 
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/utils"
+	moby "github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/filters"
 )
 
 // Containers is a set of moby Container
@@ -41,17 +40,7 @@ const (
 
 func (s *composeService) getContainers(ctx context.Context, project string, oneOff oneOff, stopped bool, selectedServices ...string) (Containers, error) {
 	var containers Containers
-	f := []filters.KeyValuePair{projectFilter(project)}
-	if len(selectedServices) == 1 {
-		f = append(f, serviceFilter(selectedServices[0]))
-	}
-	switch oneOff {
-	case oneOffOnly:
-		f = append(f, oneOffFilter(true))
-	case oneOffExclude:
-		f = append(f, oneOffFilter(false))
-	case oneOffInclude:
-	}
+	f := getDefaultFilters(project, oneOff, selectedServices...)
 	containers, err := s.apiClient().ContainerList(ctx, moby.ContainerListOptions{
 		Filters: filters.NewArgs(f...),
 		All:     stopped,
@@ -65,6 +54,40 @@ func (s *composeService) getContainers(ctx context.Context, project string, oneO
 	return containers, nil
 }
 
+func getDefaultFilters(projectName string, oneOff oneOff, selectedServices ...string) []filters.KeyValuePair {
+	f := []filters.KeyValuePair{projectFilter(projectName)}
+	if len(selectedServices) == 1 {
+		f = append(f, serviceFilter(selectedServices[0]))
+	}
+	switch oneOff {
+	case oneOffOnly:
+		f = append(f, oneOffFilter(true))
+	case oneOffExclude:
+		f = append(f, oneOffFilter(false))
+	case oneOffInclude:
+	}
+	return f
+}
+
+func (s *composeService) getSpecifiedContainer(ctx context.Context, projectName string, oneOff oneOff, stopped bool, serviceName string, containerIndex int) (moby.Container, error) {
+	defaultFilters := getDefaultFilters(projectName, oneOff, serviceName)
+	defaultFilters = append(defaultFilters, containerNumberFilter(containerIndex))
+	containers, err := s.apiClient().ContainerList(ctx, moby.ContainerListOptions{
+		Filters: filters.NewArgs(
+			defaultFilters...,
+		),
+		All: stopped,
+	})
+	if err != nil {
+		return moby.Container{}, err
+	}
+	if len(containers) < 1 {
+		return moby.Container{}, fmt.Errorf("service %q is not running container #%d", serviceName, containerIndex)
+	}
+	container := containers[0]
+	return container, nil
+}
+
 // containerPredicate define a predicate we want container to satisfy for filtering operations
 type containerPredicate func(c moby.Container) bool
 
@@ -87,14 +110,6 @@ func isNotOneOff(c moby.Container) bool {
 	return !ok || v == "False"
 }
 
-func indexed(index int) containerPredicate {
-	return func(c moby.Container) bool {
-		number := c.Labels[api.ContainerNumberLabel]
-		idx, err := strconv.Atoi(number)
-		return err == nil && index == idx
-	}
-}
-
 // filter return Containers with elements to match predicate
 func (containers Containers) filter(predicate containerPredicate) Containers {
 	var filtered Containers

pkg/compose/convergence.go

@@ -189,17 +189,11 @@ func (c *convergence) ensureService(ctx context.Context, project *types.Project,
 			continue
 		}
 
-		if recreate == api.RecreateNever {
-			continue
-		}
-		// Re-create diverged containers
-		configHash, err := ServiceHash(service)
+		mustRecreate, err := mustRecreate(service, container, recreate)
 		if err != nil {
 			return err
 		}
-		name := getContainerProgressName(container)
-		diverged := container.Labels[api.ConfigHashLabel] != configHash
-		if diverged || recreate == api.RecreateForce || service.Extensions[extLifecycle] == forceRecreate {
+		if mustRecreate {
 			i, container := i, container
 			eg.Go(func() error {
 				recreated, err := c.service.recreateContainer(ctx, project, service, container, inherit, timeout)
@@ -211,6 +205,7 @@ func (c *convergence) ensureService(ctx context.Context, project *types.Project,
 
 		// Enforce non-diverged containers are running
 		w := progress.ContextWriter(ctx)
+		name := getContainerProgressName(container)
 		switch container.State {
 		case ContainerRunning:
 			w.Event(progress.RunningEvent(name))
@@ -249,6 +244,22 @@ func (c *convergence) ensureService(ctx context.Context, project *types.Project,
 	return err
 }
 
+func mustRecreate(expected types.ServiceConfig, actual moby.Container, policy string) (bool, error) {
+	if policy == api.RecreateNever {
+		return false, nil
+	}
+	if policy == api.RecreateForce || expected.Extensions[extLifecycle] == forceRecreate {
+		return true, nil
+	}
+	configHash, err := ServiceHash(expected)
+	if err != nil {
+		return false, err
+	}
+	configChanged := actual.Labels[api.ConfigHashLabel] != configHash
+	imageUpdated := actual.Labels[api.ImageDigestLabel] != expected.CustomLabels[api.ImageDigestLabel]
+	return configChanged || imageUpdated, nil
+}
+
 func getContainerName(projectName string, service types.ServiceConfig, number int) string {
 	name := strings.Join([]string{projectName, service.Name, strconv.Itoa(number)}, Separator)
 	if service.ContainerName != "" {
@@ -512,6 +523,8 @@ func (s *composeService) createMobyContainer(ctx context.Context, project *types
 			return created, err
 		}
 	}
+
+	err = s.injectSecrets(ctx, project, service, created.ID)
 	return created, err
 }
 
@@ -540,7 +553,7 @@ func (s composeService) getLinks(ctx context.Context, projectName string, servic
 			containerName := getCanonicalContainerName(c)
 			links = append(links,
 				format(containerName, linkName),
-				format(containerName, strings.Join([]string{linkServiceName, strconv.Itoa(number)}, Separator)),
+				format(containerName, linkServiceName+Separator+strconv.Itoa(number)),
 				format(containerName, strings.Join([]string{projectName, linkServiceName, strconv.Itoa(number)}, Separator)),
 			)
 		}

pkg/compose/cp.go

@@ -42,59 +42,80 @@ const (
 	acrossServices = fromService | toService
 )
 
-func (s *composeService) Copy(ctx context.Context, project string, opts api.CopyOptions) error {
-	srcService, srcPath := splitCpArg(opts.Source)
-	destService, dstPath := splitCpArg(opts.Destination)
+func (s *composeService) Copy(ctx context.Context, projectName string, options api.CopyOptions) error {
+	projectName = strings.ToLower(projectName)
+	srcService, srcPath := splitCpArg(options.Source)
+	destService, dstPath := splitCpArg(options.Destination)
 
 	var direction copyDirection
 	var serviceName string
+	var copyFunc func(ctx context.Context, containerID string, srcPath string, dstPath string, opts api.CopyOptions) error
 	if srcService != "" {
 		direction |= fromService
 		serviceName = srcService
+		copyFunc = s.copyFromContainer
 
 		// copying from multiple containers of a services doesn't make sense.
-		if opts.All {
+		if options.All {
 			return errors.New("cannot use the --all flag when copying from a service")
 		}
 	}
 	if destService != "" {
 		direction |= toService
 		serviceName = destService
+		copyFunc = s.copyToContainer
+	}
+	if direction == acrossServices {
+		return errors.New("copying between services is not supported")
 	}
 
-	containers, err := s.getContainers(ctx, project, oneOffExclude, true, serviceName)
+	if direction == 0 {
+		return errors.New("unknown copy direction")
+	}
+
+	containers, err := s.listContainersTargetedForCopy(ctx, projectName, options.Index, direction, serviceName)
 	if err != nil {
 		return err
 	}
 
-	if len(containers) < 1 {
-		return fmt.Errorf("no container found for service %q", serviceName)
-	}
-
-	if !opts.All {
-		containers = containers.filter(indexed(opts.Index))
-	}
-
 	g := errgroup.Group{}
 	for _, container := range containers {
 		containerID := container.ID
 		g.Go(func() error {
-			switch direction {
-			case fromService:
-				return s.copyFromContainer(ctx, containerID, srcPath, dstPath, opts)
-			case toService:
-				return s.copyToContainer(ctx, containerID, srcPath, dstPath, opts)
-			case acrossServices:
-				return errors.New("copying between services is not supported")
-			default:
-				return errors.New("unknown copy direction")
-			}
+			return copyFunc(ctx, containerID, srcPath, dstPath, options)
 		})
 	}
 
 	return g.Wait()
 }
 
+func (s *composeService) listContainersTargetedForCopy(ctx context.Context, projectName string, index int, direction copyDirection, serviceName string) (Containers, error) {
+	var containers Containers
+	var err error
+	switch {
+	case index > 0:
+		container, err := s.getSpecifiedContainer(ctx, projectName, oneOffExclude, true, serviceName, index)
+		if err != nil {
+			return nil, err
+		}
+		return append(containers, container), nil
+	default:
+		containers, err = s.getContainers(ctx, projectName, oneOffExclude, true, serviceName)
+		if err != nil {
+			return nil, err
+		}
+
+		if len(containers) < 1 {
+			return nil, fmt.Errorf("no container found for service %q", serviceName)
+		}
+		if direction == fromService {
+			return containers[:1], err
+
+		}
+		return containers, err
+	}
+}
+
 func (s *composeService) copyToContainer(ctx context.Context, containerID string, srcPath string, dstPath string, opts api.CopyOptions) error {
 	var err error
 	if srcPath != "-" {
@@ -242,7 +263,7 @@ func (s *composeService) copyFromContainer(ctx context.Context, containerID, src
 	}
 
 	preArchive := content
-	if len(srcInfo.RebaseName) != 0 {
+	if srcInfo.RebaseName != "" {
 		_, srcBase := archive.SplitPathDirEntry(srcInfo.Path)
 		preArchive = archive.RebaseArchiveEntries(content, srcBase, srcInfo.RebaseName)
 	}

pkg/compose/create.go

@@ -21,7 +21,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"os"
 	"path"
 	"path/filepath"
 	"strconv"
@@ -31,6 +31,7 @@ import (
 	moby "github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/blkiodev"
 	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/api/types/strslice"
@@ -173,13 +174,21 @@ func prepareServicesDependsOn(p *types.Project) error {
 			dependencies = append(dependencies, spec[0])
 		}
 
+		for _, link := range service.Links {
+			dependencies = append(dependencies, strings.Split(link, ":")[0])
+		}
+
 		if len(dependencies) == 0 {
 			continue
 		}
 		if service.DependsOn == nil {
 			service.DependsOn = make(types.DependsOnConfig)
 		}
-		deps, err := p.GetServices(dependencies...)
+
+		// Verify dependencies exist in the project, whether disabled or not
+		projAllServices := types.Project{}
+		projAllServices.Services = p.AllServices()
+		deps, err := projAllServices.GetServices(dependencies...)
 		if err != nil {
 			return err
 		}
@@ -347,6 +356,11 @@ func (s *composeService) getCreateOptions(ctx context.Context, p *types.Project,
 		volumesFrom = append(volumesFrom, v[len("container:"):])
 	}
 
+	links, err := s.getLinks(ctx, p.Name, service, number)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
 	securityOpts, err := parseSecurityOpts(p, service.SecurityOpt)
 	if err != nil {
 		return nil, nil, nil, err
@@ -371,7 +385,7 @@ func (s *composeService) getCreateOptions(ctx context.Context, p *types.Project,
 		DNS:            service.DNS,
 		DNSSearch:      service.DNSSearch,
 		DNSOptions:     service.DNSOpts,
-		ExtraHosts:     service.ExtraHosts,
+		ExtraHosts:     service.ExtraHosts.AsList(),
 		SecurityOpt:    securityOpts,
 		UsernsMode:     container.UsernsMode(service.UserNSMode),
 		Privileged:     service.Privileged,
@@ -381,6 +395,7 @@ func (s *composeService) getCreateOptions(ctx context.Context, p *types.Project,
 		Runtime:        service.Runtime,
 		LogConfig:      logConfig,
 		GroupAdd:       service.GroupAdd,
+		Links:          links,
 	}
 
 	return &containerConfig, &hostConfig, networkConfig, nil
@@ -399,7 +414,7 @@ func parseSecurityOpts(p *types.Project, securityOpts []string) ([]string, error
 			}
 		}
 		if con[0] == "seccomp" && con[1] != "unconfined" {
-			f, err := ioutil.ReadFile(p.RelativePath(con[1]))
+			f, err := os.ReadFile(p.RelativePath(con[1]))
 			if err != nil {
 				return securityOpts, errors.Errorf("opening seccomp profile (%s) failed: %v", con[1], err)
 			}
@@ -580,8 +595,12 @@ func setLimits(limits *types.Resource, resources *container.Resources) {
 		resources.Memory = int64(limits.MemoryBytes)
 	}
 	if limits.NanoCPUs != "" {
-		i, _ := strconv.ParseInt(limits.NanoCPUs, 10, 64)
-		resources.NanoCPUs = i
+		if f, err := strconv.ParseFloat(limits.NanoCPUs, 64); err == nil {
+			resources.NanoCPUs = int64(f * 1e9)
+		}
+	}
+	if limits.PIds > 0 {
+		resources.PidsLimit = &limits.PIds
 	}
 }
 
@@ -661,7 +680,7 @@ func getVolumesFrom(project *types.Project, volumesFrom []string) ([]string, []s
 			continue
 		}
 		if spec[0] == "container" {
-			volumes = append(volumes, strings.Join(spec[1:], ":"))
+			volumes = append(volumes, vol)
 			continue
 		}
 		serviceName := spec[0]
@@ -709,12 +728,20 @@ func (s *composeService) buildContainerVolumes(ctx context.Context, p types.Proj
 MOUNTS:
 	for _, m := range mountOptions {
 		volumeMounts[m.Target] = struct{}{}
-		// `Bind` API is used when host path need to be created if missing, `Mount` is preferred otherwise
 		if m.Type == mount.TypeBind || m.Type == mount.TypeNamedPipe {
+			// `Mount` is preferred but does not offer option to created host path if missing
+			// so `Bind` API is used here with raw volume string
+			// see https://github.com/moby/moby/issues/43483
 			for _, v := range service.Volumes {
-				if v.Target == m.Target && v.Bind != nil && v.Bind.CreateHostPath {
-					binds = append(binds, fmt.Sprintf("%s:%s:%s", m.Source, m.Target, getBindMode(v.Bind, m.ReadOnly)))
-					continue MOUNTS
+				if v.Target == m.Target {
+					switch {
+					case string(m.Type) != v.Type:
+						v.Source = m.Source
+						fallthrough
+					case v.Bind != nil && v.Bind.CreateHostPath:
+						binds = append(binds, v.String())
+						continue MOUNTS
+					}
 				}
 			}
 		}
@@ -723,23 +750,6 @@ MOUNTS:
 	return volumeMounts, binds, mounts, nil
 }
 
-func getBindMode(bind *types.ServiceVolumeBind, readOnly bool) string {
-	mode := "rw"
-
-	if readOnly {
-		mode = "ro"
-	}
-
-	switch bind.SELinux {
-	case types.SELinuxShared:
-		mode += ",z"
-	case types.SELinuxPrivate:
-		mode += ",Z"
-	}
-
-	return mode
-}
-
 func buildContainerMountOptions(p types.Project, s types.ServiceConfig, img moby.ImageInspect, inherit *moby.Container) ([]mount.Mount, error) {
 	var mounts = map[string]mount.Mount{}
 	if inherit != nil {
@@ -879,7 +889,11 @@ func buildContainerSecretMounts(p types.Project, s types.ServiceConfig) ([]mount
 			return nil, fmt.Errorf("unsupported external secret %s", definedSecret.Name)
 		}
 
-		mount, err := buildMount(p, types.ServiceVolumeConfig{
+		if definedSecret.Environment != "" {
+			continue
+		}
+
+		mnt, err := buildMount(p, types.ServiceVolumeConfig{
 			Type:     types.VolumeTypeBind,
 			Source:   definedSecret.File,
 			Target:   target,
@@ -888,7 +902,7 @@ func buildContainerSecretMounts(p types.Project, s types.ServiceConfig) ([]mount
 		if err != nil {
 			return nil, err
 		}
-		mounts[target] = mount
+		mounts[target] = mnt
 	}
 	values := make([]mount.Mount, 0, len(mounts))
 	for _, v := range mounts {
@@ -897,8 +911,8 @@ func buildContainerSecretMounts(p types.Project, s types.ServiceConfig) ([]mount
 	return values, nil
 }
 
-func isUnixAbs(path string) bool {
-	return strings.HasPrefix(path, "/")
+func isUnixAbs(p string) bool {
+	return strings.HasPrefix(p, "/")
 }
 
 func buildMount(project types.Project, volume types.ServiceVolumeConfig) (mount.Mount, error) {
@@ -922,10 +936,14 @@ func buildMount(project types.Project, volume types.ServiceVolumeConfig) (mount.
 		}
 	}
 
-	bind, vol, tmpfs := buildMountOptions(volume)
+	bind, vol, tmpfs := buildMountOptions(project, volume)
 
 	volume.Target = path.Clean(volume.Target)
 
+	if bind != nil {
+		volume.Type = types.VolumeTypeBind
+	}
+
 	return mount.Mount{
 		Type:          mount.Type(volume.Type),
 		Source:        source,
@@ -938,7 +956,7 @@ func buildMount(project types.Project, volume types.ServiceVolumeConfig) (mount.
 	}, nil
 }
 
-func buildMountOptions(volume types.ServiceVolumeConfig) (*mount.BindOptions, *mount.VolumeOptions, *mount.TmpfsOptions) {
+func buildMountOptions(project types.Project, volume types.ServiceVolumeConfig) (*mount.BindOptions, *mount.VolumeOptions, *mount.TmpfsOptions) {
 	switch volume.Type {
 	case "bind":
 		if volume.Volume != nil {
@@ -955,6 +973,11 @@ func buildMountOptions(volume types.ServiceVolumeConfig) (*mount.BindOptions, *m
 		if volume.Tmpfs != nil {
 			logrus.Warnf("mount of type `volume` should not define `tmpfs` option")
 		}
+		if v, ok := project.Volumes[volume.Source]; ok && v.DriverOpts["o"] == types.VolumeTypeBind {
+			return buildBindOption(&types.ServiceVolumeBind{
+				CreateHostPath: true,
+			}), nil, nil
+		}
 		return nil, buildVolumeOptions(volume.Volume), nil
 	case "tmpfs":
 		if volume.Bind != nil {
@@ -1008,87 +1031,90 @@ func getAliases(s types.ServiceConfig, c *types.ServiceNetworkConfig) []string {
 }
 
 func (s *composeService) ensureNetwork(ctx context.Context, n types.NetworkConfig) error {
-	_, err := s.apiClient().NetworkInspect(ctx, n.Name, moby.NetworkInspectOptions{})
+	// NetworkInspect will match on ID prefix, so NetworkList with a name
+	// filter is used to look for an exact match to prevent e.g. a network
+	// named `db` from getting erroneously matched to a network with an ID
+	// like `db9086999caf`
+	networks, err := s.apiClient().NetworkList(ctx, moby.NetworkListOptions{
+		Filters: filters.NewArgs(filters.Arg("name", n.Name)),
+	})
 	if err != nil {
-		if errdefs.IsNotFound(err) {
-			if n.External.External {
-				if n.Driver == "overlay" {
-					// Swarm nodes do not register overlay networks that were
-					// created on a different node unless they're in use.
-					// Here we assume `driver` is relevant for a network we don't manage
-					// which is a non-sense, but this is our legacy ¯\(ツ)/¯
-					// networkAttach will later fail anyway if network actually doesn't exists
-					return nil
-				}
-				return fmt.Errorf("network %s declared as external, but could not be found", n.Name)
-			}
-			var ipam *network.IPAM
-			if n.Ipam.Config != nil {
-				var config []network.IPAMConfig
-				for _, pool := range n.Ipam.Config {
-					config = append(config, network.IPAMConfig{
-						Subnet:     pool.Subnet,
-						IPRange:    pool.IPRange,
-						Gateway:    pool.Gateway,
-						AuxAddress: pool.AuxiliaryAddresses,
-					})
-				}
-				ipam = &network.IPAM{
-					Driver: n.Ipam.Driver,
-					Config: config,
-				}
-			}
-			createOpts := moby.NetworkCreate{
-				// TODO NameSpace Labels
-				Labels:     n.Labels,
-				Driver:     n.Driver,
-				Options:    n.DriverOpts,
-				Internal:   n.Internal,
-				Attachable: n.Attachable,
-				IPAM:       ipam,
-				EnableIPv6: n.EnableIPv6,
-			}
-
-			if n.Ipam.Driver != "" || len(n.Ipam.Config) > 0 {
-				createOpts.IPAM = &network.IPAM{}
-			}
-
-			if n.Ipam.Driver != "" {
-				createOpts.IPAM.Driver = n.Ipam.Driver
-			}
-
-			for _, ipamConfig := range n.Ipam.Config {
-				config := network.IPAMConfig{
-					Subnet: ipamConfig.Subnet,
-				}
-				createOpts.IPAM.Config = append(createOpts.IPAM.Config, config)
-			}
-			networkEventName := fmt.Sprintf("Network %s", n.Name)
-			w := progress.ContextWriter(ctx)
-			w.Event(progress.CreatingEvent(networkEventName))
-			if _, err := s.apiClient().NetworkCreate(ctx, n.Name, createOpts); err != nil {
-				w.Event(progress.ErrorEvent(networkEventName))
-				return errors.Wrapf(err, "failed to create network %s", n.Name)
-			}
-			w.Event(progress.CreatedEvent(networkEventName))
-			return nil
-		}
 		return err
 	}
-	return nil
-}
-
-func (s *composeService) removeNetwork(ctx context.Context, networkID string, networkName string) error {
-	w := progress.ContextWriter(ctx)
-	eventName := fmt.Sprintf("Network %s", networkName)
-	w.Event(progress.RemovingEvent(eventName))
-
-	if err := s.apiClient().NetworkRemove(ctx, networkID); err != nil {
-		w.Event(progress.ErrorEvent(eventName))
-		return errors.Wrapf(err, fmt.Sprintf("failed to remove network %s", networkID))
+	networkNotFound := true
+	for _, net := range networks {
+		if net.Name == n.Name {
+			networkNotFound = false
+			break
+		}
 	}
+	if networkNotFound {
+		if n.External.External {
+			if n.Driver == "overlay" {
+				// Swarm nodes do not register overlay networks that were
+				// created on a different node unless they're in use.
+				// Here we assume `driver` is relevant for a network we don't manage
+				// which is a non-sense, but this is our legacy ¯\(ツ)/¯
+				// networkAttach will later fail anyway if network actually doesn't exists
+				return nil
+			}
+			return fmt.Errorf("network %s declared as external, but could not be found", n.Name)
+		}
+		var ipam *network.IPAM
+		if n.Ipam.Config != nil {
+			var config []network.IPAMConfig
+			for _, pool := range n.Ipam.Config {
+				config = append(config, network.IPAMConfig{
+					Subnet:     pool.Subnet,
+					IPRange:    pool.IPRange,
+					Gateway:    pool.Gateway,
+					AuxAddress: pool.AuxiliaryAddresses,
+				})
+			}
+			ipam = &network.IPAM{
+				Driver: n.Ipam.Driver,
+				Config: config,
+			}
+		}
+		createOpts := moby.NetworkCreate{
+			CheckDuplicate: true,
+			// TODO NameSpace Labels
+			Labels:     n.Labels,
+			Driver:     n.Driver,
+			Options:    n.DriverOpts,
+			Internal:   n.Internal,
+			Attachable: n.Attachable,
+			IPAM:       ipam,
+			EnableIPv6: n.EnableIPv6,
+		}
 
-	w.Event(progress.RemovedEvent(eventName))
+		if n.Ipam.Driver != "" || len(n.Ipam.Config) > 0 {
+			createOpts.IPAM = &network.IPAM{}
+		}
+
+		if n.Ipam.Driver != "" {
+			createOpts.IPAM.Driver = n.Ipam.Driver
+		}
+
+		for _, ipamConfig := range n.Ipam.Config {
+			config := network.IPAMConfig{
+				Subnet:     ipamConfig.Subnet,
+				IPRange:    ipamConfig.IPRange,
+				Gateway:    ipamConfig.Gateway,
+				AuxAddress: ipamConfig.AuxiliaryAddresses,
+			}
+			createOpts.IPAM.Config = append(createOpts.IPAM.Config, config)
+		}
+		networkEventName := fmt.Sprintf("Network %s", n.Name)
+		w := progress.ContextWriter(ctx)
+		w.Event(progress.CreatingEvent(networkEventName))
+		if _, err := s.apiClient().NetworkCreate(ctx, n.Name, createOpts); err != nil {
+			w.Event(progress.ErrorEvent(networkEventName))
+			return errors.Wrapf(err, "failed to create network %s", n.Name)
+		}
+		w.Event(progress.CreatedEvent(networkEventName))
+		return nil
+	}
 	return nil
 }
 

pkg/compose/create_test.go

@@ -22,7 +22,6 @@ import (
 	"sort"
 	"testing"
 
-	"github.com/compose-spec/compose-go/types"
 	composetypes "github.com/compose-spec/compose-go/types"
 	"github.com/docker/compose/v2/pkg/api"
 	moby "github.com/docker/docker/api/types"
@@ -66,17 +65,17 @@ func TestBuildVolumeMount(t *testing.T) {
 }
 
 func TestServiceImageName(t *testing.T) {
-	assert.Equal(t, getImageName(types.ServiceConfig{Image: "myImage"}, "myProject"), "myImage")
-	assert.Equal(t, getImageName(types.ServiceConfig{Name: "aService"}, "myProject"), "myProject_aService")
+	assert.Equal(t, getImageName(composetypes.ServiceConfig{Image: "myImage"}, "myProject"), "myImage")
+	assert.Equal(t, getImageName(composetypes.ServiceConfig{Name: "aService"}, "myProject"), "myProject_aService")
 }
 
 func TestPrepareNetworkLabels(t *testing.T) {
-	project := types.Project{
+	project := composetypes.Project{
 		Name:     "myProject",
-		Networks: types.Networks(map[string]types.NetworkConfig{"skynet": {}}),
+		Networks: composetypes.Networks(map[string]composetypes.NetworkConfig{"skynet": {}}),
 	}
 	prepareNetworks(&project)
-	assert.DeepEqual(t, project.Networks["skynet"].Labels, types.Labels(map[string]string{
+	assert.DeepEqual(t, project.Networks["skynet"].Labels, composetypes.Labels(map[string]string{
 		"com.docker.compose.network": "skynet",
 		"com.docker.compose.project": "myProject",
 		"com.docker.compose.version": api.ComposeVersion,
@@ -143,15 +142,6 @@ func TestBuildContainerMountOptions(t *testing.T) {
 	assert.Equal(t, mounts[1].Target, "/var/myvolume2")
 }
 
-func TestGetBindMode(t *testing.T) {
-	assert.Equal(t, getBindMode(&composetypes.ServiceVolumeBind{}, false), "rw")
-	assert.Equal(t, getBindMode(&composetypes.ServiceVolumeBind{}, true), "ro")
-	assert.Equal(t, getBindMode(&composetypes.ServiceVolumeBind{SELinux: composetypes.SELinuxShared}, false), "rw,z")
-	assert.Equal(t, getBindMode(&composetypes.ServiceVolumeBind{SELinux: composetypes.SELinuxPrivate}, false), "rw,Z")
-	assert.Equal(t, getBindMode(&composetypes.ServiceVolumeBind{SELinux: composetypes.SELinuxShared}, true), "ro,z")
-	assert.Equal(t, getBindMode(&composetypes.ServiceVolumeBind{SELinux: composetypes.SELinuxPrivate}, true), "ro,Z")
-}
-
 func TestGetDefaultNetworkMode(t *testing.T) {
 	t.Run("returns the network with the highest priority when service has multiple networks", func(t *testing.T) {
 		service := composetypes.ServiceConfig{

pkg/compose/dependencies.go

@@ -132,7 +132,7 @@ func getParents(v *Vertex) []*Vertex {
 	return v.GetParents()
 }
 
-// GetParents returns a slice with the parent vertexes of the a Vertex
+// GetParents returns a slice with the parent vertices of the a Vertex
 func (v *Vertex) GetParents() []*Vertex {
 	var res []*Vertex
 	for _, p := range v.Parents {
@@ -145,7 +145,7 @@ func getChildren(v *Vertex) []*Vertex {
 	return v.GetChildren()
 }
 
-// GetChildren returns a slice with the child vertexes of the a Vertex
+// GetChildren returns a slice with the child vertices of the a Vertex
 func (v *Vertex) GetChildren() []*Vertex {
 	var res []*Vertex
 	for _, p := range v.Children {
@@ -194,7 +194,7 @@ func (g *Graph) AddVertex(key string, service string, initialStatus ServiceStatu
 	g.Vertices[key] = v
 }
 
-// AddEdge adds a relationship of dependency between vertexes `source` and `destination`
+// AddEdge adds a relationship of dependency between vertices `source` and `destination`
 func (g *Graph) AddEdge(source string, destination string) error {
 	g.lock.Lock()
 	defer g.lock.Unlock()

pkg/compose/down.go

@@ -26,6 +26,7 @@ import (
 	moby "github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/errdefs"
+	"github.com/pkg/errors"
 	"golang.org/x/sync/errgroup"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -41,7 +42,6 @@ func (s *composeService) Down(ctx context.Context, projectName string, options a
 }
 
 func (s *composeService) down(ctx context.Context, projectName string, options api.DownOptions) error {
-	builtFromResources := options.Project == nil
 	w := progress.ContextWriter(ctx)
 	resourceToRemove := false
 
@@ -51,8 +51,9 @@ func (s *composeService) down(ctx context.Context, projectName string, options a
 		return err
 	}
 
-	if builtFromResources {
-		options.Project, err = s.getProjectWithVolumes(ctx, containers, projectName)
+	project := options.Project
+	if project == nil {
+		project, err = s.getProjectWithResources(ctx, containers, projectName)
 		if err != nil {
 			return err
 		}
@@ -62,7 +63,7 @@ func (s *composeService) down(ctx context.Context, projectName string, options a
 		resourceToRemove = true
 	}
 
-	err = InReverseDependencyOrder(ctx, options.Project, func(c context.Context, service string) error {
+	err = InReverseDependencyOrder(ctx, project, func(c context.Context, service string) error {
 		serviceContainers := containers.filter(isService(service))
 		err := s.removeContainers(ctx, w, serviceContainers, options.Timeout, options.Volumes)
 		return err
@@ -71,7 +72,7 @@ func (s *composeService) down(ctx context.Context, projectName string, options a
 		return err
 	}
 
-	orphans := containers.filter(isNotService(options.Project.ServiceNames()...))
+	orphans := containers.filter(isNotService(project.ServiceNames()...))
 	if options.RemoveOrphans && len(orphans) > 0 {
 		err := s.removeContainers(ctx, w, orphans, options.Timeout, false)
 		if err != nil {
@@ -79,21 +80,18 @@ func (s *composeService) down(ctx context.Context, projectName string, options a
 		}
 	}
 
-	ops, err := s.ensureNetworksDown(ctx, projectName)
-	if err != nil {
-		return err
-	}
+	ops := s.ensureNetworksDown(ctx, project, w)
 
 	if options.Images != "" {
-		ops = append(ops, s.ensureImagesDown(ctx, projectName, options, w)...)
+		ops = append(ops, s.ensureImagesDown(ctx, project, options, w)...)
 	}
 
 	if options.Volumes {
-		ops = append(ops, s.ensureVolumesDown(ctx, options.Project, w)...)
+		ops = append(ops, s.ensureVolumesDown(ctx, project, w)...)
 	}
 
 	if !resourceToRemove && len(ops) == 0 {
-		w.Event(progress.NewEvent(projectName, progress.Done, "Warning: No resource found to remove"))
+		fmt.Fprintf(s.stderr(), "Warning: No resource found to remove for project %q.\n", projectName)
 	}
 
 	eg, _ := errgroup.WithContext(ctx)
@@ -106,6 +104,9 @@ func (s *composeService) down(ctx context.Context, projectName string, options a
 func (s *composeService) ensureVolumesDown(ctx context.Context, project *types.Project, w progress.Writer) []downOp {
 	var ops []downOp
 	for _, vol := range project.Volumes {
+		if vol.External.External {
+			continue
+		}
 		volumeName := vol.Name
 		ops = append(ops, func() error {
 			return s.removeVolume(ctx, volumeName, w)
@@ -114,9 +115,9 @@ func (s *composeService) ensureVolumesDown(ctx context.Context, project *types.P
 	return ops
 }
 
-func (s *composeService) ensureImagesDown(ctx context.Context, projectName string, options api.DownOptions, w progress.Writer) []downOp {
+func (s *composeService) ensureImagesDown(ctx context.Context, project *types.Project, options api.DownOptions, w progress.Writer) []downOp {
 	var ops []downOp
-	for image := range s.getServiceImages(options, projectName) {
+	for image := range s.getServiceImages(options, project) {
 		image := image
 		ops = append(ops, func() error {
 			return s.removeImage(ctx, image, w)
@@ -125,31 +126,76 @@ func (s *composeService) ensureImagesDown(ctx context.Context, projectName strin
 	return ops
 }
 
-func (s *composeService) ensureNetworksDown(ctx context.Context, projectName string) ([]downOp, error) {
+func (s *composeService) ensureNetworksDown(ctx context.Context, project *types.Project, w progress.Writer) []downOp {
 	var ops []downOp
-	networks, err := s.apiClient().NetworkList(ctx, moby.NetworkListOptions{Filters: filters.NewArgs(projectFilter(projectName))})
-	if err != nil {
-		return ops, err
-	}
-	for _, n := range networks {
-		networkID := n.ID
+	for _, n := range project.Networks {
+		if n.External.External {
+			continue
+		}
+		// loop capture variable for op closure
 		networkName := n.Name
 		ops = append(ops, func() error {
-			return s.removeNetwork(ctx, networkID, networkName)
+			return s.removeNetwork(ctx, networkName, w)
 		})
 	}
-	return ops, nil
+	return ops
 }
 
-func (s *composeService) getServiceImages(options api.DownOptions, projectName string) map[string]struct{} {
+func (s *composeService) removeNetwork(ctx context.Context, name string, w progress.Writer) error {
+	// networks are guaranteed to have unique IDs but NOT names, so it's
+	// possible to get into a situation where a compose down will fail with
+	// an error along the lines of:
+	// 	failed to remove network test: Error response from daemon: network test is ambiguous (2 matches found based on name)
+	// as a workaround here, the delete is done by ID after doing a list using
+	// the name as a filter (99.9% of the time this will return a single result)
+	networks, err := s.apiClient().NetworkList(ctx, moby.NetworkListOptions{
+		Filters: filters.NewArgs(filters.Arg("name", name)),
+	})
+	if err != nil {
+		return errors.Wrapf(err, fmt.Sprintf("failed to inspect network %s", name))
+	}
+	if len(networks) == 0 {
+		return nil
+	}
+
+	eventName := fmt.Sprintf("Network %s", name)
+	w.Event(progress.RemovingEvent(eventName))
+
+	var removed int
+	for _, net := range networks {
+		if net.Name == name {
+			if err := s.apiClient().NetworkRemove(ctx, net.ID); err != nil {
+				if errdefs.IsNotFound(err) {
+					continue
+				}
+				w.Event(progress.ErrorEvent(eventName))
+				return errors.Wrapf(err, fmt.Sprintf("failed to remove network %s", name))
+			}
+			removed++
+		}
+	}
+
+	if removed == 0 {
+		// in practice, it's extremely unlikely for this to ever occur, as it'd
+		// mean the network was present when we queried at the start of this
+		// method but was then deleted by something else in the interim
+		w.Event(progress.NewEvent(eventName, progress.Done, "Warning: No resource found to remove"))
+		return nil
+	}
+
+	w.Event(progress.RemovedEvent(eventName))
+	return nil
+}
+
+func (s *composeService) getServiceImages(options api.DownOptions, project *types.Project) map[string]struct{} {
 	images := map[string]struct{}{}
-	for _, service := range options.Project.Services {
+	for _, service := range project.Services {
 		image := service.Image
 		if options.Images == "local" && image != "" {
 			continue
 		}
 		if image == "" {
-			image = getImageName(service, projectName)
+			image = getImageName(service, project.Name)
 		}
 		images[image] = struct{}{}
 	}
@@ -233,21 +279,23 @@ func (s *composeService) removeContainers(ctx context.Context, w progress.Writer
 	return eg.Wait()
 }
 
-func (s *composeService) getProjectWithVolumes(ctx context.Context, containers Containers, projectName string) (*types.Project, error) {
+func (s *composeService) getProjectWithResources(ctx context.Context, containers Containers, projectName string) (*types.Project, error) {
 	containers = containers.filter(isNotOneOff)
-	project, _ := s.projectFromName(containers, projectName)
-	volumes, err := s.apiClient().VolumeList(ctx, filters.NewArgs(projectFilter(projectName)))
-	if err != nil {
+	project, err := s.projectFromName(containers, projectName)
+	if err != nil && !api.IsNotFoundError(err) {
 		return nil, err
 	}
 
-	project.Volumes = types.Volumes{}
-	for _, vol := range volumes.Volumes {
-		project.Volumes[vol.Labels[api.VolumeLabel]] = types.VolumeConfig{
-			Name:   vol.Name,
-			Driver: vol.Driver,
-			Labels: vol.Labels,
-		}
+	volumes, err := s.actualVolumes(ctx, projectName)
+	if err != nil {
+		return nil, err
 	}
+	project.Volumes = volumes
+
+	networks, err := s.actualNetworks(ctx, projectName)
+	if err != nil {
+		return nil, err
+	}
+	project.Networks = networks
 	return project, nil
 }

pkg/compose/down_test.go

@@ -21,14 +21,14 @@ import (
 	"strings"
 	"testing"
 
-	compose "github.com/docker/compose/v2/pkg/api"
-	"github.com/docker/compose/v2/pkg/mocks"
-
 	moby "github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/volume"
 	"github.com/golang/mock/gomock"
 	"gotest.tools/v3/assert"
+
+	compose "github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/mocks"
 )
 
 func TestDown(t *testing.T) {
@@ -50,6 +50,14 @@ func TestDown(t *testing.T) {
 	api.EXPECT().VolumeList(gomock.Any(), filters.NewArgs(projectFilter(strings.ToLower(testProject)))).
 		Return(volume.VolumeListOKBody{}, nil)
 
+	// network names are not guaranteed to be unique, ensure Compose handles
+	// cleanup properly if duplicates are inadvertently created
+	api.EXPECT().NetworkList(gomock.Any(), moby.NetworkListOptions{Filters: filters.NewArgs(projectFilter(strings.ToLower(testProject)))}).
+		Return([]moby.NetworkResource{
+			{ID: "abc123", Name: "myProject_default"},
+			{ID: "def456", Name: "myProject_default"},
+		}, nil)
+
 	api.EXPECT().ContainerStop(gomock.Any(), "123", nil).Return(nil)
 	api.EXPECT().ContainerStop(gomock.Any(), "456", nil).Return(nil)
 	api.EXPECT().ContainerStop(gomock.Any(), "789", nil).Return(nil)
@@ -58,10 +66,14 @@ func TestDown(t *testing.T) {
 	api.EXPECT().ContainerRemove(gomock.Any(), "456", moby.ContainerRemoveOptions{Force: true}).Return(nil)
 	api.EXPECT().ContainerRemove(gomock.Any(), "789", moby.ContainerRemoveOptions{Force: true}).Return(nil)
 
-	api.EXPECT().NetworkList(gomock.Any(), moby.NetworkListOptions{Filters: filters.NewArgs(projectFilter(strings.ToLower(testProject)))}).Return([]moby.NetworkResource{{ID: "myProject_default"}},
-		nil)
-
-	api.EXPECT().NetworkRemove(gomock.Any(), "myProject_default").Return(nil)
+	api.EXPECT().NetworkList(gomock.Any(), moby.NetworkListOptions{
+		Filters: filters.NewArgs(filters.Arg("name", "myProject_default")),
+	}).Return([]moby.NetworkResource{
+		{ID: "abc123", Name: "myProject_default"},
+		{ID: "def456", Name: "myProject_default"},
+	}, nil)
+	api.EXPECT().NetworkRemove(gomock.Any(), "abc123").Return(nil)
+	api.EXPECT().NetworkRemove(gomock.Any(), "def456").Return(nil)
 
 	err := tested.Down(context.Background(), strings.ToLower(testProject), compose.DownOptions{})
 	assert.NilError(t, err)
@@ -84,6 +96,8 @@ func TestDownRemoveOrphans(t *testing.T) {
 		}, nil)
 	api.EXPECT().VolumeList(gomock.Any(), filters.NewArgs(projectFilter(strings.ToLower(testProject)))).
 		Return(volume.VolumeListOKBody{}, nil)
+	api.EXPECT().NetworkList(gomock.Any(), moby.NetworkListOptions{Filters: filters.NewArgs(projectFilter(strings.ToLower(testProject)))}).
+		Return([]moby.NetworkResource{{Name: "myProject_default"}}, nil)
 
 	api.EXPECT().ContainerStop(gomock.Any(), "123", nil).Return(nil)
 	api.EXPECT().ContainerStop(gomock.Any(), "789", nil).Return(nil)
@@ -93,10 +107,10 @@ func TestDownRemoveOrphans(t *testing.T) {
 	api.EXPECT().ContainerRemove(gomock.Any(), "789", moby.ContainerRemoveOptions{Force: true}).Return(nil)
 	api.EXPECT().ContainerRemove(gomock.Any(), "321", moby.ContainerRemoveOptions{Force: true}).Return(nil)
 
-	api.EXPECT().NetworkList(gomock.Any(), moby.NetworkListOptions{Filters: filters.NewArgs(projectFilter(strings.ToLower(testProject)))}).Return([]moby.NetworkResource{{ID: "myProject_default"}},
-		nil)
-
-	api.EXPECT().NetworkRemove(gomock.Any(), "myProject_default").Return(nil)
+	api.EXPECT().NetworkList(gomock.Any(), moby.NetworkListOptions{
+		Filters: filters.NewArgs(filters.Arg("name", "myProject_default")),
+	}).Return([]moby.NetworkResource{{ID: "abc123", Name: "myProject_default"}}, nil)
+	api.EXPECT().NetworkRemove(gomock.Any(), "abc123").Return(nil)
 
 	err := tested.Down(context.Background(), strings.ToLower(testProject), compose.DownOptions{RemoveOrphans: true})
 	assert.NilError(t, err)
@@ -117,12 +131,12 @@ func TestDownRemoveVolumes(t *testing.T) {
 		Return(volume.VolumeListOKBody{
 			Volumes: []*moby.Volume{{Name: "myProject_volume"}},
 		}, nil)
+	api.EXPECT().NetworkList(gomock.Any(), moby.NetworkListOptions{Filters: filters.NewArgs(projectFilter(strings.ToLower(testProject)))}).
+		Return(nil, nil)
 
 	api.EXPECT().ContainerStop(gomock.Any(), "123", nil).Return(nil)
 	api.EXPECT().ContainerRemove(gomock.Any(), "123", moby.ContainerRemoveOptions{Force: true, RemoveVolumes: true}).Return(nil)
 
-	api.EXPECT().NetworkList(gomock.Any(), moby.NetworkListOptions{Filters: filters.NewArgs(projectFilter(strings.ToLower(testProject)))}).Return(nil, nil)
-
 	api.EXPECT().VolumeRemove(gomock.Any(), "myProject_volume", true).Return(nil)
 
 	err := tested.Down(context.Background(), strings.ToLower(testProject), compose.DownOptions{Volumes: true})

pkg/compose/events.go

@@ -29,9 +29,10 @@ import (
 	"github.com/docker/compose/v2/pkg/utils"
 )
 
-func (s *composeService) Events(ctx context.Context, project string, options api.EventsOptions) error {
+func (s *composeService) Events(ctx context.Context, projectName string, options api.EventsOptions) error {
+	projectName = strings.ToLower(projectName)
 	events, errors := s.apiClient().Events(ctx, moby.EventsOptions{
-		Filters: filters.NewArgs(projectFilter(project)),
+		Filters: filters.NewArgs(projectFilter(projectName)),
 	})
 	for {
 		select {

pkg/compose/exec.go

@@ -18,148 +18,44 @@ package compose
 
 import (
 	"context"
-	"fmt"
-	"io"
-
-	moby "github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/pkg/stdcopy"
-	"github.com/moby/term"
+	"strings"
 
+	"github.com/docker/cli/cli"
+	"github.com/docker/cli/cli/command/container"
 	"github.com/docker/compose/v2/pkg/api"
+	moby "github.com/docker/docker/api/types"
 )
 
-func (s *composeService) Exec(ctx context.Context, project string, opts api.RunOptions) (int, error) {
-	container, err := s.getExecTarget(ctx, project, opts)
+func (s *composeService) Exec(ctx context.Context, projectName string, options api.RunOptions) (int, error) {
+	projectName = strings.ToLower(projectName)
+	target, err := s.getExecTarget(ctx, projectName, options)
 	if err != nil {
 		return 0, err
 	}
 
-	exec, err := s.apiClient().ContainerExecCreate(ctx, container.ID, moby.ExecConfig{
-		Cmd:        opts.Command,
-		Env:        opts.Environment,
-		User:       opts.User,
-		Privileged: opts.Privileged,
-		Tty:        opts.Tty,
-		Detach:     opts.Detach,
-		WorkingDir: opts.WorkingDir,
-
-		AttachStdin:  true,
-		AttachStdout: true,
-		AttachStderr: true,
-	})
-	if err != nil {
-		return 0, err
-	}
-
-	if opts.Detach {
-		return 0, s.apiClient().ContainerExecStart(ctx, exec.ID, moby.ExecStartCheck{
-			Detach: true,
-			Tty:    opts.Tty,
-		})
-	}
-
-	resp, err := s.apiClient().ContainerExecAttach(ctx, exec.ID, moby.ExecStartCheck{
-		Tty: opts.Tty,
-	})
-	if err != nil {
-		return 0, err
-	}
-	defer resp.Close() //nolint:errcheck
-
-	if opts.Tty {
-		s.monitorTTySize(ctx, exec.ID, s.apiClient().ContainerExecResize)
+	exec := container.NewExecOptions()
+	exec.Interactive = options.Interactive
+	exec.TTY = options.Tty
+	exec.Detach = options.Detach
+	exec.User = options.User
+	exec.Privileged = options.Privileged
+	exec.Workdir = options.WorkingDir
+	exec.Container = target.ID
+	exec.Command = options.Command
+	for _, v := range options.Environment {
+		err := exec.Env.Set(v)
 		if err != nil {
 			return 0, err
 		}
 	}
 
-	err = s.interactiveExec(ctx, opts, resp)
-	if err != nil {
-		return 0, err
-	}
-
-	return s.getExecExitStatus(ctx, exec.ID)
-}
-
-// inspired by https://github.com/docker/cli/blob/master/cli/command/container/exec.go#L116
-func (s *composeService) interactiveExec(ctx context.Context, opts api.RunOptions, resp moby.HijackedResponse) error {
-	outputDone := make(chan error)
-	inputDone := make(chan error)
-
-	stdout := ContainerStdout{HijackedResponse: resp}
-	stdin := ContainerStdin{HijackedResponse: resp}
-	r, err := s.getEscapeKeyProxy(s.stdin(), opts.Tty)
-	if err != nil {
-		return err
-	}
-
-	in := s.stdin()
-	if in.IsTerminal() && opts.Tty {
-		state, err := term.SetRawTerminal(in.FD())
-		if err != nil {
-			return err
-		}
-		defer term.RestoreTerminal(in.FD(), state) //nolint:errcheck
-	}
-
-	go func() {
-		if opts.Tty {
-			_, err := io.Copy(s.stdout(), stdout)
-			outputDone <- err
-		} else {
-			_, err := stdcopy.StdCopy(s.stdout(), s.stderr(), stdout)
-			outputDone <- err
-		}
-		stdout.Close() //nolint:errcheck
-	}()
-
-	go func() {
-		_, err := io.Copy(stdin, r)
-		inputDone <- err
-		stdin.Close() //nolint:errcheck
-	}()
-
-	for {
-		select {
-		case err := <-outputDone:
-			return err
-		case err := <-inputDone:
-			if _, ok := err.(term.EscapeError); ok {
-				return nil
-			}
-			if err != nil {
-				return err
-			}
-			// Wait for output to complete streaming
-		case <-ctx.Done():
-			return ctx.Err()
-		}
+	err = container.RunExec(s.dockerCli, exec)
+	if sterr, ok := err.(cli.StatusError); ok {
+		return sterr.StatusCode, nil
 	}
+	return 0, err
 }
 
 func (s *composeService) getExecTarget(ctx context.Context, projectName string, opts api.RunOptions) (moby.Container, error) {
-	containers, err := s.apiClient().ContainerList(ctx, moby.ContainerListOptions{
-		Filters: filters.NewArgs(
-			projectFilter(projectName),
-			serviceFilter(opts.Service),
-			containerNumberFilter(opts.Index),
-		),
-	})
-	if err != nil {
-		return moby.Container{}, err
-	}
-	if len(containers) < 1 {
-		return moby.Container{}, fmt.Errorf("service %q is not running container #%d", opts.Service, opts.Index)
-	}
-	container := containers[0]
-	return container, nil
-}
-
-func (s *composeService) getExecExitStatus(ctx context.Context, execID string) (int, error) {
-	resp, err := s.apiClient().ContainerExecInspect(ctx, execID)
-	if err != nil {
-		return 0, err
-	}
-	return resp.ExitCode, nil
+	return s.getSpecifiedContainer(ctx, projectName, oneOffInclude, false, opts.Service, opts.Index)
 }

pkg/compose/images.go

@@ -32,6 +32,7 @@ import (
 )
 
 func (s *composeService) Images(ctx context.Context, projectName string, options api.ImagesOptions) ([]api.ImageSummary, error) {
+	projectName = strings.ToLower(projectName)
 	allContainers, err := s.apiClient().ContainerList(ctx, moby.ContainerListOptions{
 		All:     true,
 		Filters: filters.NewArgs(projectFilter(projectName)),
@@ -93,7 +94,6 @@ func (s *composeService) getImages(ctx context.Context, images []string) (map[st
 			tag := ""
 			repository := ""
 			if len(inspect.RepoTags) > 0 {
-
 				repotag := strings.Split(inspect.RepoTags[0], ":")
 				repository = repotag[0]
 				if len(repotag) > 1 {

pkg/compose/kill.go

@@ -18,8 +18,9 @@ package compose
 
 import (
 	"context"
+	"fmt"
+	"strings"
 
-	"github.com/compose-spec/compose-go/types"
 	moby "github.com/docker/docker/api/types"
 	"golang.org/x/sync/errgroup"
 
@@ -27,29 +28,29 @@ import (
 	"github.com/docker/compose/v2/pkg/progress"
 )
 
-func (s *composeService) Kill(ctx context.Context, project *types.Project, options api.KillOptions) error {
+func (s *composeService) Kill(ctx context.Context, projectName string, options api.KillOptions) error {
 	return progress.Run(ctx, func(ctx context.Context) error {
-		return s.kill(ctx, project, options)
+		return s.kill(ctx, strings.ToLower(projectName), options)
 	})
 }
 
-func (s *composeService) kill(ctx context.Context, project *types.Project, options api.KillOptions) error {
+func (s *composeService) kill(ctx context.Context, projectName string, options api.KillOptions) error {
 	w := progress.ContextWriter(ctx)
 
 	services := options.Services
-	if len(services) == 0 {
-		services = project.ServiceNames()
-	}
 
 	var containers Containers
-	containers, err := s.getContainers(ctx, project.Name, oneOffInclude, false, services...)
+	containers, err := s.getContainers(ctx, projectName, oneOffInclude, false, services...)
 	if err != nil {
 		return err
 	}
 
+	if len(containers) == 0 {
+		fmt.Fprintf(s.stderr(), "no container to kill")
+	}
+
 	eg, ctx := errgroup.WithContext(ctx)
 	containers.
-		filter(isService(project.ServiceNames()...)).
 		forEach(func(container moby.Container) {
 			eg.Go(func() error {
 				eventName := getContainerProgressName(container)

pkg/compose/kill_test.go

@@ -22,7 +22,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/compose-spec/compose-go/types"
 	moby "github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/golang/mock/gomock"
@@ -45,18 +44,18 @@ func TestKillAll(t *testing.T) {
 	tested.dockerCli = cli
 	cli.EXPECT().Client().Return(api).AnyTimes()
 
-	project := types.Project{Name: strings.ToLower(testProject), Services: []types.ServiceConfig{testService("service1"), testService("service2")}}
+	name := strings.ToLower(testProject)
 
 	ctx := context.Background()
 	api.EXPECT().ContainerList(ctx, moby.ContainerListOptions{
-		Filters: filters.NewArgs(projectFilter(strings.ToLower(testProject))),
+		Filters: filters.NewArgs(projectFilter(name)),
 	}).Return(
 		[]moby.Container{testContainer("service1", "123", false), testContainer("service1", "456", false), testContainer("service2", "789", false)}, nil)
 	api.EXPECT().ContainerKill(anyCancellableContext(), "123", "").Return(nil)
 	api.EXPECT().ContainerKill(anyCancellableContext(), "456", "").Return(nil)
 	api.EXPECT().ContainerKill(anyCancellableContext(), "789", "").Return(nil)
 
-	err := tested.kill(ctx, &project, compose.KillOptions{})
+	err := tested.kill(ctx, name, compose.KillOptions{})
 	assert.NilError(t, err)
 }
 
@@ -70,23 +69,19 @@ func TestKillSignal(t *testing.T) {
 	tested.dockerCli = cli
 	cli.EXPECT().Client().Return(api).AnyTimes()
 
-	project := types.Project{Name: strings.ToLower(testProject), Services: []types.ServiceConfig{testService(serviceName)}}
+	name := strings.ToLower(testProject)
 	listOptions := moby.ContainerListOptions{
-		Filters: filters.NewArgs(projectFilter(strings.ToLower(testProject)), serviceFilter(serviceName)),
+		Filters: filters.NewArgs(projectFilter(name), serviceFilter(serviceName)),
 	}
 
 	ctx := context.Background()
 	api.EXPECT().ContainerList(ctx, listOptions).Return([]moby.Container{testContainer(serviceName, "123", false)}, nil)
 	api.EXPECT().ContainerKill(anyCancellableContext(), "123", "SIGTERM").Return(nil)
 
-	err := tested.kill(ctx, &project, compose.KillOptions{Services: []string{serviceName}, Signal: "SIGTERM"})
+	err := tested.kill(ctx, name, compose.KillOptions{Services: []string{serviceName}, Signal: "SIGTERM"})
 	assert.NilError(t, err)
 }
 
-func testService(name string) types.ServiceConfig {
-	return types.ServiceConfig{Name: name}
-}
-
 func testContainer(service string, id string, oneOff bool) moby.Container {
 	return moby.Container{
 		ID:     id,

pkg/compose/logs.go

@@ -19,6 +19,7 @@ package compose
 import (
 	"context"
 	"io"
+	"strings"
 
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/utils"
@@ -28,6 +29,7 @@ import (
 )
 
 func (s *composeService) Logs(ctx context.Context, projectName string, consumer api.LogConsumer, options api.LogOptions) error {
+	projectName = strings.ToLower(projectName)
 	containers, err := s.getContainers(ctx, projectName, oneOffExclude, true, options.Services...)
 	if err != nil {
 		return err
@@ -93,7 +95,7 @@ func (s *composeService) logContainers(ctx context.Context, consumer api.LogCons
 	if err != nil {
 		return err
 	}
-	defer r.Close() // nolint errcheck
+	defer r.Close() //nolint errcheck
 
 	name := getContainerNameWithoutProject(c)
 	w := utils.GetWriter(func(line string) {

pkg/compose/ls.go

@@ -106,9 +106,9 @@ func combinedStatus(statuses []string) string {
 	for _, status := range keys {
 		nb := nbByStatus[status]
 		if result != "" {
-			result = result + ", "
+			result += ", "
 		}
-		result = result + fmt.Sprintf("%s(%d)", status, nb)
+		result += fmt.Sprintf("%s(%d)", status, nb)
 	}
 	return result
 }

pkg/compose/metrics.go

@@ -50,13 +50,13 @@ var (
 	ComposeParseFailure = FailureCategory{MetricsStatus: ComposeParseFailureStatus, ExitCode: 15}
 	// CommandSyntaxFailure failure for command line syntax
 	CommandSyntaxFailure = FailureCategory{MetricsStatus: CommandSyntaxFailureStatus, ExitCode: 16}
-	//BuildFailure failure while building images.
+	// BuildFailure failure while building images.
 	BuildFailure = FailureCategory{MetricsStatus: BuildFailureStatus, ExitCode: 17}
 	// PullFailure failure while pulling image
 	PullFailure = FailureCategory{MetricsStatus: PullFailureStatus, ExitCode: 18}
 )
 
-//ByExitCode retrieve FailureCategory based on command exit code
+// ByExitCode retrieve FailureCategory based on command exit code
 func ByExitCode(exitCode int) FailureCategory {
 	switch exitCode {
 	case 0:

pkg/compose/pause.go

@@ -18,6 +18,7 @@ package compose
 
 import (
 	"context"
+	"strings"
 
 	moby "github.com/docker/docker/api/types"
 	"golang.org/x/sync/errgroup"
@@ -26,9 +27,9 @@ import (
 	"github.com/docker/compose/v2/pkg/progress"
 )
 
-func (s *composeService) Pause(ctx context.Context, project string, options api.PauseOptions) error {
+func (s *composeService) Pause(ctx context.Context, projectName string, options api.PauseOptions) error {
 	return progress.Run(ctx, func(ctx context.Context) error {
-		return s.pause(ctx, project, options)
+		return s.pause(ctx, strings.ToLower(projectName), options)
 	})
 }
 
@@ -54,14 +55,14 @@ func (s *composeService) pause(ctx context.Context, project string, options api.
 	return eg.Wait()
 }
 
-func (s *composeService) UnPause(ctx context.Context, project string, options api.PauseOptions) error {
+func (s *composeService) UnPause(ctx context.Context, projectName string, options api.PauseOptions) error {
 	return progress.Run(ctx, func(ctx context.Context) error {
-		return s.unPause(ctx, project, options)
+		return s.unPause(ctx, strings.ToLower(projectName), options)
 	})
 }
 
-func (s *composeService) unPause(ctx context.Context, project string, options api.PauseOptions) error {
-	containers, err := s.getContainers(ctx, project, oneOffExclude, false, options.Services...)
+func (s *composeService) unPause(ctx context.Context, projectName string, options api.PauseOptions) error {
+	containers, err := s.getContainers(ctx, projectName, oneOffExclude, false, options.Services...)
 	if err != nil {
 		return err
 	}

pkg/compose/port.go

@@ -19,6 +19,7 @@ package compose
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"github.com/docker/compose/v2/pkg/api"
 
@@ -26,10 +27,11 @@ import (
 	"github.com/docker/docker/api/types/filters"
 )
 
-func (s *composeService) Port(ctx context.Context, project string, service string, port int, options api.PortOptions) (string, int, error) {
+func (s *composeService) Port(ctx context.Context, projectName string, service string, port int, options api.PortOptions) (string, int, error) {
+	projectName = strings.ToLower(projectName)
 	list, err := s.apiClient().ContainerList(ctx, moby.ContainerListOptions{
 		Filters: filters.NewArgs(
-			projectFilter(project),
+			projectFilter(projectName),
 			serviceFilter(service),
 			containerNumberFilter(options.Index),
 		),

pkg/compose/printer.go

@@ -32,6 +32,11 @@ type logPrinter interface {
 	Cancel()
 }
 
+type printer struct {
+	queue    chan api.ContainerEvent
+	consumer api.LogConsumer
+}
+
 // newLogPrinter builds a LogPrinter passing containers logs to LogConsumer
 func newLogPrinter(consumer api.LogConsumer) logPrinter {
 	queue := make(chan api.ContainerEvent)
@@ -48,11 +53,6 @@ func (p *printer) Cancel() {
 	}
 }
 
-type printer struct {
-	queue    chan api.ContainerEvent
-	consumer api.LogConsumer
-}
-
 func (p *printer) HandleEvent(event api.ContainerEvent) {
 	p.queue <- event
 }

pkg/compose/ps.go

@@ -19,6 +19,7 @@ package compose
 import (
 	"context"
 	"sort"
+	"strings"
 
 	"golang.org/x/sync/errgroup"
 
@@ -26,6 +27,7 @@ import (
 )
 
 func (s *composeService) Ps(ctx context.Context, projectName string, options api.PsOptions) ([]api.ContainerSummary, error) {
+	projectName = strings.ToLower(projectName)
 	oneOff := oneOffExclude
 	if options.All {
 		oneOff = oneOffInclude

pkg/compose/pull.go

@@ -36,12 +36,12 @@ import (
 	"github.com/docker/compose/v2/pkg/progress"
 )
 
-func (s *composeService) Pull(ctx context.Context, project *types.Project, opts api.PullOptions) error {
-	if opts.Quiet {
-		return s.pull(ctx, project, opts)
+func (s *composeService) Pull(ctx context.Context, project *types.Project, options api.PullOptions) error {
+	if options.Quiet {
+		return s.pull(ctx, project, options)
 	}
 	return progress.Run(ctx, func(ctx context.Context) error {
-		return s.pull(ctx, project, opts)
+		return s.pull(ctx, project, options)
 	})
 }
 
@@ -55,6 +55,11 @@ func (s *composeService) pull(ctx context.Context, project *types.Project, opts
 		info.IndexServerAddress = registry.IndexServer
 	}
 
+	images, err := s.getLocalImagesDigests(ctx, project)
+	if err != nil {
+		return err
+	}
+
 	w := progress.ContextWriter(ctx)
 	eg, ctx := errgroup.WithContext(ctx)
 
@@ -69,8 +74,28 @@ func (s *composeService) pull(ctx context.Context, project *types.Project, opts
 			})
 			continue
 		}
+
+		switch service.PullPolicy {
+		case types.PullPolicyNever, types.PullPolicyBuild:
+			w.Event(progress.Event{
+				ID:     service.Name,
+				Status: progress.Done,
+				Text:   "Skipped",
+			})
+			continue
+		case types.PullPolicyMissing, types.PullPolicyIfNotPresent:
+			if _, ok := images[service.Image]; ok {
+				w.Event(progress.Event{
+					ID:     service.Name,
+					Status: progress.Done,
+					Text:   "Exists",
+				})
+				continue
+			}
+		}
+
 		eg.Go(func() error {
-			err := s.pullServiceImage(ctx, service, info, s.configFile(), w, false)
+			_, err := s.pullServiceImage(ctx, service, info, s.configFile(), w, false)
 			if err != nil {
 				if !opts.IgnoreFailures {
 					if service.Build != nil {
@@ -93,7 +118,7 @@ func (s *composeService) pull(ctx context.Context, project *types.Project, opts
 	return err
 }
 
-func (s *composeService) pullServiceImage(ctx context.Context, service types.ServiceConfig, info moby.Info, configFile driver.Auth, w progress.Writer, quietPull bool) error {
+func (s *composeService) pullServiceImage(ctx context.Context, service types.ServiceConfig, info moby.Info, configFile driver.Auth, w progress.Writer, quietPull bool) (string, error) {
 	w.Event(progress.Event{
 		ID:     service.Name,
 		Status: progress.Working,
@@ -101,12 +126,12 @@ func (s *composeService) pullServiceImage(ctx context.Context, service types.Ser
 	})
 	ref, err := reference.ParseNormalizedNamed(service.Image)
 	if err != nil {
-		return err
+		return "", err
 	}
 
 	repoInfo, err := registry.ParseRepositoryInfo(ref)
 	if err != nil {
-		return err
+		return "", err
 	}
 
 	key := repoInfo.Index.Name
@@ -116,12 +141,12 @@ func (s *composeService) pullServiceImage(ctx context.Context, service types.Ser
 
 	authConfig, err := configFile.GetAuthConfig(key)
 	if err != nil {
-		return err
+		return "", err
 	}
 
 	buf, err := json.Marshal(authConfig)
 	if err != nil {
-		return err
+		return "", err
 	}
 
 	stream, err := s.apiClient().ImagePull(ctx, service.Image, moby.ImagePullOptions{
@@ -134,7 +159,7 @@ func (s *composeService) pullServiceImage(ctx context.Context, service types.Ser
 			Status: progress.Error,
 			Text:   "Error",
 		})
-		return WrapCategorisedComposeError(err, PullFailure)
+		return "", WrapCategorisedComposeError(err, PullFailure)
 	}
 
 	dec := json.NewDecoder(stream)
@@ -144,10 +169,10 @@ func (s *composeService) pullServiceImage(ctx context.Context, service types.Ser
 			if err == io.EOF {
 				break
 			}
-			return WrapCategorisedComposeError(err, PullFailure)
+			return "", WrapCategorisedComposeError(err, PullFailure)
 		}
 		if jm.Error != nil {
-			return WrapCategorisedComposeError(errors.New(jm.Error.Message), PullFailure)
+			return "", WrapCategorisedComposeError(errors.New(jm.Error.Message), PullFailure)
 		}
 		if !quietPull {
 			toPullProgressEvent(service.Name, jm, w)
@@ -158,7 +183,12 @@ func (s *composeService) pullServiceImage(ctx context.Context, service types.Ser
 		Status: progress.Done,
 		Text:   "Pulled",
 	})
-	return nil
+
+	inspected, _, err := s.dockerCli.Client().ImageInspectWithRaw(ctx, service.Image)
+	if err != nil {
+		return "", err
+	}
+	return inspected.ID, nil
 }
 
 func (s *composeService) pullRequiredImages(ctx context.Context, project *types.Project, images map[string]string, quietPull bool) error {
@@ -195,10 +225,12 @@ func (s *composeService) pullRequiredImages(ctx context.Context, project *types.
 	return progress.Run(ctx, func(ctx context.Context) error {
 		w := progress.ContextWriter(ctx)
 		eg, ctx := errgroup.WithContext(ctx)
-		for _, service := range needPull {
-			service := service
+		pulledImages := make([]string, len(needPull))
+		for i, service := range needPull {
+			i, service := i, service
 			eg.Go(func() error {
-				err := s.pullServiceImage(ctx, service, info, s.configFile(), w, quietPull)
+				id, err := s.pullServiceImage(ctx, service, info, s.configFile(), w, quietPull)
+				pulledImages[i] = id
 				if err != nil && service.Build != nil {
 					// image can be built, so we can ignore pull failure
 					return nil
@@ -206,7 +238,16 @@ func (s *composeService) pullRequiredImages(ctx context.Context, project *types.
 				return err
 			})
 		}
-		return eg.Wait()
+		for i, service := range needPull {
+			if pulledImages[i] != "" {
+				images[service.Image] = pulledImages[i]
+			}
+		}
+		err := eg.Wait()
+		if err != nil {
+			return err
+		}
+		return err
 	})
 }
 

pkg/compose/remove.go

@@ -30,8 +30,13 @@ import (
 )
 
 func (s *composeService) Remove(ctx context.Context, projectName string, options api.RemoveOptions) error {
+	projectName = strings.ToLower(projectName)
 	containers, _, err := s.actualState(ctx, projectName, options.Services)
 	if err != nil {
+		if api.IsNotFoundError(err) {
+			fmt.Fprintln(s.stderr(), "No stopped containers")
+			return nil
+		}
 		return err
 	}
 
@@ -45,7 +50,7 @@ func (s *composeService) Remove(ctx context.Context, projectName string, options
 	})
 
 	if len(names) == 0 {
-		fmt.Println("No stopped containers")
+		fmt.Fprintln(s.stderr(), "No stopped containers")
 		return nil
 	}
 	msg := fmt.Sprintf("Going to remove %s", strings.Join(names, ", "))

pkg/compose/resize.go

@@ -1,74 +0,0 @@
-/*
-   Copyright 2020 Docker Compose CLI authors
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-package compose
-
-import (
-	"context"
-	"os"
-	gosignal "os/signal"
-	"runtime"
-	"time"
-
-	"github.com/buger/goterm"
-	moby "github.com/docker/docker/api/types"
-	"github.com/docker/docker/pkg/signal"
-)
-
-func (s *composeService) monitorTTySize(ctx context.Context, container string, resize func(context.Context, string, moby.ResizeOptions) error) {
-	err := resize(ctx, container, moby.ResizeOptions{ // nolint:errcheck
-		Height: uint(goterm.Height()),
-		Width:  uint(goterm.Width()),
-	})
-	if err != nil {
-		return
-	}
-
-	sigchan := make(chan os.Signal, 1)
-	gosignal.Notify(sigchan, signal.SIGWINCH)
-
-	if runtime.GOOS == "windows" {
-		// Windows has no SIGWINCH support, so we have to poll tty size ¯\_(ツ)_/¯
-		go func() {
-			prevH := goterm.Height()
-			prevW := goterm.Width()
-			for {
-				time.Sleep(time.Millisecond * 250)
-				h := goterm.Height()
-				w := goterm.Width()
-				if prevW != w || prevH != h {
-					sigchan <- signal.SIGWINCH
-				}
-				prevH = h
-				prevW = w
-			}
-		}()
-	}
-
-	go func() {
-		for {
-			select {
-			case <-sigchan:
-				resize(ctx, container, moby.ResizeOptions{ // nolint:errcheck
-					Height: uint(goterm.Height()),
-					Width:  uint(goterm.Width()),
-				})
-			case <-ctx.Done():
-				return
-			}
-		}
-	}()
-}

pkg/compose/restart.go

@@ -18,6 +18,7 @@ package compose
 
 import (
 	"context"
+	"strings"
 
 	"github.com/docker/compose/v2/pkg/api"
 	"golang.org/x/sync/errgroup"
@@ -28,13 +29,13 @@ import (
 
 func (s *composeService) Restart(ctx context.Context, projectName string, options api.RestartOptions) error {
 	return progress.Run(ctx, func(ctx context.Context) error {
-		return s.restart(ctx, projectName, options)
+		return s.restart(ctx, strings.ToLower(projectName), options)
 	})
 }
 
 func (s *composeService) restart(ctx context.Context, projectName string, options api.RestartOptions) error {
 
-	observedState, err := s.getContainers(ctx, projectName, oneOffInclude, true)
+	observedState, err := s.getContainers(ctx, projectName, oneOffExclude, true)
 	if err != nil {
 		return err
 	}

pkg/compose/run.go

@@ -19,16 +19,12 @@ package compose
 import (
 	"context"
 	"fmt"
-	"io"
 
 	"github.com/compose-spec/compose-go/types"
+	"github.com/docker/cli/cli"
+	cmd "github.com/docker/cli/cli/command/container"
 	"github.com/docker/compose/v2/pkg/api"
-	moby "github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/pkg/ioutils"
-	"github.com/docker/docker/pkg/stdcopy"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/moby/term"
 )
 
 func (s *composeService) RunOneOffContainer(ctx context.Context, project *types.Project, opts api.RunOptions) (int, error) {
@@ -37,98 +33,16 @@ func (s *composeService) RunOneOffContainer(ctx context.Context, project *types.
 		return 0, err
 	}
 
-	if opts.Detach {
-		err := s.apiClient().ContainerStart(ctx, containerID, moby.ContainerStartOptions{})
-		if err != nil {
-			return 0, err
-		}
-		fmt.Fprintln(s.stdout(), containerID)
-		return 0, nil
+	start := cmd.NewStartOptions()
+	start.OpenStdin = !opts.Detach && opts.Interactive
+	start.Attach = !opts.Detach
+	start.Containers = []string{containerID}
+
+	err = cmd.RunStart(s.dockerCli, &start)
+	if sterr, ok := err.(cli.StatusError); ok {
+		return sterr.StatusCode, nil
 	}
-
-	return s.runInteractive(ctx, containerID, opts)
-}
-
-func (s *composeService) runInteractive(ctx context.Context, containerID string, opts api.RunOptions) (int, error) {
-	in := s.stdin()
-	r, err := s.getEscapeKeyProxy(in, opts.Tty)
-	if err != nil {
-		return 0, err
-	}
-
-	stdin, stdout, err := s.getContainerStreams(ctx, containerID)
-	if err != nil {
-		return 0, err
-	}
-
-	if in.IsTerminal() && opts.Tty {
-		state, err := term.SetRawTerminal(in.FD())
-		if err != nil {
-			return 0, err
-		}
-		defer term.RestoreTerminal(in.FD(), state) //nolint:errcheck
-	}
-
-	outputDone := make(chan error)
-	inputDone := make(chan error)
-
-	go func() {
-		if opts.Tty {
-			_, err := io.Copy(s.stdout(), stdout) //nolint:errcheck
-			outputDone <- err
-		} else {
-			_, err := stdcopy.StdCopy(s.stdout(), s.stderr(), stdout) //nolint:errcheck
-			outputDone <- err
-		}
-		stdout.Close() //nolint:errcheck
-	}()
-
-	go func() {
-		_, err := io.Copy(stdin, r)
-		inputDone <- err
-		stdin.Close() //nolint:errcheck
-	}()
-
-	err = s.apiClient().ContainerStart(ctx, containerID, moby.ContainerStartOptions{})
-	if err != nil {
-		return 0, err
-	}
-
-	s.monitorTTySize(ctx, containerID, s.apiClient().ContainerResize)
-
-	for {
-		select {
-		case err := <-outputDone:
-			if err != nil {
-				return 0, err
-			}
-			return s.terminateRun(ctx, containerID, opts)
-		case err := <-inputDone:
-			if _, ok := err.(term.EscapeError); ok {
-				return 0, nil
-			}
-			if err != nil {
-				return 0, err
-			}
-			// Wait for output to complete streaming
-		case <-ctx.Done():
-			return 0, ctx.Err()
-		}
-	}
-}
-
-func (s *composeService) terminateRun(ctx context.Context, containerID string, opts api.RunOptions) (exitCode int, err error) {
-	exitCh, errCh := s.apiClient().ContainerWait(ctx, containerID, container.WaitConditionNotRunning)
-	select {
-	case exit := <-exitCh:
-		exitCode = int(exit.StatusCode)
-	case err = <-errCh:
-		return
-	}
-	if opts.AutoRemove {
-		err = s.apiClient().ContainerRemove(ctx, containerID, moby.ContainerRemoveOptions{})
-	}
-	return
+	return 0, err
 }
 
 func (s *composeService) prepareRun(ctx context.Context, project *types.Project, opts api.RunOptions) (string, error) {
@@ -142,12 +56,15 @@ func (s *composeService) prepareRun(ctx context.Context, project *types.Project,
 
 	applyRunOptions(project, &service, opts)
 
+	if err := s.dockerCli.In().CheckTty(opts.Interactive, service.Tty); err != nil {
+		return "", err
+	}
+
 	slug := stringid.GenerateRandomID()
 	if service.ContainerName == "" {
 		service.ContainerName = fmt.Sprintf("%s_%s_run_%s", project.Name, service.Name, stringid.TruncateID(slug))
 	}
 	service.Scale = 1
-	service.StdinOpen = true
 	service.Restart = ""
 	if service.Deploy != nil {
 		service.Deploy.RestartPolicy = nil
@@ -171,32 +88,17 @@ func (s *composeService) prepareRun(ctx context.Context, project *types.Project,
 	}
 	updateServices(&service, observedState)
 
-	created, err := s.createContainer(ctx, project, service, service.ContainerName, 1, opts.Detach && opts.AutoRemove, opts.UseNetworkAliases, true)
+	created, err := s.createContainer(ctx, project, service, service.ContainerName, 1,
+		opts.AutoRemove, opts.UseNetworkAliases, opts.Interactive)
 	if err != nil {
 		return "", err
 	}
-	containerID := created.ID
-	return containerID, nil
-}
-
-func (s *composeService) getEscapeKeyProxy(r io.ReadCloser, isTty bool) (io.ReadCloser, error) {
-	if !isTty {
-		return r, nil
-	}
-	var escapeKeys = []byte{16, 17}
-	if s.configFile().DetachKeys != "" {
-		customEscapeKeys, err := term.ToBytes(s.configFile().DetachKeys)
-		if err != nil {
-			return nil, err
-		}
-		escapeKeys = customEscapeKeys
-	}
-	return ioutils.NewReadCloserWrapper(term.NewEscapeProxy(r, escapeKeys), r.Close), nil
+	return created.ID, nil
 }
 
 func applyRunOptions(project *types.Project, service *types.ServiceConfig, opts api.RunOptions) {
 	service.Tty = opts.Tty
-	service.StdinOpen = true
+	service.StdinOpen = opts.Interactive
 	service.ContainerName = opts.Name
 
 	if len(opts.Command) > 0 {
@@ -214,6 +116,9 @@ func applyRunOptions(project *types.Project, service *types.ServiceConfig, opts
 	if len(opts.Environment) > 0 {
 		env := types.NewMappingWithEquals(opts.Environment)
 		projectEnv := env.Resolve(func(s string) (string, bool) {
+			if _, ok := service.Environment[s]; ok {
+				return "", false
+			}
 			v, ok := project.Environment[s]
 			return v, ok
 		}).RemoveEmpty()

pkg/compose/secrets.go

@@ -0,0 +1,88 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package compose
+
+import (
+	"archive/tar"
+	"bytes"
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/compose-spec/compose-go/types"
+	moby "github.com/docker/docker/api/types"
+)
+
+func (s *composeService) injectSecrets(ctx context.Context, project *types.Project, service types.ServiceConfig, id string) error {
+	for _, config := range service.Secrets {
+		secret := project.Secrets[config.Source]
+		if secret.Environment == "" {
+			continue
+		}
+
+		env, ok := project.Environment[secret.Environment]
+		if !ok {
+			return fmt.Errorf("environment variable %q required by secret %q is not set", secret.Environment, secret.Name)
+		}
+		b, err := createTar(env, config)
+		if err != nil {
+			return err
+		}
+
+		err = s.apiClient().CopyToContainer(ctx, id, "/", &b, moby.CopyToContainerOptions{
+			CopyUIDGID: true,
+		})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func createTar(env string, config types.ServiceSecretConfig) (bytes.Buffer, error) {
+	value := []byte(env)
+	b := bytes.Buffer{}
+	tarWriter := tar.NewWriter(&b)
+	mode := uint32(0o400)
+	if config.Mode != nil {
+		mode = *config.Mode
+	}
+
+	target := config.Target
+	if config.Target == "" {
+		target = "/run/secrets/" + config.Source
+	} else if !isUnixAbs(config.Target) {
+		target = "/run/secrets/" + config.Target
+	}
+
+	header := &tar.Header{
+		Name:    target,
+		Size:    int64(len(value)),
+		Mode:    int64(mode),
+		ModTime: time.Now(),
+	}
+	err := tarWriter.WriteHeader(header)
+	if err != nil {
+		return bytes.Buffer{}, err
+	}
+	_, err = tarWriter.Write(value)
+	if err != nil {
+		return bytes.Buffer{}, err
+	}
+	err = tarWriter.Close()
+	return b, err
+}

pkg/compose/start.go

@@ -18,6 +18,7 @@ package compose
 
 import (
 	"context"
+	"strings"
 
 	"github.com/compose-spec/compose-go/types"
 	moby "github.com/docker/docker/api/types"
@@ -30,20 +31,23 @@ import (
 
 func (s *composeService) Start(ctx context.Context, projectName string, options api.StartOptions) error {
 	return progress.Run(ctx, func(ctx context.Context) error {
-		return s.start(ctx, projectName, options, nil)
+		return s.start(ctx, strings.ToLower(projectName), options, nil)
 	})
 }
 
 func (s *composeService) start(ctx context.Context, projectName string, options api.StartOptions, listener api.ContainerEventListener) error {
-	var containers Containers
-	containers, err := s.getContainers(ctx, projectName, oneOffExclude, true)
-	if err != nil {
-		return err
-	}
+	project := options.Project
+	if project == nil {
+		var containers Containers
+		containers, err := s.getContainers(ctx, projectName, oneOffExclude, true)
+		if err != nil {
+			return err
+		}
 
-	project, err := s.projectFromName(containers, projectName, options.AttachTo...)
-	if err != nil {
-		return err
+		project, err = s.projectFromName(containers, projectName, options.AttachTo...)
+		if err != nil {
+			return err
+		}
 	}
 
 	eg, ctx := errgroup.WithContext(ctx)
@@ -55,12 +59,12 @@ func (s *composeService) start(ctx context.Context, projectName string, options
 
 		eg.Go(func() error {
 			return s.watchContainers(context.Background(), project.Name, options.AttachTo, listener, attached, func(container moby.Container) error {
-				return s.attachContainer(ctx, container, listener, project)
+				return s.attachContainer(ctx, container, listener)
 			})
 		})
 	}
 
-	err = InDependencyOrder(ctx, project, func(c context.Context, name string) error {
+	err := InDependencyOrder(ctx, project, func(c context.Context, name string) error {
 		service, err := project.GetService(name)
 		if err != nil {
 			return err
@@ -76,7 +80,7 @@ func (s *composeService) start(ctx context.Context, projectName string, options
 		depends := types.DependsOnConfig{}
 		for _, s := range project.Services {
 			depends[s.Name] = types.ServiceDependency{
-				Condition: ServiceConditionRunningOrHealthy,
+				Condition: getDependencyCondition(s, project),
 			}
 		}
 		err = s.waitDependencies(ctx, project, depends)
@@ -88,6 +92,20 @@ func (s *composeService) start(ctx context.Context, projectName string, options
 	return eg.Wait()
 }
 
+// getDependencyCondition checks if service is depended on by other services
+// with service_completed_successfully condition, and applies that condition
+// instead, or --wait will never finish waiting for one-shot containers
+func getDependencyCondition(service types.ServiceConfig, project *types.Project) string {
+	for _, services := range project.Services {
+		for dependencyService, dependencyConfig := range services.DependsOn {
+			if dependencyService == service.Name && dependencyConfig.Condition == types.ServiceConditionCompletedSuccessfully {
+				return types.ServiceConditionCompletedSuccessfully
+			}
+		}
+	}
+	return ServiceConditionRunningOrHealthy
+}
+
 type containerWatchFn func(container moby.Container) error
 
 // watchContainers uses engine events to capture container start/die and notify ContainerEventListener

pkg/compose/stop.go

@@ -18,6 +18,7 @@ package compose
 
 import (
 	"context"
+	"strings"
 
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/progress"
@@ -25,7 +26,7 @@ import (
 
 func (s *composeService) Stop(ctx context.Context, projectName string, options api.StopOptions) error {
 	return progress.Run(ctx, func(ctx context.Context) error {
-		return s.stop(ctx, projectName, options)
+		return s.stop(ctx, strings.ToLower(projectName), options)
 	})
 }
 
@@ -38,6 +39,7 @@ func (s *composeService) stop(ctx context.Context, projectName string, options a
 	}
 
 	return InReverseDependencyOrder(ctx, project, func(c context.Context, service string) error {
-		return s.stopContainers(ctx, w, containers.filter(isService(service)), options.Timeout)
+		containersToStop := containers.filter(isService(service)).filter(isNotOneOff)
+		return s.stopContainers(ctx, w, containersToStop, options.Timeout)
 	})
 }

pkg/compose/top.go

@@ -18,12 +18,14 @@ package compose
 
 import (
 	"context"
+	"strings"
 
 	"github.com/docker/compose/v2/pkg/api"
 	"golang.org/x/sync/errgroup"
 )
 
 func (s *composeService) Top(ctx context.Context, projectName string, services []string) ([]api.ContainerProcSummary, error) {
+	projectName = strings.ToLower(projectName)
 	var containers Containers
 	containers, err := s.getContainers(ctx, projectName, oneOffInclude, false)
 	if err != nil {

pkg/compose/up.go

@@ -60,13 +60,13 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options
 		return progress.Run(ctx, func(ctx context.Context) error {
 			go func() {
 				<-signalChan
-				s.Kill(ctx, project, api.KillOptions{ // nolint:errcheck
-					Services: options.Create.Services,
+				s.Kill(ctx, project.Name, api.KillOptions{ //nolint:errcheck
+					Services: project.ServiceNames(),
 				})
 			}()
 
 			return s.Stop(ctx, project.Name, api.StopOptions{
-				Services: options.Create.Services,
+				Services: project.ServiceNames(),
 			})
 		})
 	}
@@ -74,7 +74,7 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options
 		<-signalChan
 		printer.Cancel()
 		fmt.Println("Gracefully stopping... (press Ctrl+C again to force)")
-		stopFunc() // nolint:errcheck
+		stopFunc() //nolint:errcheck
 	}()
 
 	var exitCode int

pkg/e2e/build_test.go

@@ -0,0 +1,245 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package e2e
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"gotest.tools/v3/assert"
+	"gotest.tools/v3/icmd"
+)
+
+func TestLocalComposeBuild(t *testing.T) {
+	c := NewParallelCLI(t)
+
+	t.Run("build named and unnamed images", func(t *testing.T) {
+		// ensure local test run does not reuse previously build image
+		c.RunDockerOrExitError(t, "rmi", "build-test_nginx")
+		c.RunDockerOrExitError(t, "rmi", "custom-nginx")
+
+		res := c.RunDockerComposeCmd(t, "--project-directory", "fixtures/build-test", "build")
+
+		res.Assert(t, icmd.Expected{Out: "COPY static /usr/share/nginx/html"})
+		c.RunDockerCmd(t, "image", "inspect", "build-test_nginx")
+		c.RunDockerCmd(t, "image", "inspect", "custom-nginx")
+	})
+
+	t.Run("build with build-arg", func(t *testing.T) {
+		// ensure local test run does not reuse previously build image
+		c.RunDockerOrExitError(t, "rmi", "build-test_nginx")
+		c.RunDockerOrExitError(t, "rmi", "custom-nginx")
+
+		c.RunDockerComposeCmd(t, "--project-directory", "fixtures/build-test", "build", "--build-arg", "FOO=BAR")
+
+		res := c.RunDockerCmd(t, "image", "inspect", "build-test_nginx")
+		res.Assert(t, icmd.Expected{Out: `"FOO": "BAR"`})
+	})
+
+	t.Run("build with build-arg set by env", func(t *testing.T) {
+		// ensure local test run does not reuse previously build image
+		c.RunDockerOrExitError(t, "rmi", "build-test_nginx")
+		c.RunDockerOrExitError(t, "rmi", "custom-nginx")
+
+		icmd.RunCmd(c.NewDockerComposeCmd(t,
+			"--project-directory",
+			"fixtures/build-test",
+			"build",
+			"--build-arg",
+			"FOO"),
+			func(cmd *icmd.Cmd) {
+				cmd.Env = append(cmd.Env, "FOO=BAR")
+			})
+
+		res := c.RunDockerCmd(t, "image", "inspect", "build-test_nginx")
+		res.Assert(t, icmd.Expected{Out: `"FOO": "BAR"`})
+	})
+
+	t.Run("build with multiple build-args ", func(t *testing.T) {
+		// ensure local test run does not reuse previously build image
+		c.RunDockerOrExitError(t, "rmi", "-f", "multi-args_multiargs")
+		cmd := c.NewDockerComposeCmd(t, "--project-directory", "fixtures/build-test/multi-args", "build")
+
+		icmd.RunCmd(cmd, func(cmd *icmd.Cmd) {
+			cmd.Env = append(cmd.Env, "DOCKER_BUILDKIT=0")
+		})
+
+		res := c.RunDockerCmd(t, "image", "inspect", "multi-args_multiargs")
+		res.Assert(t, icmd.Expected{Out: `"RESULT": "SUCCESS"`})
+	})
+
+	t.Run("build failed with ssh default value", func(t *testing.T) {
+		res := c.RunDockerComposeCmdNoCheck(t, "--project-directory", "fixtures/build-test", "build", "--ssh", "")
+		res.Assert(t, icmd.Expected{
+			ExitCode: 1,
+			Err:      "invalid empty ssh agent socket: make sure SSH_AUTH_SOCK is set",
+		})
+
+	})
+
+	t.Run("build succeed with ssh from Compose file", func(t *testing.T) {
+		c.RunDockerOrExitError(t, "rmi", "build-test-ssh")
+
+		c.RunDockerComposeCmd(t, "--project-directory", "fixtures/build-test/ssh", "build")
+		c.RunDockerCmd(t, "image", "inspect", "build-test-ssh")
+	})
+
+	t.Run("build succeed with ssh from CLI", func(t *testing.T) {
+		c.RunDockerOrExitError(t, "rmi", "build-test-ssh")
+
+		c.RunDockerComposeCmd(t, "-f", "fixtures/build-test/ssh/compose-without-ssh.yaml", "--project-directory",
+			"fixtures/build-test/ssh", "build", "--no-cache", "--ssh", "fake-ssh=./fixtures/build-test/ssh/fake_rsa")
+		c.RunDockerCmd(t, "image", "inspect", "build-test-ssh")
+	})
+
+	t.Run("build failed with wrong ssh key id from CLI", func(t *testing.T) {
+		c.RunDockerOrExitError(t, "rmi", "build-test-ssh")
+
+		res := c.RunDockerComposeCmdNoCheck(t, "-f", "fixtures/build-test/ssh/compose-without-ssh.yaml",
+			"--project-directory", "fixtures/build-test/ssh", "build", "--no-cache", "--ssh",
+			"wrong-ssh=./fixtures/build-test/ssh/fake_rsa")
+		res.Assert(t, icmd.Expected{
+			ExitCode: 17,
+			Err:      "failed to solve: rpc error: code = Unknown desc = unset ssh forward key fake-ssh",
+		})
+	})
+
+	t.Run("build succeed as part of up with ssh from Compose file", func(t *testing.T) {
+		c.RunDockerOrExitError(t, "rmi", "build-test-ssh")
+
+		c.RunDockerComposeCmd(t, "--project-directory", "fixtures/build-test/ssh", "up", "-d", "--build")
+		t.Cleanup(func() {
+			c.RunDockerComposeCmd(t, "--project-directory", "fixtures/build-test/ssh", "down")
+		})
+		c.RunDockerCmd(t, "image", "inspect", "build-test-ssh")
+	})
+
+	t.Run("build as part of up", func(t *testing.T) {
+		c.RunDockerOrExitError(t, "rmi", "build-test_nginx")
+		c.RunDockerOrExitError(t, "rmi", "custom-nginx")
+
+		res := c.RunDockerComposeCmd(t, "--project-directory", "fixtures/build-test", "up", "-d")
+		t.Cleanup(func() {
+			c.RunDockerComposeCmd(t, "--project-directory", "fixtures/build-test", "down")
+		})
+
+		res.Assert(t, icmd.Expected{Out: "COPY static /usr/share/nginx/html"})
+		res.Assert(t, icmd.Expected{Out: "COPY static2 /usr/share/nginx/html"})
+
+		output := HTTPGetWithRetry(t, "http://localhost:8070", http.StatusOK, 2*time.Second, 20*time.Second)
+		assert.Assert(t, strings.Contains(output, "Hello from Nginx container"))
+
+		c.RunDockerCmd(t, "image", "inspect", "build-test_nginx")
+		c.RunDockerCmd(t, "image", "inspect", "custom-nginx")
+	})
+
+	t.Run("no rebuild when up again", func(t *testing.T) {
+		res := c.RunDockerComposeCmd(t, "--project-directory", "fixtures/build-test", "up", "-d")
+
+		assert.Assert(t, !strings.Contains(res.Stdout(), "COPY static"), res.Stdout())
+	})
+
+	t.Run("rebuild when up --build", func(t *testing.T) {
+		res := c.RunDockerComposeCmd(t, "--workdir", "fixtures/build-test", "up", "-d", "--build")
+
+		res.Assert(t, icmd.Expected{Out: "COPY static /usr/share/nginx/html"})
+		res.Assert(t, icmd.Expected{Out: "COPY static2 /usr/share/nginx/html"})
+	})
+
+	t.Run("cleanup build project", func(t *testing.T) {
+		c.RunDockerComposeCmd(t, "--project-directory", "fixtures/build-test", "down")
+		c.RunDockerCmd(t, "rmi", "build-test_nginx")
+		c.RunDockerCmd(t, "rmi", "custom-nginx")
+	})
+}
+
+func TestBuildSecrets(t *testing.T) {
+	c := NewParallelCLI(t)
+
+	t.Run("build with secrets", func(t *testing.T) {
+		// ensure local test run does not reuse previously build image
+		c.RunDockerOrExitError(t, "rmi", "build-test-secret")
+
+		cmd := c.NewDockerComposeCmd(t, "--project-directory", "fixtures/build-test/secrets", "build")
+
+		res := icmd.RunCmd(cmd, func(cmd *icmd.Cmd) {
+			cmd.Env = append(cmd.Env, "SOME_SECRET=bar")
+		})
+
+		res.Assert(t, icmd.Success)
+	})
+}
+
+func TestBuildTags(t *testing.T) {
+	c := NewParallelCLI(t)
+
+	t.Run("build with tags", func(t *testing.T) {
+
+		// ensure local test run does not reuse previously build image
+		c.RunDockerOrExitError(t, "rmi", "build-test-tags")
+
+		c.RunDockerComposeCmd(t, "--project-directory", "./fixtures/build-test/tags", "build", "--no-cache")
+
+		res := c.RunDockerCmd(t, "image", "inspect", "build-test-tags")
+		expectedOutput := `"RepoTags": [
+            "docker/build-test-tags:1.0.0",
+            "build-test-tags:latest",
+            "other-image-name:v1.0.0"
+        ],
+`
+		res.Assert(t, icmd.Expected{Out: expectedOutput})
+	})
+}
+
+func TestBuildImageDependencies(t *testing.T) {
+	doTest := func(t *testing.T, cli *CLI) {
+		resetState := func() {
+			cli.RunDockerComposeCmd(t, "down", "--rmi=all", "-t=0")
+		}
+		resetState()
+		t.Cleanup(resetState)
+
+		// the image should NOT exist now
+		res := cli.RunDockerOrExitError(t, "image", "inspect", "build-dependencies_service")
+		res.Assert(t, icmd.Expected{
+			ExitCode: 1,
+			Err:      "Error: No such image: build-dependencies_service",
+		})
+
+		res = cli.RunDockerComposeCmd(t, "build")
+		t.Log(res.Combined())
+
+		res = cli.RunDockerCmd(t,
+			"image", "inspect", "--format={{ index .RepoTags 0 }}",
+			"build-dependencies_service")
+		res.Assert(t, icmd.Expected{Out: "build-dependencies_service:latest"})
+	}
+
+	t.Run("ClassicBuilder", func(t *testing.T) {
+		cli := NewParallelCLI(t, WithEnv(
+			"DOCKER_BUILDKIT=0",
+			"COMPOSE_FILE=./fixtures/build-dependencies/compose.yaml",
+		))
+		doTest(t, cli)
+	})
+
+	t.Run("BuildKit", func(t *testing.T) {
+		t.Skip("See https://github.com/docker/compose/issues/9232")
+	})
+}

pkg/e2e/cancel_test.go

@@ -33,30 +33,34 @@ import (
 )
 
 func TestComposeCancel(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
 	t.Run("metrics on cancel Compose build", func(t *testing.T) {
-		c.RunDockerComposeCmd("ls")
+		c.RunDockerComposeCmd(t, "ls")
 		buildProjectPath := "fixtures/build-infinite/compose.yaml"
 
 		// require a separate groupID from the process running tests, in order to simulate ctrl+C from a terminal.
 		// sending kill signal
-		cmd, stdout, stderr, err := StartWithNewGroupID(c.NewDockerCmd("compose", "-f", buildProjectPath, "build", "--progress", "plain"))
+		cmd, stdout, stderr, err := StartWithNewGroupID(c.NewDockerComposeCmd(t, "-f", buildProjectPath, "build",
+			"--progress", "plain"))
 		assert.NilError(t, err)
 
-		c.WaitForCondition(func() (bool, string) {
+		c.WaitForCondition(t, func() (bool, string) {
 			out := stdout.String()
 			errors := stderr.String()
-			return strings.Contains(out, "RUN sleep infinity"), fmt.Sprintf("'RUN sleep infinity' not found in : \n%s\nStderr: \n%s\n", out, errors)
+			return strings.Contains(out,
+					"RUN sleep infinity"), fmt.Sprintf("'RUN sleep infinity' not found in : \n%s\nStderr: \n%s\n", out,
+					errors)
 		}, 30*time.Second, 1*time.Second)
 
 		err = syscall.Kill(-cmd.Process.Pid, syscall.SIGINT) // simulate Ctrl-C : send signal to processGroup, children will have same groupId by default
 
 		assert.NilError(t, err)
-		c.WaitForCondition(func() (bool, string) {
+		c.WaitForCondition(t, func() (bool, string) {
 			out := stdout.String()
 			errors := stderr.String()
-			return strings.Contains(out, "CANCELED"), fmt.Sprintf("'CANCELED' not found in : \n%s\nStderr: \n%s\n", out, errors)
+			return strings.Contains(out, "CANCELED"), fmt.Sprintf("'CANCELED' not found in : \n%s\nStderr: \n%s\n", out,
+				errors)
 		}, 10*time.Second, 1*time.Second)
 	})
 }

pkg/e2e/cascade_stop_test.go

@@ -23,28 +23,28 @@ import (
 )
 
 func TestCascadeStop(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
 	const projectName = "e2e-cascade-stop"
 
 	t.Run("abort-on-container-exit", func(t *testing.T) {
-		res := c.RunDockerOrExitError("compose", "-f", "./fixtures/cascade-stop-test/compose.yaml", "--project-name", projectName, "up", "--abort-on-container-exit")
+		res := c.RunDockerComposeCmdNoCheck(t, "-f", "./fixtures/cascade-stop-test/compose.yaml", "--project-name", projectName, "up", "--abort-on-container-exit")
 		res.Assert(t, icmd.Expected{ExitCode: 1, Out: `should_fail-1 exited with code 1`})
 		res.Assert(t, icmd.Expected{ExitCode: 1, Out: `Aborting on container exit...`})
 	})
 
 	t.Run("exit-code-from", func(t *testing.T) {
-		res := c.RunDockerOrExitError("compose", "-f", "./fixtures/cascade-stop-test/compose.yaml", "--project-name", projectName, "up", "--exit-code-from=sleep")
+		res := c.RunDockerComposeCmdNoCheck(t, "-f", "./fixtures/cascade-stop-test/compose.yaml", "--project-name", projectName, "up", "--exit-code-from=sleep")
 		res.Assert(t, icmd.Expected{ExitCode: 137, Out: `should_fail-1 exited with code 1`})
 		res.Assert(t, icmd.Expected{ExitCode: 137, Out: `Aborting on container exit...`})
 	})
 
 	t.Run("exit-code-from unknown", func(t *testing.T) {
-		res := c.RunDockerOrExitError("compose", "-f", "./fixtures/cascade-stop-test/compose.yaml", "--project-name", projectName, "up", "--exit-code-from=unknown")
+		res := c.RunDockerComposeCmdNoCheck(t, "-f", "./fixtures/cascade-stop-test/compose.yaml", "--project-name", projectName, "up", "--exit-code-from=unknown")
 		res.Assert(t, icmd.Expected{ExitCode: 1, Err: `no such service: unknown`})
 	})
 
 	t.Run("down", func(t *testing.T) {
-		_ = c.RunDockerComposeCmd("--project-name", projectName, "down")
+		_ = c.RunDockerComposeCmd(t, "--project-name", projectName, "down")
 	})
 }

pkg/e2e/compose_build_test.go

@@ -1,119 +0,0 @@
-/*
-   Copyright 2020 Docker Compose CLI authors
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-package e2e
-
-import (
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"gotest.tools/v3/assert"
-	"gotest.tools/v3/icmd"
-)
-
-func TestLocalComposeBuild(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
-
-	t.Run("build named and unnamed images", func(t *testing.T) {
-		// ensure local test run does not reuse previously build image
-		c.RunDockerOrExitError("rmi", "build-test_nginx")
-		c.RunDockerOrExitError("rmi", "custom-nginx")
-
-		res := c.RunDockerComposeCmd("--project-directory", "fixtures/build-test", "build")
-
-		res.Assert(t, icmd.Expected{Out: "COPY static /usr/share/nginx/html"})
-		c.RunDockerCmd("image", "inspect", "build-test_nginx")
-		c.RunDockerCmd("image", "inspect", "custom-nginx")
-	})
-
-	t.Run("build with build-arg", func(t *testing.T) {
-		// ensure local test run does not reuse previously build image
-		c.RunDockerOrExitError("rmi", "build-test_nginx")
-		c.RunDockerOrExitError("rmi", "custom-nginx")
-
-		c.RunDockerComposeCmd("--project-directory", "fixtures/build-test", "build", "--build-arg", "FOO=BAR")
-
-		res := c.RunDockerCmd("image", "inspect", "build-test_nginx")
-		res.Assert(t, icmd.Expected{Out: `"FOO": "BAR"`})
-	})
-
-	t.Run("build with build-arg set by env", func(t *testing.T) {
-		// ensure local test run does not reuse previously build image
-		c.RunDockerOrExitError("rmi", "build-test_nginx")
-		c.RunDockerOrExitError("rmi", "custom-nginx")
-
-		icmd.RunCmd(c.NewDockerCmd("compose", "--project-directory", "fixtures/build-test", "build", "--build-arg", "FOO"),
-			func(cmd *icmd.Cmd) {
-				cmd.Env = append(cmd.Env, "FOO=BAR")
-			})
-
-		res := c.RunDockerCmd("image", "inspect", "build-test_nginx")
-		res.Assert(t, icmd.Expected{Out: `"FOO": "BAR"`})
-	})
-
-	t.Run("build with multiple build-args ", func(t *testing.T) {
-		// ensure local test run does not reuse previously build image
-		c.RunDockerOrExitError("rmi", "-f", "multi-args_multiargs")
-		cmd := c.NewDockerCmd("compose", "--project-directory", "fixtures/build-test/multi-args", "build")
-
-		icmd.RunCmd(cmd, func(cmd *icmd.Cmd) {
-			cmd.Env = append(cmd.Env, "DOCKER_BUILDKIT=0")
-		})
-
-		res := c.RunDockerCmd("image", "inspect", "multi-args_multiargs")
-		res.Assert(t, icmd.Expected{Out: `"RESULT": "SUCCESS"`})
-	})
-
-	t.Run("build as part of up", func(t *testing.T) {
-		c.RunDockerOrExitError("rmi", "build-test_nginx")
-		c.RunDockerOrExitError("rmi", "custom-nginx")
-
-		res := c.RunDockerComposeCmd("--project-directory", "fixtures/build-test", "up", "-d")
-		t.Cleanup(func() {
-			c.RunDockerComposeCmd("--project-directory", "fixtures/build-test", "down")
-		})
-
-		res.Assert(t, icmd.Expected{Out: "COPY static /usr/share/nginx/html"})
-		res.Assert(t, icmd.Expected{Out: "COPY static2 /usr/share/nginx/html"})
-
-		output := HTTPGetWithRetry(t, "http://localhost:8070", http.StatusOK, 2*time.Second, 20*time.Second)
-		assert.Assert(t, strings.Contains(output, "Hello from Nginx container"))
-
-		c.RunDockerCmd("image", "inspect", "build-test_nginx")
-		c.RunDockerCmd("image", "inspect", "custom-nginx")
-	})
-
-	t.Run("no rebuild when up again", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("--project-directory", "fixtures/build-test", "up", "-d")
-
-		assert.Assert(t, !strings.Contains(res.Stdout(), "COPY static"), res.Stdout())
-	})
-
-	t.Run("rebuild when up --build", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("--workdir", "fixtures/build-test", "up", "-d", "--build")
-
-		res.Assert(t, icmd.Expected{Out: "COPY static /usr/share/nginx/html"})
-		res.Assert(t, icmd.Expected{Out: "COPY static2 /usr/share/nginx/html"})
-	})
-
-	t.Run("cleanup build project", func(t *testing.T) {
-		c.RunDockerComposeCmd("--project-directory", "fixtures/build-test", "down")
-		c.RunDockerCmd("rmi", "build-test_nginx")
-		c.RunDockerCmd("rmi", "custom-nginx")
-	})
-}

pkg/e2e/compose_down_test.go

@@ -0,0 +1,34 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package e2e
+
+import (
+	"testing"
+
+	"gotest.tools/v3/icmd"
+)
+
+func TestDown(t *testing.T) {
+	c := NewParallelCLI(t)
+
+	const projectName = "e2e-down"
+
+	t.Run("no resource to remove", func(t *testing.T) {
+		res := c.RunDockerComposeCmd(t, "--project-name", projectName, "down")
+		res.Assert(t, icmd.Expected{ExitCode: 0, Err: `No resource found to remove for project "e2e-down"`})
+	})
+}

pkg/e2e/compose_environment_test.go

@@ -0,0 +1,163 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package e2e
+
+import (
+	"strings"
+	"testing"
+
+	"gotest.tools/v3/assert"
+	"gotest.tools/v3/icmd"
+)
+
+func TestEnvPriority(t *testing.T) {
+	c := NewParallelCLI(t)
+
+	projectDir := "./fixtures/environment/env-priority"
+
+	t.Run("up", func(t *testing.T) {
+		c.RunDockerOrExitError(t, "rmi", "env-compose-priority")
+		c.RunDockerComposeCmd(t, "-f", "./fixtures/environment/env-priority/compose-with-env.yaml",
+			"--project-directory", projectDir, "up", "-d", "--build")
+	})
+
+	// Full options activated
+	// 1. Compose file <-- Result expected
+	// 2. Shell environment variables
+	// 3. Environment file
+	// 4. Dockerfile
+	// 5. Variable is not defined
+	t.Run("compose file priority", func(t *testing.T) {
+		cmd := c.NewDockerComposeCmd(t, "-f", "./fixtures/environment/env-priority/compose-with-env.yaml",
+			"--project-directory", projectDir, "--env-file", "./fixtures/environment/env-priority/.env.override", "run",
+			"--rm", "-e", "WHEREAMI", "env-compose-priority")
+		cmd.Env = append(cmd.Env, "WHEREAMI=shell")
+		res := icmd.RunCmd(cmd)
+		assert.Equal(t, strings.TrimSpace(res.Stdout()), "Compose File")
+	})
+
+	// No Compose file, all other options
+	// 1. Compose file
+	// 2. Shell environment variables <-- Result expected
+	// 3. Environment file
+	// 4. Dockerfile
+	// 5. Variable is not defined
+	t.Run("shell priority", func(t *testing.T) {
+		cmd := c.NewDockerComposeCmd(t, "-f", "./fixtures/environment/env-priority/compose.yaml", "--project-directory",
+			projectDir, "--env-file", "./fixtures/environment/env-priority/.env.override", "run", "--rm", "-e",
+			"WHEREAMI", "env-compose-priority")
+		cmd.Env = append(cmd.Env, "WHEREAMI=shell")
+		res := icmd.RunCmd(cmd)
+		assert.Equal(t, strings.TrimSpace(res.Stdout()), "shell")
+	})
+
+	//  No Compose file and env variable pass to the run command
+	// 1. Compose file
+	// 2. Shell environment variables <-- Result expected
+	// 3. Environment file
+	// 4. Dockerfile
+	// 5. Variable is not defined
+	t.Run("shell priority from run command", func(t *testing.T) {
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/environment/env-priority/compose.yaml", "--project-directory",
+			projectDir, "--env-file", "./fixtures/environment/env-priority/.env.override", "run", "--rm", "-e",
+			"WHEREAMI=shell-run", "env-compose-priority")
+		assert.Equal(t, strings.TrimSpace(res.Stdout()), "shell-run")
+	})
+
+	//  No Compose file & no env variable but override env file
+	// 1. Compose file
+	// 2. Shell environment variables
+	// 3. Environment file <-- Result expected
+	// 4. Dockerfile
+	// 5. Variable is not defined
+	t.Run("override env file", func(t *testing.T) {
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/environment/env-priority/compose.yaml", "--project-directory",
+			projectDir, "--env-file", "./fixtures/environment/env-priority/.env.override", "run", "--rm", "-e",
+			"WHEREAMI", "env-compose-priority")
+		assert.Equal(t, strings.TrimSpace(res.Stdout()), "override")
+	})
+
+	//  No Compose file & no env variable but override env file
+	// 1. Compose file
+	// 2. Shell environment variables
+	// 3. Environment file <-- Result expected
+	// 4. Dockerfile
+	// 5. Variable is not defined
+	t.Run("env file", func(t *testing.T) {
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/environment/env-priority/compose.yaml", "--project-directory",
+			projectDir, "run", "--rm", "-e", "WHEREAMI", "env-compose-priority")
+		assert.Equal(t, strings.TrimSpace(res.Stdout()), "Env File")
+	})
+
+	//  No Compose file & no env variable, using an empty override env file
+	// 1. Compose file
+	// 2. Shell environment variables
+	// 3. Environment file
+	// 4. Dockerfile   <-- Result expected
+	// 5. Variable is not defined
+	t.Run("use Dockerfile", func(t *testing.T) {
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/environment/env-priority/compose.yaml", "--project-directory",
+			projectDir, "--env-file", "./fixtures/environment/env-priority/.env.empty", "run", "--rm", "-e", "WHEREAMI",
+			"env-compose-priority")
+		assert.Equal(t, strings.TrimSpace(res.Stdout()), "Dockerfile")
+	})
+
+	t.Run("down", func(t *testing.T) {
+		c.RunDockerComposeCmd(t, "--project-directory", projectDir, "down")
+	})
+}
+
+func TestEnvInterpolation(t *testing.T) {
+	c := NewParallelCLI(t)
+
+	projectDir := "./fixtures/environment/env-interpolation"
+
+	//  No variable defined in the Compose file and env variable pass to the run command
+	// 1. Compose file
+	// 2. Shell environment variables <-- Result expected
+	// 3. Environment file
+	// 4. Dockerfile
+	// 5. Variable is not defined
+	t.Run("shell priority from run command", func(t *testing.T) {
+		cmd := c.NewDockerComposeCmd(t, "-f", "./fixtures/environment/env-interpolation/compose.yaml",
+			"--project-directory", projectDir, "config")
+		cmd.Env = append(cmd.Env, "WHEREAMI=shell")
+		res := icmd.RunCmd(cmd)
+		res.Assert(t, icmd.Expected{Out: `IMAGE: default_env:shell`})
+	})
+}
+
+func TestCommentsInEnvFile(t *testing.T) {
+	c := NewParallelCLI(t)
+
+	projectDir := "./fixtures/environment/env-file-comments"
+
+	t.Run("comments in env files", func(t *testing.T) {
+		c.RunDockerOrExitError(t, "rmi", "env-file-comments")
+
+		c.RunDockerComposeCmd(t, "-f", "./fixtures/environment/env-file-comments/compose.yaml", "--project-directory",
+			projectDir, "up", "-d", "--build")
+
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/environment/env-file-comments/compose.yaml",
+			"--project-directory", projectDir, "run", "--rm", "-e", "COMMENT", "-e", "NO_COMMENT", "env-file-comments")
+
+		res.Assert(t, icmd.Expected{Out: `COMMENT=1234`})
+		res.Assert(t, icmd.Expected{Out: `NO_COMMENT=1234#5`})
+
+		c.RunDockerComposeCmd(t, "--project-directory", projectDir, "down", "--rmi", "all")
+	})
+}

pkg/e2e/compose_exec_test.go

@@ -25,24 +25,29 @@ import (
 )
 
 func TestLocalComposeExec(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
 	const projectName = "compose-e2e-exec"
 
-	c.RunDockerComposeCmd("--project-directory", "fixtures/simple-composefile", "--project-name", projectName, "up", "-d")
+	cmdArgs := func(cmd string, args ...string) []string {
+		ret := []string{"--project-directory", "fixtures/simple-composefile", "--project-name", projectName, cmd}
+		ret = append(ret, args...)
+		return ret
+	}
+
+	c.RunDockerComposeCmd(t, cmdArgs("up", "-d")...)
 
 	t.Run("exec true", func(t *testing.T) {
-		res := c.RunDockerOrExitError("exec", "compose-e2e-exec-simple-1", "/bin/true")
-		res.Assert(t, icmd.Expected{ExitCode: 0})
+		c.RunDockerComposeCmd(t, cmdArgs("exec", "simple", "/bin/true")...)
 	})
 
 	t.Run("exec false", func(t *testing.T) {
-		res := c.RunDockerOrExitError("exec", "compose-e2e-exec-simple-1", "/bin/false")
+		res := c.RunDockerComposeCmdNoCheck(t, cmdArgs("exec", "simple", "/bin/false")...)
 		res.Assert(t, icmd.Expected{ExitCode: 1})
 	})
 
 	t.Run("exec with env set", func(t *testing.T) {
-		res := icmd.RunCmd(c.NewDockerCmd("exec", "-e", "FOO", "compose-e2e-exec-simple-1", "/usr/bin/env"),
+		res := icmd.RunCmd(c.NewDockerComposeCmd(t, cmdArgs("exec", "-e", "FOO", "simple", "/usr/bin/env")...),
 			func(cmd *icmd.Cmd) {
 				cmd.Env = append(cmd.Env, "FOO=BAR")
 			})
@@ -50,8 +55,7 @@ func TestLocalComposeExec(t *testing.T) {
 	})
 
 	t.Run("exec without env set", func(t *testing.T) {
-		res := c.RunDockerOrExitError("exec", "-e", "FOO", "compose-e2e-exec-simple-1", "/usr/bin/env")
-		res.Assert(t, icmd.Expected{ExitCode: 0})
-		assert.Check(t, !strings.Contains(res.Stdout(), "FOO="))
+		res := c.RunDockerComposeCmd(t, cmdArgs("exec", "-e", "FOO", "simple", "/usr/bin/env")...)
+		assert.Check(t, !strings.Contains(res.Stdout(), "FOO="), res.Combined())
 	})
 }

pkg/e2e/compose_run_test.go

@@ -26,21 +26,22 @@ import (
 )
 
 func TestLocalComposeRun(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
 	t.Run("compose run", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-f", "./fixtures/run-test/compose.yaml", "run", "back")
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/compose.yaml", "run", "back")
 		lines := Lines(res.Stdout())
 		assert.Equal(t, lines[len(lines)-1], "Hello there!!", res.Stdout())
 		assert.Assert(t, !strings.Contains(res.Combined(), "orphan"))
-		res = c.RunDockerComposeCmd("-f", "./fixtures/run-test/compose.yaml", "run", "back", "echo", "Hello one more time")
+		res = c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/compose.yaml", "run", "back", "echo",
+			"Hello one more time")
 		lines = Lines(res.Stdout())
 		assert.Equal(t, lines[len(lines)-1], "Hello one more time", res.Stdout())
 		assert.Assert(t, !strings.Contains(res.Combined(), "orphan"))
 	})
 
 	t.Run("check run container exited", func(t *testing.T) {
-		res := c.RunDockerCmd("ps", "--all")
+		res := c.RunDockerCmd(t, "ps", "--all")
 		lines := Lines(res.Stdout())
 		var runContainerID string
 		var truncatedSlug string
@@ -59,7 +60,7 @@ func TestLocalComposeRun(t *testing.T) {
 			}
 		}
 		assert.Assert(t, runContainerID != "")
-		res = c.RunDockerCmd("inspect", runContainerID)
+		res = c.RunDockerCmd(t, "inspect", runContainerID)
 		res.Assert(t, icmd.Expected{Out: ` "Status": "exited"`})
 		res.Assert(t, icmd.Expected{Out: `"com.docker.compose.container-number": "1"`})
 		res.Assert(t, icmd.Expected{Out: `"com.docker.compose.project": "run-test"`})
@@ -68,43 +69,46 @@ func TestLocalComposeRun(t *testing.T) {
 	})
 
 	t.Run("compose run --rm", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-f", "./fixtures/run-test/compose.yaml", "run", "--rm", "back", "echo", "Hello again")
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/compose.yaml", "run", "--rm", "back", "echo",
+			"Hello again")
 		lines := Lines(res.Stdout())
 		assert.Equal(t, lines[len(lines)-1], "Hello again", res.Stdout())
 
-		res = c.RunDockerCmd("ps", "--all")
+		res = c.RunDockerCmd(t, "ps", "--all")
 		assert.Assert(t, strings.Contains(res.Stdout(), "run-test_back"), res.Stdout())
 	})
 
 	t.Run("down", func(t *testing.T) {
-		c.RunDockerComposeCmd("-f", "./fixtures/run-test/compose.yaml", "down")
-		res := c.RunDockerCmd("ps", "--all")
+		c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/compose.yaml", "down")
+		res := c.RunDockerCmd(t, "ps", "--all")
 		assert.Assert(t, !strings.Contains(res.Stdout(), "run-test"), res.Stdout())
 	})
 
 	t.Run("compose run --volumes", func(t *testing.T) {
 		wd, err := os.Getwd()
 		assert.NilError(t, err)
-		res := c.RunDockerComposeCmd("-f", "./fixtures/run-test/compose.yaml", "run", "--volumes", wd+":/foo", "back", "/bin/sh", "-c", "ls /foo")
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/compose.yaml", "run", "--volumes", wd+":/foo",
+			"back", "/bin/sh", "-c", "ls /foo")
 		res.Assert(t, icmd.Expected{Out: "compose_run_test.go"})
 
-		res = c.RunDockerCmd("ps", "--all")
+		res = c.RunDockerCmd(t, "ps", "--all")
 		assert.Assert(t, strings.Contains(res.Stdout(), "run-test_back"), res.Stdout())
 	})
 
 	t.Run("compose run --publish", func(t *testing.T) {
-		c.RunDockerComposeCmd("-f", "./fixtures/run-test/compose.yaml", "run", "--publish", "8081:80", "-d", "back", "/bin/sh", "-c", "sleep 1")
-		res := c.RunDockerCmd("ps")
+		c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/compose.yaml", "run", "--publish", "8081:80", "-d", "back",
+			"/bin/sh", "-c", "sleep 1")
+		res := c.RunDockerCmd(t, "ps")
 		assert.Assert(t, strings.Contains(res.Stdout(), "8081->80/tcp"), res.Stdout())
 	})
 
 	t.Run("compose run orphan", func(t *testing.T) {
 		// Use different compose files to get an orphan container
-		c.RunDockerComposeCmd("-f", "./fixtures/run-test/orphan.yaml", "run", "simple")
-		res := c.RunDockerComposeCmd("-f", "./fixtures/run-test/compose.yaml", "run", "back", "echo", "Hello")
+		c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/orphan.yaml", "run", "simple")
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/compose.yaml", "run", "back", "echo", "Hello")
 		assert.Assert(t, strings.Contains(res.Combined(), "orphan"))
 
-		cmd := c.NewDockerCmd("compose", "-f", "./fixtures/run-test/compose.yaml", "run", "back", "echo", "Hello")
+		cmd := c.NewDockerComposeCmd(t, "-f", "./fixtures/run-test/compose.yaml", "run", "back", "echo", "Hello")
 		res = icmd.RunCmd(cmd, func(cmd *icmd.Cmd) {
 			cmd.Env = append(cmd.Env, "COMPOSE_IGNORE_ORPHANS=True")
 		})
@@ -112,9 +116,23 @@ func TestLocalComposeRun(t *testing.T) {
 	})
 
 	t.Run("down", func(t *testing.T) {
-		c.RunDockerComposeCmd("-f", "./fixtures/run-test/compose.yaml", "down")
-		c.RunDockerComposeCmd("-f", "./fixtures/run-test/orphan.yaml", "down")
-		res := c.RunDockerCmd("ps", "--all")
+		cmd := c.NewDockerComposeCmd(t, "-f", "./fixtures/run-test/compose.yaml", "down")
+		icmd.RunCmd(cmd, func(c *icmd.Cmd) {
+			c.Env = append(c.Env, "COMPOSE_REMOVE_ORPHANS=True")
+		})
+		res := c.RunDockerCmd(t, "ps", "--all")
 		assert.Assert(t, !strings.Contains(res.Stdout(), "run-test"), res.Stdout())
 	})
+
+	t.Run("run starts only container and dependencies", func(t *testing.T) {
+		// ensure that even if another service is up run does not start it: https://github.com/docker/compose/issues/9459
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/deps.yaml", "up", "service_b")
+		res.Assert(t, icmd.Success)
+
+		res = c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/deps.yaml", "run", "service_a")
+		assert.Assert(t, strings.Contains(res.Combined(), "shared_dep"), res.Combined())
+		assert.Assert(t, !strings.Contains(res.Combined(), "service_b"), res.Combined())
+
+		c.RunDockerComposeCmd(t, "-f", "./fixtures/run-test/deps.yaml", "down", "--remove-orphans")
+	})
 }

pkg/e2e/compose_test.go

@@ -18,7 +18,6 @@ package e2e
 
 import (
 	"fmt"
-	"io/ioutil"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -31,31 +30,30 @@ import (
 	"gotest.tools/v3/icmd"
 )
 
-var binDir string
-
 func TestLocalComposeUp(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	// this test shares a fixture with TestCompatibility and can't run at the same time
+	c := NewCLI(t)
 
 	const projectName = "compose-e2e-demo"
 
 	t.Run("up", func(t *testing.T) {
-		c.RunDockerComposeCmd("-f", "./fixtures/sentences/compose.yaml", "--project-name", projectName, "up", "-d")
+		c.RunDockerComposeCmd(t, "-f", "./fixtures/sentences/compose.yaml", "--project-name", projectName, "up", "-d")
 	})
 
 	t.Run("check accessing running app", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-p", projectName, "ps")
+		res := c.RunDockerComposeCmd(t, "-p", projectName, "ps")
 		res.Assert(t, icmd.Expected{Out: `web`})
 
 		endpoint := "http://localhost:90"
 		output := HTTPGetWithRetry(t, endpoint+"/words/noun", http.StatusOK, 2*time.Second, 20*time.Second)
 		assert.Assert(t, strings.Contains(output, `"word":`))
 
-		res = c.RunDockerCmd("network", "ls")
+		res = c.RunDockerCmd(t, "network", "ls")
 		res.Assert(t, icmd.Expected{Out: projectName + "_default"})
 	})
 
 	t.Run("top", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-p", projectName, "top")
+		res := c.RunDockerComposeCmd(t, "-p", projectName, "top")
 		output := res.Stdout()
 		head := []string{"UID", "PID", "PPID", "C", "STIME", "TTY", "TIME", "CMD"}
 		for _, h := range head {
@@ -66,7 +64,7 @@ func TestLocalComposeUp(t *testing.T) {
 	})
 
 	t.Run("check compose labels", func(t *testing.T) {
-		res := c.RunDockerCmd("inspect", projectName+"-web-1")
+		res := c.RunDockerCmd(t, "inspect", projectName+"-web-1")
 		res.Assert(t, icmd.Expected{Out: `"com.docker.compose.container-number": "1"`})
 		res.Assert(t, icmd.Expected{Out: `"com.docker.compose.project": "compose-e2e-demo"`})
 		res.Assert(t, icmd.Expected{Out: `"com.docker.compose.oneoff": "False",`})
@@ -76,55 +74,55 @@ func TestLocalComposeUp(t *testing.T) {
 		res.Assert(t, icmd.Expected{Out: `"com.docker.compose.service": "web"`})
 		res.Assert(t, icmd.Expected{Out: `"com.docker.compose.version":`})
 
-		res = c.RunDockerCmd("network", "inspect", projectName+"_default")
+		res = c.RunDockerCmd(t, "network", "inspect", projectName+"_default")
 		res.Assert(t, icmd.Expected{Out: `"com.docker.compose.network": "default"`})
 		res.Assert(t, icmd.Expected{Out: `"com.docker.compose.project": `})
 		res.Assert(t, icmd.Expected{Out: `"com.docker.compose.version": `})
 	})
 
 	t.Run("check user labels", func(t *testing.T) {
-		res := c.RunDockerCmd("inspect", projectName+"-web-1")
+		res := c.RunDockerCmd(t, "inspect", projectName+"-web-1")
 		res.Assert(t, icmd.Expected{Out: `"my-label": "test"`})
 
 	})
 
 	t.Run("check healthcheck output", func(t *testing.T) {
-		c.WaitForCmdResult(c.NewDockerCmd("compose", "-p", projectName, "ps", "--format", "json"),
+		c.WaitForCmdResult(t, c.NewDockerComposeCmd(t, "-p", projectName, "ps", "--format", "json"),
 			StdoutContains(`"Name":"compose-e2e-demo-web-1","Command":"/dispatcher","Project":"compose-e2e-demo","Service":"web","State":"running","Health":"healthy"`),
 			5*time.Second, 1*time.Second)
 
-		res := c.RunDockerComposeCmd("-p", projectName, "ps")
+		res := c.RunDockerComposeCmd(t, "-p", projectName, "ps")
 		res.Assert(t, icmd.Expected{Out: `NAME                       COMMAND                  SERVICE             STATUS              PORTS`})
-		res.Assert(t, icmd.Expected{Out: `compose-e2e-demo-web-1     "/dispatcher"            web                 running (healthy)   0.0.0.0:90->80/tcp, :::90->80/tcp`})
+		res.Assert(t, icmd.Expected{Out: `compose-e2e-demo-web-1     "/dispatcher"            web                 running (healthy)   0.0.0.0:90->80/tcp`})
 		res.Assert(t, icmd.Expected{Out: `compose-e2e-demo-db-1      "docker-entrypoint.s…"   db                  running             5432/tcp`})
 	})
 
 	t.Run("images", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-p", projectName, "images")
+		res := c.RunDockerComposeCmd(t, "-p", projectName, "images")
 		res.Assert(t, icmd.Expected{Out: `compose-e2e-demo-db-1      gtardif/sentences-db    latest`})
 		res.Assert(t, icmd.Expected{Out: `compose-e2e-demo-web-1     gtardif/sentences-web   latest`})
 		res.Assert(t, icmd.Expected{Out: `compose-e2e-demo-words-1   gtardif/sentences-api   latest`})
 	})
 
 	t.Run("down", func(t *testing.T) {
-		_ = c.RunDockerComposeCmd("--project-name", projectName, "down")
+		_ = c.RunDockerComposeCmd(t, "--project-name", projectName, "down")
 	})
 
 	t.Run("check containers after down", func(t *testing.T) {
-		res := c.RunDockerCmd("ps", "--all")
+		res := c.RunDockerCmd(t, "ps", "--all")
 		assert.Assert(t, !strings.Contains(res.Combined(), projectName), res.Combined())
 	})
 
 	t.Run("check networks after down", func(t *testing.T) {
-		res := c.RunDockerCmd("network", "ls")
+		res := c.RunDockerCmd(t, "network", "ls")
 		assert.Assert(t, !strings.Contains(res.Combined(), projectName), res.Combined())
 	})
 }
 
 func TestComposePull(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
-	res := c.RunDockerOrExitError("compose", "--project-directory", "fixtures/simple-composefile", "pull")
+	res := c.RunDockerComposeCmd(t, "--project-directory", "fixtures/simple-composefile", "pull")
 	output := res.Combined()
 
 	assert.Assert(t, strings.Contains(output, "simple Pulled"))
@@ -132,97 +130,108 @@ func TestComposePull(t *testing.T) {
 }
 
 func TestDownComposefileInParentFolder(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
-	tmpFolder, err := ioutil.TempDir("fixtures/simple-composefile", "test-tmp")
+	tmpFolder, err := os.MkdirTemp("fixtures/simple-composefile", "test-tmp")
 	assert.NilError(t, err)
-	defer os.Remove(tmpFolder) // nolint: errcheck
+	defer os.Remove(tmpFolder) //nolint: errcheck
 	projectName := filepath.Base(tmpFolder)
 
-	res := c.RunDockerComposeCmd("--project-directory", tmpFolder, "up", "-d")
+	res := c.RunDockerComposeCmd(t, "--project-directory", tmpFolder, "up", "-d")
 	res.Assert(t, icmd.Expected{Err: "Started", ExitCode: 0})
 
-	res = c.RunDockerComposeCmd("-p", projectName, "down")
+	res = c.RunDockerComposeCmd(t, "-p", projectName, "down")
 	res.Assert(t, icmd.Expected{Err: "Removed", ExitCode: 0})
 }
 
 func TestAttachRestart(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
-	cmd := c.NewDockerCmd("compose", "--ansi=never", "--project-directory", "./fixtures/attach-restart", "up")
+	cmd := c.NewDockerComposeCmd(t, "--ansi=never", "--project-directory", "./fixtures/attach-restart", "up")
 	res := icmd.StartCmd(cmd)
-	defer c.RunDockerOrExitError("compose", "-p", "attach-restart", "down")
+	defer c.RunDockerComposeCmd(t, "-p", "attach-restart", "down")
 
-	c.WaitForCondition(func() (bool, string) {
+	c.WaitForCondition(t, func() (bool, string) {
 		debug := res.Combined()
-		return strings.Count(res.Stdout(), "failing-1 exited with code 1") == 3, fmt.Sprintf("'failing-1 exited with code 1' not found 3 times in : \n%s\n", debug)
+		return strings.Count(res.Stdout(),
+				"failing-1 exited with code 1") == 3, fmt.Sprintf("'failing-1 exited with code 1' not found 3 times in : \n%s\n",
+				debug)
 	}, 2*time.Minute, 2*time.Second)
 
 	assert.Equal(t, strings.Count(res.Stdout(), "failing-1  | world"), 3, res.Combined())
 }
 
 func TestInitContainer(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
-	res := c.RunDockerOrExitError("compose", "--ansi=never", "--project-directory", "./fixtures/init-container", "up")
-	defer c.RunDockerOrExitError("compose", "-p", "init-container", "down")
+	res := c.RunDockerComposeCmd(t, "--ansi=never", "--project-directory", "./fixtures/init-container", "up")
+	defer c.RunDockerComposeCmd(t, "-p", "init-container", "down")
 	testify.Regexp(t, "foo-1  | hello(?m:.*)bar-1  | world", res.Stdout())
 }
 
 func TestRm(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
 	const projectName = "compose-e2e-rm"
 
 	t.Run("up", func(t *testing.T) {
-		c.RunDockerComposeCmd("-f", "./fixtures/simple-composefile/compose.yaml", "-p", projectName, "up", "-d")
+		c.RunDockerComposeCmd(t, "-f", "./fixtures/simple-composefile/compose.yaml", "-p", projectName, "up", "-d")
 	})
 
 	t.Run("rm -sf", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-f", "./fixtures/simple-composefile/compose.yaml", "-p", projectName, "rm", "-sf", "simple")
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/simple-composefile/compose.yaml", "-p", projectName, "rm",
+			"-sf", "simple")
 		res.Assert(t, icmd.Expected{Err: "Removed", ExitCode: 0})
 	})
 
 	t.Run("check containers after rm -sf", func(t *testing.T) {
-		res := c.RunDockerCmd("ps", "--all")
+		res := c.RunDockerCmd(t, "ps", "--all")
 		assert.Assert(t, !strings.Contains(res.Combined(), projectName+"_simple"), res.Combined())
 	})
 
+	t.Run("rm -sf <none>", func(t *testing.T) {
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/simple-composefile/compose.yaml", "-p", projectName, "rm",
+			"-sf", "simple")
+		res.Assert(t, icmd.Expected{ExitCode: 0})
+	})
+
 	t.Run("down", func(t *testing.T) {
-		c.RunDockerComposeCmd("-p", projectName, "down")
+		c.RunDockerComposeCmd(t, "-p", projectName, "down")
 	})
 }
 
 func TestCompatibility(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	// this test shares a fixture with TestLocalComposeUp and can't run at the same time
+	c := NewCLI(t)
 
 	const projectName = "compose-e2e-compatibility"
 
 	t.Run("up", func(t *testing.T) {
-		c.RunDockerComposeCmd("--compatibility", "-f", "./fixtures/sentences/compose.yaml", "--project-name", projectName, "up", "-d")
+		c.RunDockerComposeCmd(t, "--compatibility", "-f", "./fixtures/sentences/compose.yaml", "--project-name",
+			projectName, "up", "-d")
 	})
 
 	t.Run("check container names", func(t *testing.T) {
-		res := c.RunDockerCmd("ps", "--format", "{{.Names}}")
+		res := c.RunDockerCmd(t, "ps", "--format", "{{.Names}}")
 		res.Assert(t, icmd.Expected{Out: "compose-e2e-compatibility_web_1"})
 		res.Assert(t, icmd.Expected{Out: "compose-e2e-compatibility_words_1"})
 		res.Assert(t, icmd.Expected{Out: "compose-e2e-compatibility_db_1"})
 	})
 
 	t.Run("down", func(t *testing.T) {
-		c.RunDockerComposeCmd("-p", projectName, "down")
+		c.RunDockerComposeCmd(t, "-p", projectName, "down")
 	})
 }
 
 func TestConvert(t *testing.T) {
 	const projectName = "compose-e2e-convert"
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
 	wd, err := os.Getwd()
 	assert.NilError(t, err)
 
 	t.Run("up", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-f", "./fixtures/simple-build-test/compose.yaml", "-p", projectName, "convert")
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/simple-build-test/compose.yaml", "-p", projectName, "convert")
 		res.Assert(t, icmd.Expected{Out: fmt.Sprintf(`services:
   nginx:
     build:

pkg/e2e/compose_up_test.go

@@ -0,0 +1,47 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package e2e
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestUpWait(t *testing.T) {
+	c := NewParallelCLI(t)
+	const projectName = "e2e-deps-wait"
+
+	timeout := time.After(30 * time.Second)
+	done := make(chan bool)
+	go func() {
+		res := c.RunDockerComposeCmd(t, "-f", "fixtures/dependencies/deps-completed-successfully.yaml", "--project-name", projectName, "up", "--wait", "-d")
+		assert.Assert(t, strings.Contains(res.Combined(), "e2e-deps-wait-oneshot-1"), res.Combined())
+		done <- true
+	}()
+
+	select {
+	case <-timeout:
+		t.Fatal("test did not finish in time")
+	case <-done:
+		break
+	}
+
+	c.RunDockerComposeCmd(t, "--project-name", projectName, "down")
+}

pkg/e2e/cp_test.go

@@ -26,12 +26,12 @@ import (
 )
 
 func TestCopy(t *testing.T) {
-	c := NewParallelE2eCLI(t, binDir)
+	c := NewParallelCLI(t)
 
 	const projectName = "copy_e2e"
 
 	t.Cleanup(func() {
-		c.RunDockerComposeCmd("-f", "./fixtures/cp-test/compose.yaml", "--project-name", projectName, "down")
+		c.RunDockerComposeCmd(t, "-f", "./fixtures/cp-test/compose.yaml", "--project-name", projectName, "down")
 
 		os.Remove("./fixtures/cp-test/from-default.txt") //nolint:errcheck
 		os.Remove("./fixtures/cp-test/from-indexed.txt") //nolint:errcheck
@@ -39,52 +39,45 @@ func TestCopy(t *testing.T) {
 	})
 
 	t.Run("start service", func(t *testing.T) {
-		c.RunDockerComposeCmd("-f", "./fixtures/cp-test/compose.yaml", "--project-name", projectName, "up", "--scale", "nginx=5", "-d")
+		c.RunDockerComposeCmd(t, "-f", "./fixtures/cp-test/compose.yaml", "--project-name", projectName, "up",
+			"--scale", "nginx=5", "-d")
 	})
 
 	t.Run("make sure service is running", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-p", projectName, "ps")
+		res := c.RunDockerComposeCmd(t, "-p", projectName, "ps")
 		res.Assert(t, icmd.Expected{Out: `nginx               running`})
 	})
 
-	t.Run("copy to container copies the file to the first container by default", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp", "./fixtures/cp-test/cp-me.txt", "nginx:/tmp/default.txt")
+	t.Run("copy to container copies the file to the all containers by default", func(t *testing.T) {
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp",
+			"./fixtures/cp-test/cp-me.txt", "nginx:/tmp/default.txt")
 		res.Assert(t, icmd.Expected{ExitCode: 0})
 
-		output := c.RunDockerCmd("exec", projectName+"-nginx-1", "cat", "/tmp/default.txt").Stdout()
+		output := c.RunDockerCmd(t, "exec", projectName+"-nginx-1", "cat", "/tmp/default.txt").Stdout()
 		assert.Assert(t, strings.Contains(output, `hello world`), output)
 
-		res = c.RunDockerOrExitError("exec", projectName+"_nginx_2", "cat", "/tmp/default.txt")
-		res.Assert(t, icmd.Expected{ExitCode: 1})
+		output = c.RunDockerCmd(t, "exec", projectName+"-nginx-2", "cat", "/tmp/default.txt").Stdout()
+		assert.Assert(t, strings.Contains(output, `hello world`), output)
+
+		output = c.RunDockerCmd(t, "exec", projectName+"-nginx-3", "cat", "/tmp/default.txt").Stdout()
+		assert.Assert(t, strings.Contains(output, `hello world`), output)
 	})
 
 	t.Run("copy to container with a given index copies the file to the given container", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp", "--index=3", "./fixtures/cp-test/cp-me.txt", "nginx:/tmp/indexed.txt")
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp", "--index=3",
+			"./fixtures/cp-test/cp-me.txt", "nginx:/tmp/indexed.txt")
 		res.Assert(t, icmd.Expected{ExitCode: 0})
 
-		output := c.RunDockerCmd("exec", projectName+"-nginx-3", "cat", "/tmp/indexed.txt").Stdout()
+		output := c.RunDockerCmd(t, "exec", projectName+"-nginx-3", "cat", "/tmp/indexed.txt").Stdout()
 		assert.Assert(t, strings.Contains(output, `hello world`), output)
 
-		res = c.RunDockerOrExitError("exec", projectName+"-nginx-2", "cat", "/tmp/indexed.txt")
+		res = c.RunDockerOrExitError(t, "exec", projectName+"-nginx-2", "cat", "/tmp/indexed.txt")
 		res.Assert(t, icmd.Expected{ExitCode: 1})
 	})
 
-	t.Run("copy to container with the all flag copies the file to all containers", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp", "--all", "./fixtures/cp-test/cp-me.txt", "nginx:/tmp/all.txt")
-		res.Assert(t, icmd.Expected{ExitCode: 0})
-
-		output := c.RunDockerCmd("exec", projectName+"-nginx-1", "cat", "/tmp/all.txt").Stdout()
-		assert.Assert(t, strings.Contains(output, `hello world`), output)
-
-		output = c.RunDockerCmd("exec", projectName+"-nginx-2", "cat", "/tmp/all.txt").Stdout()
-		assert.Assert(t, strings.Contains(output, `hello world`), output)
-
-		output = c.RunDockerCmd("exec", projectName+"-nginx-3", "cat", "/tmp/all.txt").Stdout()
-		assert.Assert(t, strings.Contains(output, `hello world`), output)
-	})
-
 	t.Run("copy from a container copies the file to the host from the first container by default", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp", "nginx:/tmp/default.txt", "./fixtures/cp-test/from-default.txt")
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp",
+			"nginx:/tmp/default.txt", "./fixtures/cp-test/from-default.txt")
 		res.Assert(t, icmd.Expected{ExitCode: 0})
 
 		data, err := os.ReadFile("./fixtures/cp-test/from-default.txt")
@@ -93,7 +86,8 @@ func TestCopy(t *testing.T) {
 	})
 
 	t.Run("copy from a container with a given index copies the file to host", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp", "--index=3", "nginx:/tmp/indexed.txt", "./fixtures/cp-test/from-indexed.txt")
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp", "--index=3",
+			"nginx:/tmp/indexed.txt", "./fixtures/cp-test/from-indexed.txt")
 		res.Assert(t, icmd.Expected{ExitCode: 0})
 
 		data, err := os.ReadFile("./fixtures/cp-test/from-indexed.txt")
@@ -102,13 +96,15 @@ func TestCopy(t *testing.T) {
 	})
 
 	t.Run("copy to and from a container also work with folder", func(t *testing.T) {
-		res := c.RunDockerComposeCmd("-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp", "./fixtures/cp-test/cp-folder", "nginx:/tmp")
+		res := c.RunDockerComposeCmd(t, "-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp",
+			"./fixtures/cp-test/cp-folder", "nginx:/tmp")
 		res.Assert(t, icmd.Expected{ExitCode: 0})
 
-		output := c.RunDockerCmd("exec", projectName+"-nginx-1", "cat", "/tmp/cp-folder/cp-me.txt").Stdout()
+		output := c.RunDockerCmd(t, "exec", projectName+"-nginx-1", "cat", "/tmp/cp-folder/cp-me.txt").Stdout()
 		assert.Assert(t, strings.Contains(output, `hello world from folder`), output)
 
-		res = c.RunDockerComposeCmd("-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp", "nginx:/tmp/cp-folder", "./fixtures/cp-test/cp-folder2")
+		res = c.RunDockerComposeCmd(t, "-f", "./fixtures/cp-test/compose.yaml", "-p", projectName, "cp",
+			"nginx:/tmp/cp-folder", "./fixtures/cp-test/cp-folder2")
 		res.Assert(t, icmd.Expected{ExitCode: 0})
 
 		data, err := os.ReadFile("./fixtures/cp-test/cp-folder2/cp-me.txt")

pkg/e2e/ddev_test.go

@@ -0,0 +1,106 @@
+/*
+   Copyright 2020 Docker Compose CLI authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package e2e
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"gotest.tools/v3/assert"
+)
+
+const ddevVersion = "v1.19.1"
+
+func TestComposeRunDdev(t *testing.T) {
+	if !composeStandaloneMode {
+		t.Skip("Not running in plugin mode - ddev only supports invoking standalone `docker-compose`")
+	}
+	if runtime.GOOS == "windows" {
+		t.Skip("Running on Windows. Skipping...")
+	}
+
+	// ddev shells out to `docker` and `docker-compose` (standalone), so a
+	// temporary directory is created with symlinks to system Docker and the
+	// locally-built standalone Compose binary to use as PATH
+	requiredTools := []string{
+		findToolInPath(t, DockerExecutableName),
+		ComposeStandalonePath(t),
+		findToolInPath(t, "tar"),
+		findToolInPath(t, "gzip"),
+	}
+	pathDir := t.TempDir()
+	for _, tool := range requiredTools {
+		require.NoError(t, os.Symlink(tool, filepath.Join(pathDir, filepath.Base(tool))),
+			"Could not create symlink for %q", tool)
+	}
+
+	c := NewCLI(t, WithEnv(
+		"DDEV_DEBUG=true",
+		fmt.Sprintf("PATH=%s", pathDir),
+	))
+
+	ddevDir := t.TempDir()
+	siteName := filepath.Base(ddevDir)
+
+	t.Cleanup(func() {
+		_ = c.RunCmdInDir(t, ddevDir, "./ddev", "delete", "-Oy")
+		_ = c.RunCmdInDir(t, ddevDir, "./ddev", "poweroff")
+	})
+
+	osName := "linux"
+	if runtime.GOOS == "darwin" {
+		osName = "macos"
+	}
+
+	compressedFilename := fmt.Sprintf("ddev_%s-%s.%s.tar.gz", osName, runtime.GOARCH, ddevVersion)
+	c.RunCmdInDir(t, ddevDir, "curl", "-LO", fmt.Sprintf("https://github.com/drud/ddev/releases/download/%s/%s",
+		ddevVersion,
+		compressedFilename))
+
+	c.RunCmdInDir(t, ddevDir, "tar", "-xzf", compressedFilename)
+
+	// Create a simple index.php we can test against.
+	c.RunCmdInDir(t, ddevDir, "sh", "-c", "echo '<?php\nprint \"ddev is working\";' >index.php")
+
+	c.RunCmdInDir(t, ddevDir, "./ddev", "config", "--auto")
+	c.RunCmdInDir(t, ddevDir, "./ddev", "config", "global", "--use-docker-compose-from-path")
+	vRes := c.RunCmdInDir(t, ddevDir, "./ddev", "version")
+	out := vRes.Stdout()
+	fmt.Printf("ddev version: %s\n", out)
+
+	c.RunCmdInDir(t, ddevDir, "./ddev", "poweroff")
+
+	c.RunCmdInDir(t, ddevDir, "./ddev", "start", "-y")
+
+	curlRes := c.RunCmdInDir(t, ddevDir, "curl", "-sSL", fmt.Sprintf("http://%s.ddev.site", siteName))
+	out = curlRes.Stdout()
+	fmt.Println(out)
+	assert.Assert(t, strings.Contains(out, "ddev is working"), "Could not start project")
+}
+
+func findToolInPath(t testing.TB, name string) string {
+	t.Helper()
+	binPath, err := exec.LookPath(name)
+	require.NoError(t, err, "Could not find %q in path", name)
+	return binPath
+}

pkg/e2e/fixtures/build-dependencies/base.dockerfile

@@ -0,0 +1,19 @@
+#   Copyright 2020 Docker Compose CLI authors
+
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+
+#       http://www.apache.org/licenses/LICENSE-2.0
+
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+FROM alpine
+
+COPY hello.txt /hello.txt
+
+CMD [ "/bin/true" ]

pkg/e2e/fixtures/build-dependencies/compose.yaml

@@ -0,0 +1,12 @@
+services:
+  base:
+    image: base
+    build:
+      context: .
+      dockerfile: base.dockerfile
+  service:
+    depends_on:
+      - base
+    build:
+      context: .
+      dockerfile: service.dockerfile

pkg/e2e/fixtures/build-dependencies/hello.txt

@@ -0,0 +1 @@
+this file was copied from base -> service

pkg/e2e/fixtures/build-dependencies/service.dockerfile

@@ -0,0 +1,19 @@
+#   Copyright 2020 Docker Compose CLI authors
+
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+
+#       http://www.apache.org/licenses/LICENSE-2.0
+
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+FROM alpine
+
+COPY --from=base /hello.txt /hello.txt
+
+CMD [ "cat", "/hello.txt" ]

pkg/e2e/fixtures/build-test/secrets/Dockerfile

@@ -0,0 +1,26 @@
+# syntax=docker/dockerfile:1.2
+
+
+#   Copyright 2020 Docker Compose CLI authors
+
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+
+#       http://www.apache.org/licenses/LICENSE-2.0
+
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+FROM alpine
+
+RUN echo "foo" > /tmp/expected
+RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret > /tmp/actual
+RUN diff /tmp/expected /tmp/actual
+
+RUN echo "bar" > /tmp/expected
+RUN --mount=type=secret,id=envsecret cat /run/secrets/envsecret > tmp/actual
+RUN diff --ignore-all-space /tmp/expected /tmp/actual

pkg/e2e/fixtures/build-test/secrets/compose.yml

@@ -0,0 +1,14 @@
+services:
+  ssh:
+    image: build-test-secret
+    build:
+      context: .
+      secrets:
+        - mysecret
+        - envsecret
+
+secrets:
+  mysecret:
+    file: ./secret.txt
+  envsecret:
+    environment: SOME_SECRET

pkg/e2e/fixtures/build-test/secrets/secret.txt

@@ -0,0 +1 @@
+foo

pkg/e2e/fixtures/build-test/ssh/Dockerfile

@@ -0,0 +1,24 @@
+# syntax=docker/dockerfile:1.2
+
+
+#   Copyright 2020 Docker Compose CLI authors
+
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+
+#       http://www.apache.org/licenses/LICENSE-2.0
+
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+FROM alpine
+RUN apk add --no-cache openssh-client
+
+WORKDIR /compose
+COPY fake_rsa.pub /compose/
+
+RUN --mount=type=ssh,id=fake-ssh,required=true diff <(ssh-add -L) <(cat /compose/fake_rsa.pub)