Setup Compose service using functional parameters

cmd/compose/alpha.go

@@ -1,5 +1,4 @@
 /*
-
    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.
@@ -16,12 +15,11 @@ package compose
 
 import (
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/compose/v2/pkg/api"
 	"github.com/spf13/cobra"
 )
 
 // alphaCommand groups all experimental subcommands
-func alphaCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func alphaCommand(p *ProjectOptions, dockerCli command.Cli, backendOptions *BackendOptions) *cobra.Command {
 	cmd := &cobra.Command{
 		Short:  "Experimental commands",
 		Use:    "alpha [COMMAND]",
@@ -31,9 +29,9 @@ func alphaCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 		},
 	}
 	cmd.AddCommand(
-		vizCommand(p, dockerCli, backend),
-		publishCommand(p, dockerCli, backend),
-		generateCommand(p, backend),
+		vizCommand(p, dockerCli, backendOptions),
+		publishCommand(p, dockerCli, backendOptions),
+		generateCommand(p, dockerCli, backendOptions),
 	)
 	return cmd
 }

cmd/compose/attach.go

@@ -21,6 +21,7 @@ import (
 
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/compose"
 	"github.com/spf13/cobra"
 )
 
@@ -35,7 +36,7 @@ type attachOpts struct {
 	proxy      bool
 }
 
-func attachCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func attachCommand(p *ProjectOptions, dockerCli command.Cli, backendOptions *BackendOptions) *cobra.Command {
 	opts := attachOpts{
 		composeOptions: &composeOptions{
 			ProjectOptions: p,
@@ -50,7 +51,7 @@ func attachCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runAttach(ctx, dockerCli, backend, opts)
+			return runAttach(ctx, dockerCli, backendOptions, opts)
 		}),
 		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
@@ -63,7 +64,7 @@ func attachCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose
 	return runCmd
 }
 
-func runAttach(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts attachOpts) error {
+func runAttach(ctx context.Context, dockerCli command.Cli, backendOptions *BackendOptions, opts attachOpts) error {
 	projectName, err := opts.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
@@ -76,5 +77,9 @@ func runAttach(ctx context.Context, dockerCli command.Cli, backend api.Compose,
 		NoStdin:    opts.noStdin,
 		Proxy:      opts.proxy,
 	}
+	backend, err := compose.NewComposeService(dockerCli, backendOptions.Options...)
+	if err != nil {
+		return err
+	}
 	return backend.Attach(ctx, projectName, attachOpts)
 }

cmd/compose/build.go

@@ -26,6 +26,7 @@ import (
 	"github.com/compose-spec/compose-go/v2/types"
 	"github.com/docker/cli/cli/command"
 	cliopts "github.com/docker/cli/opts"
+	"github.com/docker/compose/v2/pkg/compose"
 	ui "github.com/docker/compose/v2/pkg/progress"
 	"github.com/spf13/cobra"
 
@@ -90,7 +91,7 @@ func (opts buildOptions) toAPIBuildOptions(services []string) (api.BuildOptions,
 	}, nil
 }
 
-func buildCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func buildCommand(p *ProjectOptions, dockerCli command.Cli, backendOptions *BackendOptions) *cobra.Command {
 	opts := buildOptions{
 		ProjectOptions: p,
 	}
@@ -115,7 +116,7 @@ func buildCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 			if cmd.Flags().Changed("progress") && opts.ssh == "" {
 				fmt.Fprint(os.Stderr, "--progress is a global compose flag, better use `docker compose --progress xx build ...\n")
 			}
-			return runBuild(ctx, dockerCli, backend, opts, args)
+			return runBuild(ctx, dockerCli, backendOptions, opts, args)
 		}),
 		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
@@ -148,7 +149,7 @@ func buildCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return cmd
 }
 
-func runBuild(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts buildOptions, services []string) error {
+func runBuild(ctx context.Context, dockerCli command.Cli, backendOptions *BackendOptions, opts buildOptions, services []string) error {
 	opts.All = true // do not drop resources as build may involve some dependencies by additional_contexts
 	project, _, err := opts.ToProject(ctx, dockerCli, nil, cli.WithResolvedPaths(true), cli.WithoutEnvironmentResolution)
 	if err != nil {
@@ -165,5 +166,9 @@ func runBuild(ctx context.Context, dockerCli command.Cli, backend api.Compose, o
 	}
 	apiBuildOptions.Attestations = true
 
+	backend, err := compose.NewComposeService(dockerCli, backendOptions.Options...)
+	if err != nil {
+		return err
+	}
 	return backend.Build(ctx, project, apiBuildOptions)
 }

cmd/compose/commit.go

@@ -22,6 +22,7 @@ import (
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/opts"
 	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/compose"
 	"github.com/spf13/cobra"
 )
 
@@ -39,7 +40,7 @@ type commitOptions struct {
 	index int
 }
 
-func commitCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func commitCommand(p *ProjectOptions, dockerCli command.Cli, backendOptions *BackendOptions) *cobra.Command {
 	options := commitOptions{
 		ProjectOptions: p,
 	}
@@ -56,7 +57,7 @@ func commitCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runCommit(ctx, dockerCli, backend, options)
+			return runCommit(ctx, dockerCli, backendOptions, options)
 		}),
 		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
@@ -73,12 +74,16 @@ func commitCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose
 	return cmd
 }
 
-func runCommit(ctx context.Context, dockerCli command.Cli, backend api.Compose, options commitOptions) error {
+func runCommit(ctx context.Context, dockerCli command.Cli, backendOptions *BackendOptions, options commitOptions) error {
 	projectName, err := options.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
 	}
 
+	backend, err := compose.NewComposeService(dockerCli, backendOptions.Options...)
+	if err != nil {
+		return err
+	}
 	return backend.Commit(ctx, projectName, api.CommitOptions{
 		Service:   options.service,
 		Reference: options.reference,

cmd/compose/completion.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/compose"
 	"github.com/spf13/cobra"
 )
 
@@ -52,8 +53,13 @@ func completeServiceNames(dockerCli command.Cli, p *ProjectOptions) validArgsFn
 	}
 }
 
-func completeProjectNames(backend api.Compose) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+func completeProjectNames(dockerCli command.Cli, backendOptions *BackendOptions) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		backend, err := compose.NewComposeService(dockerCli, backendOptions.Options...)
+		if err != nil {
+			return nil, cobra.ShellCompDirectiveError
+		}
+
 		list, err := backend.List(cmd.Context(), api.ListOptions{
 			All: true,
 		})

cmd/compose/compose.go

@@ -42,6 +42,7 @@ import (
 	"github.com/docker/compose/v2/cmd/formatter"
 	"github.com/docker/compose/v2/internal/tracing"
 	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/compose"
 	ui "github.com/docker/compose/v2/pkg/progress"
 	"github.com/docker/compose/v2/pkg/remote"
 	"github.com/docker/compose/v2/pkg/utils"
@@ -415,8 +416,16 @@ func RunningAsStandalone() bool {
 	return len(os.Args) < 2 || os.Args[1] != metadata.MetadataSubcommandName && os.Args[1] != PluginName
 }
 
+type BackendOptions struct {
+	Options []compose.Option
+}
+
+func (o *BackendOptions) Add(option compose.Option) {
+	o.Options = append(o.Options, option)
+}
+
 // RootCommand returns the compose command with its child commands
-func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //nolint:gocyclo
+func RootCommand(dockerCli command.Cli, backendOptions *BackendOptions) *cobra.Command { //nolint:gocyclo
 	// filter out useless commandConn.CloseWrite warning message that can occur
 	// when using a remote context that is unreachable: "commandConn.CloseWrite: commandconn: failed to wait: signal: killed"
 	// https://github.com/docker/cli/blob/e1f24d3c93df6752d3c27c8d61d18260f141310c/cli/connhelper/commandconn/commandconn.go#L203-L215
@@ -456,9 +465,7 @@ func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //
 			}
 		},
 		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
 			parent := cmd.Root()
-
 			if parent != nil {
 				parentPrerun := parent.PersistentPreRunE
 				if parentPrerun != nil {
@@ -560,64 +567,61 @@ func RootCommand(dockerCli command.Cli, backend api.Compose) *cobra.Command { //
 			}
 			if parallel > 0 {
 				logrus.Debugf("Limiting max concurrency to %d jobs", parallel)
-				backend.MaxConcurrency(parallel)
+				backendOptions.Add(compose.WithMaxConcurrency(parallel))
 			}
 
 			// dry run detection
-			ctx, err = backend.DryRunMode(ctx, dryRun)
-			if err != nil {
-				return err
+			if dryRun {
+				backendOptions.Add(compose.WithDryRun)
 			}
-			cmd.SetContext(ctx)
-
 			return nil
 		},
 	}
 
 	c.AddCommand(
-		upCommand(&opts, dockerCli, backend),
-		downCommand(&opts, dockerCli, backend),
-		startCommand(&opts, dockerCli, backend),
-		restartCommand(&opts, dockerCli, backend),
-		stopCommand(&opts, dockerCli, backend),
-		psCommand(&opts, dockerCli, backend),
-		listCommand(dockerCli, backend),
-		logsCommand(&opts, dockerCli, backend),
+		upCommand(&opts, dockerCli, backendOptions),
+		downCommand(&opts, dockerCli, backendOptions),
+		startCommand(&opts, dockerCli, backendOptions),
+		restartCommand(&opts, dockerCli, backendOptions),
+		stopCommand(&opts, dockerCli, backendOptions),
+		psCommand(&opts, dockerCli, backendOptions),
+		listCommand(dockerCli, backendOptions),
+		logsCommand(&opts, dockerCli, backendOptions),
 		configCommand(&opts, dockerCli),
-		killCommand(&opts, dockerCli, backend),
-		runCommand(&opts, dockerCli, backend),
-		removeCommand(&opts, dockerCli, backend),
-		execCommand(&opts, dockerCli, backend),
-		attachCommand(&opts, dockerCli, backend),
-		exportCommand(&opts, dockerCli, backend),
-		commitCommand(&opts, dockerCli, backend),
-		pauseCommand(&opts, dockerCli, backend),
-		unpauseCommand(&opts, dockerCli, backend),
-		topCommand(&opts, dockerCli, backend),
-		eventsCommand(&opts, dockerCli, backend),
-		portCommand(&opts, dockerCli, backend),
-		imagesCommand(&opts, dockerCli, backend),
+		killCommand(&opts, dockerCli, backendOptions),
+		runCommand(&opts, dockerCli, backendOptions),
+		removeCommand(&opts, dockerCli, backendOptions),
+		execCommand(&opts, dockerCli, backendOptions),
+		attachCommand(&opts, dockerCli, backendOptions),
+		exportCommand(&opts, dockerCli, backendOptions),
+		commitCommand(&opts, dockerCli, backendOptions),
+		pauseCommand(&opts, dockerCli, backendOptions),
+		unpauseCommand(&opts, dockerCli, backendOptions),
+		topCommand(&opts, dockerCli, backendOptions),
+		eventsCommand(&opts, dockerCli, backendOptions),
+		portCommand(&opts, dockerCli, backendOptions),
+		imagesCommand(&opts, dockerCli, backendOptions),
 		versionCommand(dockerCli),
-		buildCommand(&opts, dockerCli, backend),
-		pushCommand(&opts, dockerCli, backend),
-		pullCommand(&opts, dockerCli, backend),
-		createCommand(&opts, dockerCli, backend),
-		copyCommand(&opts, dockerCli, backend),
-		waitCommand(&opts, dockerCli, backend),
-		scaleCommand(&opts, dockerCli, backend),
+		buildCommand(&opts, dockerCli, backendOptions),
+		pushCommand(&opts, dockerCli, backendOptions),
+		pullCommand(&opts, dockerCli, backendOptions),
+		createCommand(&opts, dockerCli, backendOptions),
+		copyCommand(&opts, dockerCli, backendOptions),
+		waitCommand(&opts, dockerCli, backendOptions),
+		scaleCommand(&opts, dockerCli, backendOptions),
 		statsCommand(&opts, dockerCli),
-		watchCommand(&opts, dockerCli, backend),
-		publishCommand(&opts, dockerCli, backend),
-		alphaCommand(&opts, dockerCli, backend),
+		watchCommand(&opts, dockerCli, backendOptions),
+		publishCommand(&opts, dockerCli, backendOptions),
+		alphaCommand(&opts, dockerCli, backendOptions),
 		bridgeCommand(&opts, dockerCli),
-		volumesCommand(&opts, dockerCli, backend),
+		volumesCommand(&opts, dockerCli, backendOptions),
 	)
 
 	c.Flags().SetInterspersed(false)
 	opts.addProjectFlags(c.Flags())
 	c.RegisterFlagCompletionFunc( //nolint:errcheck
 		"project-name",
-		completeProjectNames(backend),
+		completeProjectNames(dockerCli, backendOptions),
 	)
 	c.RegisterFlagCompletionFunc( //nolint:errcheck
 		"project-directory",

cmd/compose/cp.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
+	"github.com/docker/compose/v2/pkg/compose"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -38,7 +39,7 @@ type copyOptions struct {
 	copyUIDGID  bool
 }
 
-func copyCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose) *cobra.Command {
+func copyCommand(p *ProjectOptions, dockerCli command.Cli, backendOptions *BackendOptions) *cobra.Command {
 	opts := copyOptions{
 		ProjectOptions: p,
 	}
@@ -59,7 +60,7 @@ func copyCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 		RunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
 			opts.source = args[0]
 			opts.destination = args[1]
-			return runCopy(ctx, dockerCli, backend, opts)
+			return runCopy(ctx, dockerCli, backendOptions, opts)
 		}),
 		ValidArgsFunction: completeServiceNames(dockerCli, p),
 	}
@@ -73,12 +74,16 @@ func copyCommand(p *ProjectOptions, dockerCli command.Cli, backend api.Compose)
 	return copyCmd
 }
 
-func runCopy(ctx context.Context, dockerCli command.Cli, backend api.Compose, opts copyOptions) error {
+func runCopy(ctx context.Context, dockerCli command.Cli, backendOptions *BackendOptions, opts copyOptions) error {
 	name, err := opts.toProjectName(ctx, dockerCli)
 	if err != nil {
 		return err
 	}
 
+	backend, err := compose.NewComposeService(dockerCli, backendOptions.Options...)
+	if err != nil {
+		return err
+	}
 	return backend.Copy(ctx, name, api.CopyOptions{
 		Source:      opts.source,
 		Destination: opts.destination,