Add kubernetes support to docker/cli

cli/command/cli.go

@@ -44,6 +44,7 @@ type Cli interface {
 	ServerInfo() ServerInfo
 	ClientInfo() ClientInfo
 	NotaryClient(imgRefAndAuth trust.ImageRefAndAuth, actions []string) (notaryclient.Repository, error)
+	DefaultVersion() string
 }
 
 // DockerCli is an instance the docker command line client.
@@ -135,9 +136,11 @@ func (cli *DockerCli) Initialize(opts *cliflags.ClientOptions) error {
 	if err != nil {
  return errors.Wrap(err, "Experimental field")
 	}
+	orchestrator := GetOrchestrator(hasExperimental, opts.Common.Orchestrator, cli.configFile.Orchestrator)
 	cli.clientInfo = ClientInfo{
  DefaultVersion: cli.client.ClientVersion(),
  HasExperimental: hasExperimental,
+ Orchestrator: orchestrator,
 	}
 	cli.initializeFromClient()
 	return nil
@@ -203,6 +206,12 @@ type ServerInfo struct {
 type ClientInfo struct {
 	HasExperimental bool
 	DefaultVersion string
+	Orchestrator Orchestrator
+}
+
+// HasKubernetes checks if kubernetes orchestrator is enabled
+func (c ClientInfo) HasKubernetes() bool {
+	return c.HasExperimental && c.Orchestrator == OrchestratorKubernetes
 }
 
 // NewDockerCli returns a DockerCli instance with IO output and error streams set by in, out and err.

cli/command/cli_test.go

@@ -170,6 +170,110 @@ func TestExperimentalCLI(t *testing.T) {
 	}
 }
 
+func TestOrchestratorSwitch(t *testing.T) {
+	defaultVersion := "v0.00"
+
+	var testcases = []struct {
+ doc string
+ configfile string
+ envOrchestrator string
+ flagOrchestrator string
+ expectedOrchestrator string
+ expectedKubernetes bool
+	}{
+ {
+ doc: "default",
+ configfile: `{
+ "experimental": "enabled"
+ }`,
+ expectedOrchestrator: "swarm",
+ expectedKubernetes: false,
+ },
+ {
+ doc: "kubernetesIsExperimental",
+ configfile: `{
+ "experimental": "disabled",
+ "orchestrator": "kubernetes"
+ }`,
+ envOrchestrator: "kubernetes",
+ flagOrchestrator: "kubernetes",
+ expectedOrchestrator: "swarm",
+ expectedKubernetes: false,
+ },
+ {
+ doc: "kubernetesConfigFile",
+ configfile: `{
+ "experimental": "enabled",
+ "orchestrator": "kubernetes"
+ }`,
+ expectedOrchestrator: "kubernetes",
+ expectedKubernetes: true,
+ },
+ {
+ doc: "kubernetesEnv",
+ configfile: `{
+ "experimental": "enabled"
+ }`,
+ envOrchestrator: "kubernetes",
+ expectedOrchestrator: "kubernetes",
+ expectedKubernetes: true,
+ },
+ {
+ doc: "kubernetesFlag",
+ configfile: `{
+ "experimental": "enabled"
+ }`,
+ flagOrchestrator: "kubernetes",
+ expectedOrchestrator: "kubernetes",
+ expectedKubernetes: true,
+ },
+ {
+ doc: "envOverridesConfigFile",
+ configfile: `{
+ "experimental": "enabled",
+ "orchestrator": "kubernetes"
+ }`,
+ envOrchestrator: "swarm",
+ expectedOrchestrator: "swarm",
+ expectedKubernetes: false,
+ },
+ {
+ doc: "flagOverridesEnv",
+ configfile: `{
+ "experimental": "enabled"
+ }`,
+ envOrchestrator: "kubernetes",
+ flagOrchestrator: "swarm",
+ expectedOrchestrator: "swarm",
+ expectedKubernetes: false,
+ },
+	}
+
+	for _, testcase := range testcases {
+ t.Run(testcase.doc, func(t *testing.T) {
+ dir := fs.NewDir(t, testcase.doc, fs.WithFile("config.json", testcase.configfile))
+ defer dir.Remove()
+ apiclient := &fakeClient{
+ version: defaultVersion,
+ }
+ if testcase.envOrchestrator != "" {
+ defer patchEnvVariable(t, "DOCKER_ORCHESTRATOR", testcase.envOrchestrator)()
+ }
+
+ cli := &DockerCli{client: apiclient, err: os.Stderr}
+ cliconfig.SetDir(dir.Path())
+ options := flags.NewClientOptions()
+ if testcase.flagOrchestrator != "" {
+ options.Common.Orchestrator = testcase.flagOrchestrator
+ }
+ err := cli.Initialize(options)
+ assert.NoError(t, err)
+ assert.Equal(t, testcase.expectedKubernetes, cli.ClientInfo().HasKubernetes())
+ assert.Equal(t, testcase.expectedOrchestrator, string(cli.ClientInfo().Orchestrator))
+ })
+	}
+}
+
 func TestGetClientWithPassword(t *testing.T) {
 	expected := "password"
 

cli/command/config/cmd.go

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

cli/command/node/cmd.go

@@ -14,11 +14,14 @@ import (
 // NewNodeCommand returns a cobra command for `node` subcommands
 func NewNodeCommand(dockerCli command.Cli) *cobra.Command {
 	cmd := &cobra.Command{
- Use: "node",
- Short: "Manage Swarm nodes",
- Args: cli.NoArgs,
- RunE: command.ShowHelp(dockerCli.Err()),
- Annotations: map[string]string{"version": "1.24"},
+ Use: "node",
+ Short: "Manage Swarm nodes",
+ Args: cli.NoArgs,
+ RunE: command.ShowHelp(dockerCli.Err()),
+ Annotations: map[string]string{
+ "version": "1.24",
+ "swarm": "",
+ },
 	}
 	cmd.AddCommand(
  newDemoteCommand(dockerCli),

cli/command/orchestrator.go

@@ -0,0 +1,59 @@
+package command
+
+import (
+	"fmt"
+	"os"
+)
+
+// Orchestrator type acts as an enum describing supported orchestrators.
+type Orchestrator string
+
+const (
+	// OrchestratorKubernetes orchestrator
+	OrchestratorKubernetes = Orchestrator("kubernetes")
+	// OrchestratorSwarm orchestrator
+	OrchestratorSwarm = Orchestrator("swarm")
+	orchestratorUnset = Orchestrator("unset")
+
+	defaultOrchestrator = OrchestratorSwarm
+	envVarDockerOrchestrator = "DOCKER_ORCHESTRATOR"
+)
+
+func normalize(flag string) Orchestrator {
+	switch flag {
+	case "kubernetes", "k8s":
+ return OrchestratorKubernetes
+	case "swarm", "swarmkit":
+ return OrchestratorSwarm
+	default:
+ return orchestratorUnset
+	}
+}
+
+// GetOrchestrator checks DOCKER_ORCHESTRATOR environment variable and configuration file
+// orchestrator value and returns user defined Orchestrator.
+func GetOrchestrator(isExperimental bool, flagValue, value string) Orchestrator {
+	// Non experimental CLI has kubernetes disabled
+	if !isExperimental {
+ return defaultOrchestrator
+	}
+	// Check flag
+	if o := normalize(flagValue); o != orchestratorUnset {
+ return o
+	}
+	// Check environment variable
+	env := os.Getenv(envVarDockerOrchestrator)
+	if o := normalize(env); o != orchestratorUnset {
+ return o
+	}
+	// Check specified orchestrator
+	if o := normalize(value); o != orchestratorUnset {
+ return o
+	}
+
+	if value != "" {
+ fmt.Fprintf(os.Stderr, "Specified orchestrator %q is invalid. Please use either kubernetes or swarm\n", value)
+	}
+	// Nothing set, use default orchestrator
+	return defaultOrchestrator
+}

cli/command/secret/cmd.go

@@ -10,11 +10,14 @@ import (
 // NewSecretCommand returns a cobra command for `secret` subcommands
 func NewSecretCommand(dockerCli command.Cli) *cobra.Command {
 	cmd := &cobra.Command{
- Use: "secret",
- Short: "Manage Docker secrets",
- Args: cli.NoArgs,
- RunE: command.ShowHelp(dockerCli.Err()),
- Annotations: map[string]string{"version": "1.25"},
+ Use: "secret",
+ Short: "Manage Docker secrets",
+ Args: cli.NoArgs,
+ RunE: command.ShowHelp(dockerCli.Err()),
+ Annotations: map[string]string{
+ "version": "1.25",
+ "swarm": "",
+ },
 	}
 	cmd.AddCommand(
  newSecretListCommand(dockerCli),

cli/command/service/cmd.go

@@ -10,11 +10,14 @@ import (
 // NewServiceCommand returns a cobra command for `service` subcommands
 func NewServiceCommand(dockerCli command.Cli) *cobra.Command {
 	cmd := &cobra.Command{
- Use: "service",
- Short: "Manage services",
- Args: cli.NoArgs,
- RunE: command.ShowHelp(dockerCli.Err()),
- Annotations: map[string]string{"version": "1.24"},
+ Use: "service",
+ Short: "Manage services",
+ Args: cli.NoArgs,
+ RunE: command.ShowHelp(dockerCli.Err()),
+ Annotations: map[string]string{
+ "version": "1.24",
+ "swarm": "",
+ },
 	}
 	cmd.AddCommand(
  newCreateCommand(dockerCli),

cli/command/stack/cmd.go

@@ -18,10 +18,17 @@ func NewStackCommand(dockerCli command.Cli) *cobra.Command {
 	cmd.AddCommand(
  newDeployCommand(dockerCli),
  newListCommand(dockerCli),
+ newPsCommand(dockerCli),
  newRemoveCommand(dockerCli),
  newServicesCommand(dockerCli),
- newPsCommand(dockerCli),
 	)
+	flags := cmd.PersistentFlags()
+	flags.String("namespace", "default", "Kubernetes namespace to use")
+	flags.SetAnnotation("namespace", "kubernetes", nil)
+	flags.SetAnnotation("namespace", "experimentalCLI", nil)
+	flags.String("kubeconfig", "", "Kubernetes config file")
+	flags.SetAnnotation("kubeconfig", "kubernetes", nil)
+	flags.SetAnnotation("kubeconfig", "experimentalCLI", nil)
 	return cmd
 }