Support set/unset environment variables through tanzu config file

- The change allows users to configure env variables as part of tanzu
  config file
- Env configuration can be set using `tanzu config set env.<variable> <value>`
  command
- User can unset the already configured settings with new `tanzu config
  unset env.<variable>` command
- In the case of conflicts, meaning user has set environment variable
  outside tanzu config file with `export FOO=bar` and as part of tanzu
  config file, higer precedence is given to user configured environment
  variable to allow user to override config for one off command runs

Author: Anuj Chaudhari

apis/config/v1alpha1/clientconfig.go

@@ -86,6 +86,15 @@ func (c *ClientConfig) IsConfigFeatureActivated(featurePath string) (bool, error
 	return booleanValue, nil
 }
 
+// GetEnvConfigurations returns a map of environment variables to values
+// it returns nil if configuration is not yet defined
+func (c *ClientConfig) GetEnvConfigurations() map[string]string {
+	if c.ClientOptions == nil || c.ClientOptions.Env == nil {
+		return nil
+	}
+	return c.ClientOptions.Env
+}
+
 // SplitFeaturePath splits a features path into the pluginName and the featureName
 // For example "features.management-cluster.dual-stack" returns "management-cluster", "dual-stack"
 // An error results from a malformed path, including any path that does not start with "features."

apis/config/v1alpha1/clientconfig_types.go

@@ -93,6 +93,7 @@ type ClientOptions struct {
 	// CLI options specific to the CLI.
 	CLI      *CLIOptions           `json:"cli,omitempty" yaml:"cli"`
 	Features map[string]FeatureMap `json:"features,omitempty" yaml:"features"`
+	Env      map[string]string     `json:"env,omitempty" yaml:"env"`
 }
 
 // FeatureMap is simply a hash table, but needs an explicit type to be an object in another hash map (cf ClientOptions.Features)

pkg/v1/cli/command/core/config.go

@@ -20,12 +20,19 @@ import (
 	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/config"
 )
 
