Command tree and exported env in kubectl plugins

hack/make-rules/test-cmd-util.sh

@@ -3769,6 +3769,30 @@ __EOF__
   output_message=$(! KUBECTL_PLUGINS_PATH=test/fixtures/pkg/kubectl/plugins/ kubectl plugin error 2>&1)
   kube::test::if_has_string "${output_message}" 'error: exit status 1'
 
+  # plugin tree
+  output_message=$(KUBECTL_PLUGINS_PATH=test/fixtures/pkg/kubectl/plugins kubectl plugin tree 2>&1)
+  kube::test::if_has_string "${output_message}" 'Plugin with a tree of commands'
+  kube::test::if_has_string "${output_message}" 'child1\s\+The first child of a tree'
+  kube::test::if_has_string "${output_message}" 'child2\s\+The second child of a tree'
+  kube::test::if_has_string "${output_message}" 'child3\s\+The third child of a tree'
+  output_message=$(KUBECTL_PLUGINS_PATH=test/fixtures/pkg/kubectl/plugins kubectl plugin tree child1 --help 2>&1)
+  kube::test::if_has_string "${output_message}" 'The first child of a tree'
+  kube::test::if_has_not_string "${output_message}" 'The second child'
+  kube::test::if_has_not_string "${output_message}" 'child2'
+  output_message=$(KUBECTL_PLUGINS_PATH=test/fixtures/pkg/kubectl/plugins kubectl plugin tree child1 2>&1)
+  kube::test::if_has_string "${output_message}" 'child one'
+  kube::test::if_has_not_string "${output_message}" 'child1'
+  kube::test::if_has_not_string "${output_message}" 'The first child'
+
+  # plugin env
+  output_message=$(KUBECTL_PLUGINS_PATH=test/fixtures/pkg/kubectl/plugins kubectl plugin env 2>&1)
+  kube::test::if_has_string "${output_message}" 'KUBECTL_PLUGINS_CURRENT_NAMESPACE'
+  kube::test::if_has_string "${output_message}" 'KUBECTL_PLUGINS_CALLER'
+  kube::test::if_has_string "${output_message}" 'KUBECTL_PLUGINS_DESCRIPTOR_COMMAND=./env.sh'
+  kube::test::if_has_string "${output_message}" 'KUBECTL_PLUGINS_DESCRIPTOR_SHORT_DESC=The plugin envs plugin'
+  kube::test::if_has_string "${output_message}" 'KUBECTL_PLUGINS_GLOBAL_FLAG_KUBECONFIG'
+  kube::test::if_has_string "${output_message}" 'KUBECTL_PLUGINS_GLOBAL_FLAG_REQUEST_TIMEOUT=0'
+
   #################
   # Impersonation #
   #################

pkg/kubectl/cmd/plugin.go

@@ -19,10 +19,10 @@ package cmd
 import (
 	"fmt"
 	"io"
-	"os"
 
 	"github.com/golang/glog"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
 	"k8s.io/kubernetes/pkg/kubectl/plugins"
@@ -61,36 +61,89 @@ func NewCmdPlugin(f cmdutil.Factory, in io.Reader, out, err io.Writer) *cobra.Co
 	if len(loadedPlugins) > 0 {
 		pluginRunner := f.PluginRunner()
 		for _, p := range loadedPlugins {
-			cmd.AddCommand(NewCmdForPlugin(p, pluginRunner, in, out, err))
+			cmd.AddCommand(NewCmdForPlugin(f, p, pluginRunner, in, out, err))
 		}
 	}
 
 	return cmd
 }
 
 // NewCmdForPlugin creates a command capable of running the provided plugin.
