package stack import ( "errors" "fmt" "strings" "github.com/docker/cli/cli" "github.com/docker/cli/cli/command" "github.com/spf13/cobra" "github.com/spf13/pflag" ) var errUnsupportedAllOrchestrator = fmt.Errorf(`no orchestrator specified: use either "kubernetes" or "swarm"`) type commonOptions struct { orchestrator command.Orchestrator } func (o *commonOptions) Orchestrator() command.Orchestrator { if o == nil { return command.OrchestratorSwarm } return o.orchestrator } // NewStackCommand returns a cobra command for `stack` subcommands func NewStackCommand(dockerCli command.Cli) *cobra.Command { var opts commonOptions cmd := &cobra.Command{ Use: "stack [OPTIONS]", Short: "Manage Docker stacks", Args: cli.NoArgs, PersistentPreRunE: func(cmd *cobra.Command, args []string) error { orchestrator, err := getOrchestrator(dockerCli, cmd) if err != nil { return err } opts.orchestrator = orchestrator hideOrchestrationFlags(cmd, orchestrator) return checkSupportedFlag(cmd, orchestrator) }, RunE: command.ShowHelp(dockerCli.Err()), Annotations: map[string]string{ "version": "1.25", }, } defaultHelpFunc := cmd.HelpFunc() cmd.SetHelpFunc(func(c *cobra.Command, args []string) { if err := cmd.Root().PersistentPreRunE(c, args); err != nil { fmt.Fprintln(dockerCli.Err(), err) return } if err := cmd.PersistentPreRunE(c, args); err != nil { fmt.Fprintln(dockerCli.Err(), err) return } hideOrchestrationFlags(c, opts.orchestrator) defaultHelpFunc(c, args) }) cmd.AddCommand( newDeployCommand(dockerCli, &opts), newListCommand(dockerCli, &opts), newPsCommand(dockerCli, &opts), newRemoveCommand(dockerCli, &opts), newServicesCommand(dockerCli, &opts), ) flags := cmd.PersistentFlags() flags.String("kubeconfig", "", "Kubernetes config file") flags.SetAnnotation("kubeconfig", "kubernetes", nil) flags.String("orchestrator", "", "Orchestrator to use (swarm|kubernetes|all)") return cmd } // NewTopLevelDeployCommand returns a command for `docker deploy` func NewTopLevelDeployCommand(dockerCli command.Cli) *cobra.Command { cmd := newDeployCommand(dockerCli, nil) // Remove the aliases at the top level cmd.Aliases = []string{} cmd.Annotations = map[string]string{ "experimental": "", "version": "1.25", } return cmd } func getOrchestrator(dockerCli command.Cli, cmd *cobra.Command) (command.Orchestrator, error) { var orchestratorFlag string if o, err := cmd.Flags().GetString("orchestrator"); err == nil { orchestratorFlag = o } return dockerCli.StackOrchestrator(orchestratorFlag) } func hideOrchestrationFlags(cmd *cobra.Command, orchestrator command.Orchestrator) { cmd.Flags().VisitAll(func(f *pflag.Flag) { if _, ok := f.Annotations["kubernetes"]; ok && !orchestrator.HasKubernetes() { f.Hidden = true } if _, ok := f.Annotations["swarm"]; ok && !orchestrator.HasSwarm() { f.Hidden = true } }) for _, subcmd := range cmd.Commands() { hideOrchestrationFlags(subcmd, orchestrator) } } func checkSupportedFlag(cmd *cobra.Command, orchestrator command.Orchestrator) error { errs := []string{} cmd.Flags().VisitAll(func(f *pflag.Flag) { if !f.Changed { return } if _, ok := f.Annotations["kubernetes"]; ok && !orchestrator.HasKubernetes() { errs = append(errs, fmt.Sprintf(`"--%s" is only supported on a Docker cli with kubernetes features enabled`, f.Name)) } if _, ok := f.Annotations["swarm"]; ok && !orchestrator.HasSwarm() { errs = append(errs, fmt.Sprintf(`"--%s" is only supported on a Docker cli with swarm features enabled`, f.Name)) } }) for _, subcmd := range cmd.Commands() { if err := checkSupportedFlag(subcmd, orchestrator); err != nil { errs = append(errs, err.Error()) } } if len(errs) > 0 { return errors.New(strings.Join(errs, "\n")) } return nil }