+// ConfigLiterals used with set/unset commands
+const (
+	ConfigLiteralFeatures = "features"
+	ConfigLiteralEnv      = "env"
+)
+
 func init() {
 	configCmd.SetUsageFunc(cli.SubCmdUsageFunc)
 	configCmd.AddCommand(
 		getConfigCmd,
 		initConfigCmd,
 		setConfigCmd,
+		unsetConfigCmd,
 		serversCmd,
 	)
 	serversCmd.AddCommand(listServersCmd)
@@ -67,7 +74,7 @@ var getConfigCmd = &cobra.Command{
 
 var setConfigCmd = &cobra.Command{
 	Use:   "set <path> <value>",
-	Short: "Set config values at the given path. path values: [unstable-versions, features.global.<feature>, features.<plugin>.<feature>]",
+	Short: "Set config values at the given path. path values: [unstable-versions, features.global.<feature>, features.<plugin>.<feature>, env.global.<variable>, env.<plugin>.<variable>]",
 	RunE: func(cmd *cobra.Command, args []string) error {
 		if len(args) < 2 {
 			return errors.Errorf("both path and value are required")
@@ -80,7 +87,7 @@ var setConfigCmd = &cobra.Command{
 			return err
 		}
 
-		err = setFeature(cfg, args[0], args[1])
+		err = setConfiguration(cfg, args[0], args[1])
 		if err != nil {
 			return err
 		}
@@ -89,8 +96,8 @@ var setConfigCmd = &cobra.Command{
 	},
 }
 
-// setFeature sets the key-value pair for the given path
-func setFeature(cfg *configv1alpha1.ClientConfig, pathParam, value string) error {
+// setConfiguration sets the key-value pair for the given path
+func setConfiguration(cfg *configv1alpha1.ClientConfig, pathParam, value string) error {
 	// special cases:
 	// backward compatibility
 	if pathParam == "unstable-versions" {
@@ -99,17 +106,28 @@ func setFeature(cfg *configv1alpha1.ClientConfig, pathParam, value string) error
 
 	// parse the param
 	paramArray := strings.Split(pathParam, ".")
-	if len(paramArray) != 3 {
-		return errors.New("unable to parse config path parameter into three parts [" + pathParam + "]  (was expecting features.<plugin>.<feature>)")
+	if len(paramArray) < 2 {
+		return errors.New("unable to parse config path parameter into parts [" + pathParam + "]  (was expecting 'features.<plugin>.<feature>' or 'env.<env_variable>')")
 	}
 
-	featuresLiteral := paramArray[0]
-	plugin := paramArray[1]
-	key := paramArray[2]
+	configLiteral := paramArray[0]
+
+	switch configLiteral {
+	case ConfigLiteralFeatures:
+		return setFeatures(cfg, paramArray, value)
+	case ConfigLiteralEnv:
+		return setEnvs(cfg, paramArray, value)
+	default:
+		return errors.New("unsupported config path parameter [" + configLiteral + "] (was expecting 'features.<plugin>.<feature>' or 'env.<env_variable>')")
+	}
+}
 
-	if featuresLiteral != "features" {
-		return errors.New("unsupported config path parameter [" + featuresLiteral + "] (was expecting 'features.<plugin>.<feature>')")
+func setFeatures(cfg *configv1alpha1.ClientConfig, paramArray []string, value string) error {
+	if len(paramArray) != 3 {
+		return errors.New("unable to parse config path parameter into three parts [" + strings.Join(paramArray, ".") + "]  (was expecting 'features.<plugin>.<feature>'")
 	}
+	plugin := paramArray[1]
+	featureName := paramArray[2]
 
 	if cfg.ClientOptions == nil {
 		cfg.ClientOptions = &configv1alpha1.ClientOptions{}
@@ -120,8 +138,24 @@ func setFeature(cfg *configv1alpha1.ClientConfig, pathParam, value string) error
 	if cfg.ClientOptions.Features[plugin] == nil {
 		cfg.ClientOptions.Features[plugin] = configv1alpha1.FeatureMap{}
 	}
-	cfg.ClientOptions.Features[plugin][key] = value
+	cfg.ClientOptions.Features[plugin][featureName] = value
+	return nil
+}
+
+func setEnvs(cfg *configv1alpha1.ClientConfig, paramArray []string, value string) error {
+	if len(paramArray) != 2 {
+		return errors.New("unable to parse config path parameter into two parts [" + strings.Join(paramArray, ".") + "]  (was expecting 'env.<variable>'")
+	}
+	envVariable := paramArray[1]
 
+	if cfg.ClientOptions == nil {
+		cfg.ClientOptions = &configv1alpha1.ClientOptions{}
+	}
+	if cfg.ClientOptions.Env == nil {
+		cfg.ClientOptions.Env = make(map[string]string)
+	}
+
+	cfg.ClientOptions.Env[envVariable] = value
 	return nil
 }
 
@@ -256,3 +290,76 @@ var deleteServersCmd = &cobra.Command{
 		return nil
 	},
 }
+
+var unsetConfigCmd = &cobra.Command{
+	Use:   "unset <path>",
+	Short: "Unset config values at the given path. path values: [features.global.<feature>, features.<plugin>.<feature>, env.global.<variable>, env.<plugin>.<variable>]",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if len(args) < 1 {
+			return errors.Errorf("path is required")
+		}
+		if len(args) > 1 {
+			return errors.Errorf("only path is allowed")
+		}
+		cfg, err := config.GetClientConfig()
+		if err != nil {
+			return err
+		}
+
+		err = unsetConfiguration(cfg, args[0])
+		if err != nil {
+			return err
+		}
+
+		return config.StoreClientConfig(cfg)
+	},
+}
+
+// unsetConfiguration unsets the key-value pair for the given path and removes it
+func unsetConfiguration(cfg *configv1alpha1.ClientConfig, pathParam string) error {
+	// parse the param
+	paramArray := strings.Split(pathParam, ".")
+	if len(paramArray) < 2 {
+		return errors.New("unable to parse config path parameter into parts [" + pathParam + "]  (was expecting 'features.<plugin>.<feature>' or 'env.<env_variable>')")
+	}
+
+	configLiteral := paramArray[0]
+
+	switch configLiteral {
+	case ConfigLiteralFeatures:
+		return unsetFeatures(cfg, paramArray)
+	case ConfigLiteralEnv:
+		return unsetEnvs(cfg, paramArray)
+	default:
+		return errors.New("unsupported config path parameter [" + configLiteral + "] (was expecting 'features.<plugin>.<feature>' or 'env.<env_variable>')")
+	}
+}
+
+func unsetFeatures(cfg *configv1alpha1.ClientConfig, paramArray []string) error {
+	if len(paramArray) != 3 {
+		return errors.New("unable to parse config path parameter into three parts [" + strings.Join(paramArray, ".") + "]  (was expecting 'features.<plugin>.<feature>'")
+	}
+	plugin := paramArray[1]
+	featureName := paramArray[2]
+
+	if cfg.ClientOptions == nil || cfg.ClientOptions.Features == nil ||
+		cfg.ClientOptions.Features[plugin] == nil {
+		return nil
+	}
+	delete(cfg.ClientOptions.Features[plugin], featureName)
+	return nil
+}
+
+func unsetEnvs(cfg *configv1alpha1.ClientConfig, paramArray []string) error {
+	if len(paramArray) != 2 {
+		return errors.New("unable to parse config path parameter into two parts [" + strings.Join(paramArray, ".") + "]  (was expecting 'env.<env_variable>'")
+	}
+
+	envVariable := paramArray[1]
+	if cfg.ClientOptions == nil || cfg.ClientOptions.Env == nil {
+		return nil
+	}
+	delete(cfg.ClientOptions.Env, envVariable)
+
+	return nil
+}

pkg/v1/cli/command/core/config_test.go

@@ -7,12 +7,14 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+
 	configv1alpha1 "github.com/vmware-tanzu/tanzu-framework/apis/config/v1alpha1"
 )
 
 // Test_config_MalformedPathArg validates functionality when an invalid argument is provided.
 func Test_config_MalformedPathArg(t *testing.T) {
-	err := setFeature(nil, "invalid-arg", "")
+	err := setConfiguration(nil, "invalid-arg", "")
 	if err == nil {
 		t.Error("Malformed path argument should have resulted in an error")
 	}
@@ -24,7 +26,7 @@ func Test_config_MalformedPathArg(t *testing.T) {
 
 // Test_config_InvalidPathArg validates functionality when an invalid argument is provided.
 func Test_config_InvalidPathArg(t *testing.T) {
-	err := setFeature(nil, "shouldbefeatures.plugin.feature", "")
+	err := setConfiguration(nil, "shouldbefeatures.plugin.feature", "")
 	if err == nil {
 		t.Error("Invalid path argument should have resulted in an error")
 	}
@@ -37,7 +39,7 @@ func Test_config_InvalidPathArg(t *testing.T) {
 // Test_config_UnstableVersions validates functionality when path argument unstable-versions is provided.
 func Test_config_UnstableVersions(t *testing.T) {
 	cfg := &configv1alpha1.ClientConfig{}
-	err := setFeature(cfg, "unstable-versions", "experimental")
+	err := setConfiguration(cfg, "unstable-versions", "experimental")
 	if err != nil {
 		t.Errorf("Unexpected error returned for unstable-versions path argument: %s", err.Error())
 	}
@@ -50,7 +52,7 @@ func Test_config_UnstableVersions(t *testing.T) {
 // Test_config_InvalidUnstableVersions validates functionality when invalid unstable-versions is provided.
 func Test_config_InvalidUnstableVersions(t *testing.T) {
 	cfg := &configv1alpha1.ClientConfig{}
-	err := setFeature(cfg, "unstable-versions", "invalid-unstable-versions-value")
+	err := setConfiguration(cfg, "unstable-versions", "invalid-unstable-versions-value")
 	if err == nil {
 		t.Error("Invalid unstable-versions should have resulted in error")
 	}
@@ -64,7 +66,7 @@ func Test_config_InvalidUnstableVersions(t *testing.T) {
 func Test_config_GlobalFeature(t *testing.T) {
 	cfg := &configv1alpha1.ClientConfig{}
 	value := "bar"
-	err := setFeature(cfg, "features.global.foo", value)
+	err := setConfiguration(cfg, "features.global.foo", value)
 	if err != nil {
 		t.Errorf("Unexpected error returned for global features path argument: %s", err.Error())
 	}
@@ -78,7 +80,7 @@ func Test_config_GlobalFeature(t *testing.T) {
 func Test_config_Feature(t *testing.T) {
 	cfg := &configv1alpha1.ClientConfig{}
 	value := "barr"
-	err := setFeature(cfg, "features.any-plugin.foo", value)
+	err := setConfiguration(cfg, "features.any-plugin.foo", value)
 	if err != nil {
 		t.Errorf("Unexpected error returned for any-plugin features path argument: %s", err.Error())
 	}
@@ -87,3 +89,29 @@ func Test_config_Feature(t *testing.T) {
 		t.Error("cfg.ClientOptions.Features[\"any-plugin\"][\"foo\"] was not assigned the value \"" + value + "\"")
 	}
 }
+
+// Test_config_SetUnsetEnv validates set and unset functionality when env config path argument is provided.
+func Test_config_SetUnsetEnv(t *testing.T) {
+	assert := assert.New(t)
+
+	cfg := &configv1alpha1.ClientConfig{}
+	value := "baar"
+	err := setConfiguration(cfg, "env.foo", value)
+	assert.Nil(err)
+	assert.Equal(value, cfg.ClientOptions.Env["foo"])
+
+	err = unsetConfiguration(cfg, "env.foo")
+	assert.Nil(err)
+	assert.Equal(cfg.ClientOptions.Env["foo"], "")
+}
+
+// Test_config_IncorrectConfigLiteral validates incorrect config literal
+func Test_config_IncorrectConfigLiteral(t *testing.T) {
+	assert := assert.New(t)
+
+	cfg := &configv1alpha1.ClientConfig{}
+	value := "b"
+	err := setConfiguration(cfg, "fake.any-plugin.foo", value)
+	assert.NotNil(err)
+	assert.Contains(err.Error(), "unsupported config path parameter [fake] (was expecting 'features.<plugin>.<feature>' or 'env.<env_variable>')")
+}

pkg/v1/cli/command/core/root.go

@@ -78,6 +78,10 @@ func NewRootCmd() (*cobra.Command, error) {
 		}
 	}
 
+	// configure defined global environment variables
+	// under tanzu config file
+	config.ConfigureEnvVariables()
+
 	for _, plugin := range plugins {
 		RootCmd.AddCommand(cli.GetCmd(plugin))
 	}

pkg/v1/config/clientconfig.go

@@ -507,3 +507,30 @@ func IsFeatureActivated(feature string) bool {
 	}
 	return status
 }
+
+// GetEnvConfigurations returns a map of configured environment variables
+// to values as part of tanzu configuration file
+// it returns nil if configuration is not yet defined
+func GetEnvConfigurations() map[string]string {
+	cfg, err := GetClientConfig()
+	if err != nil {
+		return nil
+	}
+	return cfg.GetEnvConfigurations()
+}
+
+// ConfigureEnvVariables reads and configures provided environment variables
+// as part of tanzu configuration file
+func ConfigureEnvVariables() {
+	envMap := GetEnvConfigurations()
+	if envMap == nil {
+		return
+	}
+	for variable, value := range envMap {
+		// If environment variable is not already set
+		// set the environment variable
+		if os.Getenv(variable) == "" {
+			os.Setenv(variable, value)
+		}
+	}
+}