-func NewCmdForPlugin(plugin *plugins.Plugin, runner plugins.PluginRunner, in io.Reader, out, errout io.Writer) *cobra.Command {
+func NewCmdForPlugin(f cmdutil.Factory, plugin *plugins.Plugin, runner plugins.PluginRunner, in io.Reader, out, errout io.Writer) *cobra.Command {
 	if !plugin.IsValid() {
 		return nil
 	}
 
-	return &cobra.Command{
+	cmd := &cobra.Command{
 		Use:     plugin.Name,
 		Short:   plugin.ShortDesc,
 		Long:    templates.LongDesc(plugin.LongDesc),
 		Example: templates.Examples(plugin.Example),
 		Run: func(cmd *cobra.Command, args []string) {
-			ctx := plugins.RunningContext{
-				In:         in,
-				Out:        out,
-				ErrOut:     errout,
-				Args:       args,
-				Env:        os.Environ(),
-				WorkingDir: plugin.Dir,
+			if len(plugin.Command) == 0 {
+				cmdutil.DefaultSubCommandRun(errout)(cmd, args)
+				return
+			}
+
+			envProvider := &plugins.MultiEnvProvider{
+				&plugins.PluginCallerEnvProvider{},
+				&plugins.OSEnvProvider{},
+				&plugins.PluginDescriptorEnvProvider{
+					Plugin: plugin,
+				},
+				&flagsPluginEnvProvider{
+					cmd: cmd,
+				},
+				&factoryAttrsPluginEnvProvider{
+					factory: f,
+				},
+			}
+
+			runningContext := plugins.RunningContext{
+				In:          in,
+				Out:         out,
+				ErrOut:      errout,
+				Args:        args,
+				EnvProvider: envProvider,
+				WorkingDir:  plugin.Dir,
 			}
-			if err := runner.Run(plugin, ctx); err != nil {
+
+			if err := runner.Run(plugin, runningContext); err != nil {
 				cmdutil.CheckErr(err)
 			}
 		},
 	}
+
+	for _, childPlugin := range plugin.Tree {
+		cmd.AddCommand(NewCmdForPlugin(f, childPlugin, runner, in, out, errout))
+	}
+
+	return cmd
+}
+
+type flagsPluginEnvProvider struct {
+	cmd *cobra.Command
+}
+
+func (p *flagsPluginEnvProvider) Env() (plugins.EnvList, error) {
+	prefix := "KUBECTL_PLUGINS_GLOBAL_FLAG_"
+	env := plugins.EnvList{}
+	p.cmd.Flags().VisitAll(func(flag *pflag.Flag) {
+		env = append(env, plugins.FlagToEnv(flag, prefix))
+	})
+	return env, nil
+}
+
+type factoryAttrsPluginEnvProvider struct {
+	factory cmdutil.Factory
+}
+
+func (p *factoryAttrsPluginEnvProvider) Env() (plugins.EnvList, error) {
+	cmdNamespace, _, err := p.factory.DefaultNamespace()
+	if err != nil {
+		return plugins.EnvList{}, err
+	}
+	return plugins.EnvList{
+		plugins.Env{N: "KUBECTL_PLUGINS_CURRENT_NAMESPACE", V: cmdNamespace},
+	}, nil
 }

pkg/kubectl/cmd/plugin_test.go

@@ -21,6 +21,7 @@ import (
 	"fmt"
 	"testing"
 
+	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
 	"k8s.io/kubernetes/pkg/kubectl/plugins"
 )
@@ -91,7 +92,8 @@ func TestPluginCmd(t *testing.T) {
 			success: test.expectedSuccess,
 		}
 
-		cmd := NewCmdForPlugin(test.plugin, runner, inBuf, outBuf, errBuf)
+		f, _, _, _ := cmdtesting.NewAPIFactory()
+		cmd := NewCmdForPlugin(f, test.plugin, runner, inBuf, outBuf, errBuf)
 		if cmd == nil {
 			if !test.expectedNilCmd {
 				t.Fatalf("%s: command was unexpectedly not registered", test.name)

pkg/kubectl/plugins/BUILD

@@ -11,6 +11,7 @@ load(
 go_library(
     name = "go_default_library",
     srcs = [
+        "env.go",
         "loader.go",
         "plugins.go",
         "runner.go",
@@ -19,6 +20,7 @@ go_library(
     deps = [
         "//vendor/github.com/ghodss/yaml:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/github.com/spf13/pflag:go_default_library",
         "//vendor/k8s.io/client-go/tools/clientcmd:go_default_library",
     ],
 )
@@ -39,10 +41,12 @@ filegroup(
 go_test(
     name = "go_default_test",
     srcs = [
+        "env_test.go",
         "loader_test.go",
         "plugins_test.go",
         "runner_test.go",
     ],
     library = ":go_default_library",
     tags = ["automanaged"],
+    deps = ["//vendor/github.com/spf13/pflag:go_default_library"],
 )

pkg/kubectl/plugins/env.go

@@ -0,0 +1,147 @@
+/*
+Copyright 2017 The Kubernetes 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 plugins
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/spf13/pflag"
+)
+
+// Env represents an environment variable with its name and value
+type Env struct {
+	N string
+	V string
+}
+
+func (e Env) String() string {
+	return fmt.Sprintf("%s=%s", e.N, e.V)
+}
+
+// EnvList is a list of Env
+type EnvList []Env
+
+func (e EnvList) Slice() []string {
+	envs := []string{}
+	for _, env := range e {
+		envs = append(envs, env.String())
+	}
+	return envs
+}
+
+func (e EnvList) Merge(s ...string) EnvList {
+	newList := e
+	newList = append(newList, fromSlice(s)...)
+	return newList
+}
+
+// EnvProvider provides the environment in which the plugin will run.
+type EnvProvider interface {
+	Env() (EnvList, error)
+}
+
+// MultiEnvProvider is an EnvProvider for multiple env providers, returns on first error.
+type MultiEnvProvider []EnvProvider
+
+func (p MultiEnvProvider) Env() (EnvList, error) {
+	env := EnvList{}
+	for _, provider := range p {
+		pEnv, err := provider.Env()
+		if err != nil {
+			return EnvList{}, err
+		}
+		env = append(env, pEnv...)
+	}
+	return env, nil
+}
+
+// PluginCallerEnvProvider provides env with the path to the caller binary (usually full path to 'kubectl').
+type PluginCallerEnvProvider struct{}
+
+func (p *PluginCallerEnvProvider) Env() (EnvList, error) {
+	caller, err := os.Executable()
+	if err != nil {
+		return EnvList{}, err
+	}
+	return EnvList{
+		{"KUBECTL_PLUGINS_CALLER", caller},
+	}, nil
+}
+
+// PluginDescriptorEnvProvider provides env vars with information about the running plugin.
+type PluginDescriptorEnvProvider struct {
+	Plugin *Plugin
+}
+
+func (p *PluginDescriptorEnvProvider) Env() (EnvList, error) {
+	if p.Plugin == nil {
+		return []Env{}, fmt.Errorf("plugin not present to extract env")
+	}
+	prefix := "KUBECTL_PLUGINS_DESCRIPTOR_"
+	env := EnvList{
+		{prefix + "NAME", p.Plugin.Name},
+		{prefix + "SHORT_DESC", p.Plugin.ShortDesc},
+		{prefix + "LONG_DESC", p.Plugin.LongDesc},
+		{prefix + "EXAMPLE", p.Plugin.Example},
+		{prefix + "COMMAND", p.Plugin.Command},
+	}
+	return env, nil
+}
+
+// OSEnvProvider provides current environment from the operating system.
+type OSEnvProvider struct{}
+
+func (p *OSEnvProvider) Env() (EnvList, error) {
+	return fromSlice(os.Environ()), nil
+}
+
+type EmptyEnvProvider struct{}
+
+func (p *EmptyEnvProvider) Env() (EnvList, error) {
+	return EnvList{}, nil
+}
+
+func FlagToEnvName(flagName, prefix string) string {
+	envName := strings.TrimPrefix(flagName, "--")
+	envName = strings.ToUpper(envName)
+	envName = strings.Replace(envName, "-", "_", -1)
+	envName = prefix + envName
+	return envName
+}
+
+func FlagToEnv(flag *pflag.Flag, prefix string) Env {
+	envName := FlagToEnvName(flag.Name, prefix)
+	return Env{envName, flag.Value.String()}
+}
+
+func fromSlice(envs []string) EnvList {
+	list := EnvList{}
+	for _, env := range envs {
+		list = append(list, parseEnv(env))
+	}
+	return list
+}
+
+func parseEnv(env string) Env {
+	if !strings.Contains(env, "=") {
+		env = env + "="
+	}
+	parsed := strings.SplitN(env, "=", 2)
+	return Env{parsed[0], parsed[1]}
+}