cli/command/stack: internalize RunDeploy, RunRemove

These were deprecated in ad6ab18 and
were only used internally. Move them back inside the stack package.

Signed-off-by: Sebastiaan van Stijn <[email protected]>

Author: thaJeztah

cli/command/stack/common.go

@@ -1,13 +1,17 @@
 package stack
 
 import (
+	"context"
 	"fmt"
 	"strings"
 	"unicode"
 
 	"github.com/docker/cli/cli/compose/convert"
 	"github.com/docker/cli/opts"
 	"github.com/moby/moby/api/types/filters"
+	"github.com/moby/moby/api/types/network"
+	"github.com/moby/moby/api/types/swarm"
+	"github.com/moby/moby/client"
 )
 
 // validateStackName checks if the provided string is a valid stack name (namespace).
@@ -34,6 +38,12 @@ func quotesOrWhitespace(r rune) bool {
 	return unicode.IsSpace(r) || r == '"' || r == '\''
 }
 
+func getStackFilter(namespace string) filters.Args {
+	filter := filters.NewArgs()
+	filter.Add("label", convert.LabelNamespace+"="+namespace)
+	return filter
+}
+
 func getStackFilterFromOpt(namespace string, opt opts.FilterOpt) filters.Args {
 	filter := opt.Value()
 	filter.Add("label", convert.LabelNamespace+"="+namespace)
@@ -45,3 +55,23 @@ func getAllStacksFilter() filters.Args {
 	filter.Add("label", convert.LabelNamespace)
 	return filter
 }
+
+func getStackServices(ctx context.Context, apiclient client.APIClient, namespace string) ([]swarm.Service, error) {
+	return apiclient.ServiceList(ctx, client.ServiceListOptions{Filters: getStackFilter(namespace)})
+}
+
+func getStackNetworks(ctx context.Context, apiclient client.APIClient, namespace string) ([]network.Summary, error) {
+	return apiclient.NetworkList(ctx, client.NetworkListOptions{Filters: getStackFilter(namespace)})
+}
+
+func getStackSecrets(ctx context.Context, apiclient client.APIClient, namespace string) ([]swarm.Secret, error) {
+	return apiclient.SecretList(ctx, client.SecretListOptions{Filters: getStackFilter(namespace)})
+}
+
+func getStackConfigs(ctx context.Context, apiclient client.APIClient, namespace string) ([]swarm.Config, error) {
+	return apiclient.ConfigList(ctx, client.ConfigListOptions{Filters: getStackFilter(namespace)})
+}
+
+func getStackTasks(ctx context.Context, apiclient client.APIClient, namespace string) ([]swarm.Task, error) {
+	return apiclient.TaskList(ctx, client.TaskListOptions{Filters: getStackFilter(namespace)})
+}

cli/command/stack/deploy.go

@@ -1,15 +1,33 @@
 package stack
 
 import (
+	"context"
+	"fmt"
+
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/command/stack/options"
-	"github.com/docker/cli/cli/command/stack/swarm"
+	"github.com/docker/cli/cli/compose/convert"
+	composetypes "github.com/docker/cli/cli/compose/types"
+	"github.com/moby/moby/api/types/swarm"
+	"github.com/moby/moby/api/types/versions"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
+// deployOptions holds docker stack deploy options
+type deployOptions struct {
+	Composefiles     []string
+	Namespace        string
+	ResolveImage     string
+	SendRegistryAuth bool
+	Prune            bool
+	Detach           bool
+	Quiet            bool
+}
+
 func newDeployCommand(dockerCLI command.Cli) *cobra.Command {
-	var opts options.Deploy
+	var opts deployOptions
 
 	cmd := &cobra.Command{
 		Use:     "deploy [OPTIONS] STACK",
@@ -25,7 +43,7 @@ func newDeployCommand(dockerCLI command.Cli) *cobra.Command {
 			if err != nil {
 				return err
 			}
-			return swarm.RunDeploy(cmd.Context(), dockerCLI, cmd.Flags(), &opts, config)
+			return runDeploy(cmd.Context(), dockerCLI, cmd.Flags(), &opts, config)
 		},
 		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 			return completeNames(dockerCLI)(cmd, args, toComplete)
@@ -39,10 +57,76 @@ func newDeployCommand(dockerCLI command.Cli) *cobra.Command {
 	flags.BoolVar(&opts.SendRegistryAuth, "with-registry-auth", false, "Send registry authentication details to Swarm agents")
 	flags.BoolVar(&opts.Prune, "prune", false, "Prune services that are no longer referenced")
 	flags.SetAnnotation("prune", "version", []string{"1.27"})
-	flags.StringVar(&opts.ResolveImage, "resolve-image", swarm.ResolveImageAlways,
-		`Query the registry to resolve image digest and supported platforms ("`+swarm.ResolveImageAlways+`", "`+swarm.ResolveImageChanged+`", "`+swarm.ResolveImageNever+`")`)
+	flags.StringVar(&opts.ResolveImage, "resolve-image", resolveImageAlways,
+		`Query the registry to resolve image digest and supported platforms ("`+resolveImageAlways+`", "`+resolveImageChanged+`", "`+resolveImageNever+`")`)
 	flags.SetAnnotation("resolve-image", "version", []string{"1.30"})
 	flags.BoolVarP(&opts.Detach, "detach", "d", true, "Exit immediately instead of waiting for the stack services to converge")
 	flags.BoolVarP(&opts.Quiet, "quiet", "q", false, "Suppress progress output")
 	return cmd
 }
+
+// Resolve image constants
+const (
+	resolveImageAlways  = "always"
+	resolveImageChanged = "changed"
+	resolveImageNever   = "never"
+)
+
+const defaultNetworkDriver = "overlay"
+
+// runDeploy is the swarm implementation of docker stack deploy
+func runDeploy(ctx context.Context, dockerCLI command.Cli, flags *pflag.FlagSet, opts *deployOptions, cfg *composetypes.Config) error {
+	switch opts.ResolveImage {
+	case resolveImageAlways, resolveImageChanged, resolveImageNever:
+		// valid options.
+	default:
+		return errors.Errorf("Invalid option %s for flag --resolve-image", opts.ResolveImage)
+	}
+
+	// client side image resolution should not be done when the supported
+	// server version is older than 1.30
+	if versions.LessThan(dockerCLI.Client().ClientVersion(), "1.30") {
+		// TODO(thaJeztah): should this error if "opts.ResolveImage" is already other (unsupported) values?
+		opts.ResolveImage = resolveImageNever
+	}
+
+	if opts.Detach && !flags.Changed("detach") {
+		_, _ = fmt.Fprintln(dockerCLI.Err(), "Since --detach=false was not specified, tasks will be created in the background.\n"+
+			"In a future release, --detach=false will become the default.")
+	}
+
+	return deployCompose(ctx, dockerCLI, opts, cfg)
+}
+
+// checkDaemonIsSwarmManager does an Info API call to verify that the daemon is
+// a swarm manager. This is necessary because we must create networks before we
+// create services, but the API call for creating a network does not return a
+// proper status code when it can't create a network in the "global" scope.
+func checkDaemonIsSwarmManager(ctx context.Context, dockerCli command.Cli) error {
+	info, err := dockerCli.Client().Info(ctx)
+	if err != nil {
+		return err
+	}
+	if !info.Swarm.ControlAvailable {
+		return errors.New("this node is not a swarm manager. Use \"docker swarm init\" or \"docker swarm join\" to connect this node to swarm and try again")
+	}
+	return nil
+}
+
+// pruneServices removes services that are no longer referenced in the source
+func pruneServices(ctx context.Context, dockerCLI command.Cli, namespace convert.Namespace, services map[string]struct{}) {
+	apiClient := dockerCLI.Client()
+
+	oldServices, err := getStackServices(ctx, apiClient, namespace.Name())
+	if err != nil {
+		_, _ = fmt.Fprintln(dockerCLI.Err(), "Failed to list services:", err)
+	}
+
+	toRemove := make([]swarm.Service, 0, len(oldServices))
+	for _, service := range oldServices {
+		if _, exists := services[namespace.Descope(service.Spec.Name)]; !exists {
+			toRemove = append(toRemove, service)
+		}
+	}
+	removeServices(ctx, dockerCLI, toRemove)
+}

…ommand/stack/swarm/deploy_composefile.go cli/command/stack/deploy_composefile.gocli/command/stack/swarm/deploy_composefile.go renamed to cli/command/stack/deploy_composefile.go cli/command/stack/swarm/deploy_composefile.go renamed to cli/command/stack/deploy_composefile.go

@@ -1,4 +1,4 @@
-package swarm
+package stack
 
 import (
 	"context"
@@ -7,8 +7,7 @@ import (
 
 	"github.com/containerd/errdefs"
 	"github.com/docker/cli/cli/command"
-	servicecli "github.com/docker/cli/cli/command/service"
-	"github.com/docker/cli/cli/command/stack/options"
+	"github.com/docker/cli/cli/command/service"
 	"github.com/docker/cli/cli/compose/convert"
 	composetypes "github.com/docker/cli/cli/compose/types"
 	"github.com/moby/moby/api/types/container"
@@ -17,7 +16,7 @@ import (
 	"github.com/moby/moby/client"
 )
 
-func deployCompose(ctx context.Context, dockerCli command.Cli, opts *options.Deploy, config *composetypes.Config) error {
+func deployCompose(ctx context.Context, dockerCli command.Cli, opts *deployOptions, config *composetypes.Config) error {
 	if err := checkDaemonIsSwarmManager(ctx, dockerCli); err != nil {
 		return err
 	}
@@ -26,8 +25,8 @@ func deployCompose(ctx context.Context, dockerCli command.Cli, opts *options.Dep
 
 	if opts.Prune {
 		services := map[string]struct{}{}
-		for _, service := range config.Services {
-			services[service.Name] = struct{}{}
+		for _, svc := range config.Services {
+			services[svc.Name] = struct{}{}
 		}
 		pruneServices(ctx, dockerCli, namespace, services)
 	}
@@ -196,8 +195,8 @@ func deployServices(ctx context.Context, dockerCLI command.Cli, services map[str
 	}
 
 	existingServiceMap := make(map[string]swarm.Service)
-	for _, service := range existingServices {
-		existingServiceMap[service.Spec.Name] = service
+	for _, svc := range existingServices {
+		existingServiceMap[svc.Spec.Name] = svc
 	}
 
 	var serviceIDs []string
@@ -217,42 +216,42 @@ func deployServices(ctx context.Context, dockerCLI command.Cli, services map[str
 			}
 		}
 
-		if service, exists := existingServiceMap[name]; exists {
-			_, _ = fmt.Fprintf(out, "Updating service %s (id: %s)\n", name, service.ID)
+		if svc, exists := existingServiceMap[name]; exists {
+			_, _ = fmt.Fprintf(out, "Updating service %s (id: %s)\n", name, svc.ID)
 
 			updateOpts := client.ServiceUpdateOptions{EncodedRegistryAuth: encodedAuth}
 
 			switch resolveImage {
-			case ResolveImageAlways:
+			case resolveImageAlways:
 				// image should be updated by the server using QueryRegistry
 				updateOpts.QueryRegistry = true
-			case ResolveImageChanged:
-				if image != service.Spec.Labels[convert.LabelImage] {
+			case resolveImageChanged:
+				if image != svc.Spec.Labels[convert.LabelImage] {
 					// Query the registry to resolve digest for the updated image
 					updateOpts.QueryRegistry = true
 				} else {
 					// image has not changed; update the serviceSpec with the
 					// existing information that was set by QueryRegistry on the
 					// previous deploy. Otherwise this will trigger an incorrect
 					// service update.
-					serviceSpec.TaskTemplate.ContainerSpec.Image = service.Spec.TaskTemplate.ContainerSpec.Image
+					serviceSpec.TaskTemplate.ContainerSpec.Image = svc.Spec.TaskTemplate.ContainerSpec.Image
 				}
 			default:
-				if image == service.Spec.Labels[convert.LabelImage] {
+				if image == svc.Spec.Labels[convert.LabelImage] {
 					// image has not changed; update the serviceSpec with the
 					// existing information that was set by QueryRegistry on the
 					// previous deploy. Otherwise this will trigger an incorrect
 					// service update.
-					serviceSpec.TaskTemplate.ContainerSpec.Image = service.Spec.TaskTemplate.ContainerSpec.Image
+					serviceSpec.TaskTemplate.ContainerSpec.Image = svc.Spec.TaskTemplate.ContainerSpec.Image
 				}
 			}
 
 			// Stack deploy does not have a `--force` option. Preserve existing
 			// ForceUpdate value so that tasks are not re-deployed if not updated.
 			// TODO move this to API client?
-			serviceSpec.TaskTemplate.ForceUpdate = service.Spec.TaskTemplate.ForceUpdate
+			serviceSpec.TaskTemplate.ForceUpdate = svc.Spec.TaskTemplate.ForceUpdate
 
-			response, err := apiClient.ServiceUpdate(ctx, service.ID, service.Version, serviceSpec, updateOpts)
+			response, err := apiClient.ServiceUpdate(ctx, svc.ID, svc.Version, serviceSpec, updateOpts)
 			if err != nil {
 				return nil, fmt.Errorf("failed to update service %s: %w", name, err)
 			}
@@ -261,12 +260,12 @@ func deployServices(ctx context.Context, dockerCLI command.Cli, services map[str
 				_, _ = fmt.Fprintln(dockerCLI.Err(), warning)
 			}
 
-			serviceIDs = append(serviceIDs, service.ID)
+			serviceIDs = append(serviceIDs, svc.ID)
 		} else {
 			_, _ = fmt.Fprintln(out, "Creating service", name)
 
 			// query registry if flag disabling it was not set
-			queryRegistry := resolveImage == ResolveImageAlways || resolveImage == ResolveImageChanged
+			queryRegistry := resolveImage == resolveImageAlways || resolveImage == resolveImageChanged
 
 			response, err := apiClient.ServiceCreate(ctx, serviceSpec, client.ServiceCreateOptions{
 				EncodedRegistryAuth: encodedAuth,
@@ -286,7 +285,7 @@ func deployServices(ctx context.Context, dockerCLI command.Cli, services map[str
 func waitOnServices(ctx context.Context, dockerCli command.Cli, serviceIDs []string, quiet bool) error {
 	var errs []error
 	for _, serviceID := range serviceIDs {
-		if err := servicecli.WaitOnService(ctx, dockerCli, serviceID, quiet); err != nil {
+		if err := service.WaitOnService(ctx, dockerCli, serviceID, quiet); err != nil {
 			errs = append(errs, fmt.Errorf("%s: %w", serviceID, err))
 		}
 	}

…d/stack/swarm/deploy_composefile_test.go …command/stack/deploy_composefile_test.gocli/command/stack/swarm/deploy_composefile_test.go renamed to cli/command/stack/deploy_composefile_test.go cli/command/stack/swarm/deploy_composefile_test.go renamed to cli/command/stack/deploy_composefile_test.go

@@ -1,4 +1,4 @@
-package swarm
+package stack
 
 import (
 	"context"