Refactor the deprecated APIs (vmware-tanzu#616)

* Update deprecated apis like feature flag apis

* Remove unused builder publish command

* Address review comments

* Implement sync of active contexts and server

pkg/command/config.go

@@ -15,11 +15,9 @@ import (
 	"gopkg.in/yaml.v3"
 
 	configlib "github.com/vmware-tanzu/tanzu-plugin-runtime/config"
-	configtypes "github.com/vmware-tanzu/tanzu-plugin-runtime/config/types"
 	"github.com/vmware-tanzu/tanzu-plugin-runtime/plugin"
 
 	"github.com/vmware-tanzu/tanzu-cli/pkg/cli"
-	"github.com/vmware-tanzu/tanzu-cli/pkg/config"
 	"github.com/vmware-tanzu/tanzu-cli/pkg/pluginsupplier"
 	"github.com/vmware-tanzu/tanzu-plugin-runtime/log"
 )
@@ -123,26 +121,17 @@ var setConfigCmd = &cobra.Command{
 			return errors.Errorf("only PATH and <value> are allowed")
 		}
 
-		// Acquire tanzu config lock
-		configlib.AcquireTanzuConfigLock()
-		defer configlib.ReleaseTanzuConfigLock()
-
-		cfg, err := configlib.GetClientConfigNoLock()
-		if err != nil {
-			return err
-		}
-
-		err = setConfiguration(cfg, args[0], args[1])
+		err := setConfiguration(args[0], args[1])
 		if err != nil {
 			return err
 		}
 
-		return configlib.StoreClientConfig(cfg)
+		return nil
 	},
 }
 
 // setConfiguration sets the key-value pair for the given path
-func setConfiguration(cfg *configtypes.ClientConfig, pathParam, value string) error {
+func setConfiguration(pathParam, value string) error {
 	// parse the param
 	paramArray := strings.Split(pathParam, ".")
 	if len(paramArray) < 2 {
@@ -153,74 +142,26 @@ func setConfiguration(cfg *configtypes.ClientConfig, pathParam, value string) er
 
 	switch configLiteral {
 	case ConfigLiteralFeatures:
-		return setFeatures(cfg, paramArray, value)
+		if len(paramArray) != 3 {
+			return errors.New("unable to parse config path parameter into three parts [" + strings.Join(paramArray, ".") + "]  (was expecting 'features.<plugin>.<feature>'")
+		}
+		return configlib.SetFeature(paramArray[1], paramArray[2], value)
 	case ConfigLiteralEnv:
-		return setEnvs(cfg, paramArray, value)
+		if len(paramArray) != 2 {
+			return errors.New("unable to parse config path parameter into two parts [" + strings.Join(paramArray, ".") + "]  (was expecting 'env.<variable>'")
+		}
+		return configlib.SetEnv(paramArray[1], value)
 	default:
 		return errors.New("unsupported config path parameter [" + configLiteral + "] (was expecting 'features.<plugin>.<feature>' or 'env.<env_variable>')")
 	}
 }
 
-func setFeatures(cfg *configtypes.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>'")
-	}
-	pluginName := paramArray[1]
-	featureName := paramArray[2]
-
-	if cfg.ClientOptions == nil {
-		cfg.ClientOptions = &configtypes.ClientOptions{}
-	}
-	if cfg.ClientOptions.Features == nil {
-		cfg.ClientOptions.Features = make(map[string]configtypes.FeatureMap)
-	}
-	if cfg.ClientOptions.Features[pluginName] == nil {
-		cfg.ClientOptions.Features[pluginName] = configtypes.FeatureMap{}
-	}
-	cfg.ClientOptions.Features[pluginName][featureName] = value
-	return nil
-}
-
-func setEnvs(cfg *configtypes.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 = &configtypes.ClientOptions{}
-	}
-	if cfg.ClientOptions.Env == nil {
-		cfg.ClientOptions.Env = make(map[string]string)
-	}
-
-	cfg.ClientOptions.Env[envVariable] = value
-	return nil
-}
-
 var initConfigCmd = &cobra.Command{
 	Use:               "init",
 	Short:             "Initialize config with defaults",
 	Long:              "Initialize config with defaults including plugin specific defaults such as default feature flags for all active and installed plugins",
 	ValidArgsFunction: noMoreCompletions,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		// Acquire tanzu config lock
-		configlib.AcquireTanzuConfigLock()
-		defer configlib.ReleaseTanzuConfigLock()
-
-		cfg, err := configlib.GetClientConfigNoLock()
-		if err != nil {
-			return err
-		}
-		if cfg.ClientOptions == nil {
-			cfg.ClientOptions = &configtypes.ClientOptions{}
-		}
-		//nolint: staticcheck
-		//SA1019: cfg.ClientOptions.CLI is deprecated: CLI has been deprecated and will be removed from future version. use CoreCliOptions (staticcheck)
-		if cfg.ClientOptions.CLI == nil {
-			cfg.ClientOptions.CLI = &configtypes.CLIOptions{}
-		}
-
 		plugins, err := pluginsupplier.GetInstalledPlugins()
 		if err != nil {
 			return err
@@ -230,12 +171,10 @@ var initConfigCmd = &cobra.Command{
 		// Plugins that are installed but are not active plugin will not be processed here
 		// and defaultFeatureFlags will not be configured for those plugins
 		for _, desc := range plugins {
-			config.AddDefaultFeatureFlagsIfMissing(cfg, desc.DefaultFeatureFlags)
-		}
-
-		err = configlib.StoreClientConfig(cfg)
-		if err != nil {
-			return err
+			err := configlib.ConfigureFeatureFlags(desc.DefaultFeatureFlags, configlib.SkipIfExists())
+			if err != nil {
+				return err
+			}
 		}
 
 		log.Success("successfully initialized the config")
@@ -340,16 +279,14 @@ func completionGetEnvAndFeatures() []string {
 	}
 
 	// Retrieve client config node
-	cfg, err := configlib.GetClientConfig()
+	featureFlags, err := configlib.GetAllFeatureFlags()
 	if err != nil {
 		return comps
 	}
 
-	if cfg.ClientOptions != nil && cfg.ClientOptions.Features != nil {
-		for plugin, features := range cfg.ClientOptions.Features {
-			for name, value := range features {
-				comps = append(comps, fmt.Sprintf("%s.%s.%s\tValue: %q", ConfigLiteralFeatures, plugin, name, value))
-			}
+	for pluginKey, features := range featureFlags {
+		for name, value := range features {
+			comps = append(comps, fmt.Sprintf("%s.%s.%s\tValue: %q", ConfigLiteralFeatures, pluginKey, name, value))
 		}
 	}
 

pkg/command/config_test.go

@@ -12,12 +12,11 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	configlib "github.com/vmware-tanzu/tanzu-plugin-runtime/config"
-	configtypes "github.com/vmware-tanzu/tanzu-plugin-runtime/config/types"
 )
 
 // Test_config_MalformedPathArg validates functionality when an invalid argument is provided.
 func TestConfigMalformedPathArg(t *testing.T) {
-	err := setConfiguration(nil, "invalid-arg", "")
+	err := setConfiguration("invalid-arg", "")
 	if err == nil {
 		t.Error("Malformed path argument should have resulted in an error")
 	}
@@ -29,7 +28,7 @@ func TestConfigMalformedPathArg(t *testing.T) {
 
 // Test_config_InvalidPathArg validates functionality when an invalid argument is provided.
 func TestConfigInvalidPathArg(t *testing.T) {
-	err := setConfiguration(nil, "shouldbefeatures.plugin.feature", "")
+	err := setConfiguration("shouldbefeatures.plugin.feature", "")
 	if err == nil {
 		t.Error("Invalid path argument should have resulted in an error")
 	}
@@ -39,70 +38,35 @@ func TestConfigInvalidPathArg(t *testing.T) {
 	}
 }
 
-// TestConfigGlobalFeature validates functionality when global feature path argument is provided.
-func TestConfigGlobalFeature(t *testing.T) {
-	cfg := &configtypes.ClientConfig{}
-	value := "bar"
-	err := setConfiguration(cfg, "features.global.foo", value)
-	if err != nil {
-		t.Errorf("Unexpected error returned for global features path argument: %s", err.Error())
-	}
-
-	if cfg.ClientOptions.Features["global"]["foo"] != value {
-		t.Error("cfg.ClientOptions.Features[\"global\"][\"foo\"] was not assigned the value \"" + value + "\"")
-	}
-}
-
-// TestConfigFeature validates functionality when normal feature path argument is provided.
-func TestConfigFeature(t *testing.T) {
-	cfg := &configtypes.ClientConfig{}
-	value := "barr"
-	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())
-	}
-
-	if cfg.ClientOptions.Features["any-plugin"]["foo"] != value {
-		t.Error("cfg.ClientOptions.Features[\"any-plugin\"][\"foo\"] was not assigned the value \"" + value + "\"")
-	}
-}
-
 // TestConfigSetUnsetEnv validates set and unset functionality when env config path argument is provided.
 func TestConfigSetUnsetEnv(t *testing.T) {
-	cfg := &configtypes.ClientConfig{}
 	value := "baar"
-	err := setConfiguration(cfg, "env.foo", value)
+	err := setConfiguration("env.foo", value)
 	assert.Nil(t, err)
-	assert.Equal(t, value, cfg.ClientOptions.Env["foo"])
 
 	err = unsetConfiguration("env.foo")
 	assert.Nil(t, err)
 
-	cfg, err = configlib.GetClientConfigNoLock()
+	cfg, err := configlib.GetClientConfigNoLock()
 	assert.NoError(t, err)
 	assert.Equal(t, cfg.ClientOptions.Env["foo"], "")
 }
 
 // TestConfigIncorrectConfigLiteral validates incorrect config literal
 func TestConfigIncorrectConfigLiteral(t *testing.T) {
-	cfg := &configtypes.ClientConfig{}
 	value := "b"
-	err := setConfiguration(cfg, "fake.any-plugin.foo", value)
+	err := setConfiguration("fake.any-plugin.foo", value)
 	assert.NotNil(t, err)
 	assert.Contains(t, err.Error(), "unsupported config path parameter [fake] (was expecting 'features.<plugin>.<feature>' or 'env.<env_variable>')")
 }
 
 // TestConfigEnv validates functionality when normal env path argument is provided.
 func TestConfigEnv(t *testing.T) {
-	cfg := &configtypes.ClientConfig{}
 	value := "baarr"
-	err := setConfiguration(cfg, "env.any-plugin", value)
+	err := setConfiguration("env.any-plugin", value)
 	if err != nil {
 		t.Errorf("Unexpected error returned for any-plugin env path argument: %s", err.Error())
 	}
-	if cfg.ClientOptions.Env["any-plugin"] != value {
-		t.Error("cfg.ClientOptions.Features[\"any-plugin\"][\"foo\"] was not assigned the value \"" + value + "\"")
-	}
 }
 
 func TestCompletionConfig(t *testing.T) {

pkg/command/root_test.go

@@ -20,7 +20,6 @@ import (
 
 	"github.com/vmware-tanzu/tanzu-cli/pkg/catalog"
 	"github.com/vmware-tanzu/tanzu-cli/pkg/cli"
-	configcli "github.com/vmware-tanzu/tanzu-cli/pkg/config"
 	"github.com/vmware-tanzu/tanzu-cli/pkg/constants"
 )
 
@@ -713,14 +712,8 @@ func TestEnvVarsSet(t *testing.T) {
 	os.Setenv("TANZU_CLI_EULA_PROMPT_ANSWER", "Yes")
 	defer os.RemoveAll(configFileNG.Name())
 
-	// Setup default feature flags since we have created new config files
-	// TODO(khouzam): This is because AddDefaultFeatureFlagsIfMissing() has already
-	// been called in an init() function.  We should fix that in a more generic way.
-	c, err := config.GetClientConfigNoLock()
+	err := config.ConfigureFeatureFlags(constants.DefaultCliFeatureFlags)
 	assert.Nil(err)
-	if configcli.AddDefaultFeatureFlagsIfMissing(c, constants.DefaultCliFeatureFlags) {
-		_ = config.StoreClientConfig(c)
-	}
 
 	rootCmd, err := NewRootCmd()
 	assert.Nil(err)

pkg/config/context.go

@@ -0,0 +1,38 @@
+// Copyright 2024 VMware, Inc. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package config
+
+import (
+	"github.com/pkg/errors"
+
+	"github.com/vmware-tanzu/tanzu-plugin-runtime/config"
+)
+
+// SyncContextsAndServers populate or sync contexts and servers
+func SyncContextsAndServers() error {
+	cfg, err := config.GetClientConfig()
+	if err != nil {
+		return errors.Wrap(err, "failed to get client config")
+	}
+
+	config.PopulateContexts(cfg)
+
+	// Now write the context to the configuration file.  This will also create any missing server for its corresponding context
+	for _, c := range cfg.KnownContexts {
+		err := config.SetContext(c, false)
+		if err != nil {
+			return errors.Wrap(err, "failed to set context")
+		}
+	}
+
+	// Now write the active contexts to the configuration file. This will also create any missing active server for its corresponding context
+	activeContexts, _ := cfg.GetAllActiveContextsList()
+	for _, c := range activeContexts {
+		err := config.SetActiveContext(c)
+		if err != nil {
+			return errors.Wrap(err, "failed to set active context")
+		}
+	}
+	return nil
+}

pkg/config/defaults.go

@@ -31,12 +31,6 @@ var (
 	DefaultStandaloneDiscoveryLocalPath = ""
 )
 
-// CoreRepositoryName is the core repository name.
-const CoreRepositoryName = "core"
-
-// CoreBucketName is the name of the core plugin repository bucket to use.
-var CoreBucketName = "tanzu-cli-framework"
-
 // DefaultTMCPluginsArtifactRepository is the S3 bucket repository for TMC plugins.
 const DefaultTMCPluginsArtifactRepository = "https://tmc-cli.s3-us-west-2.amazonaws.com/plugins/artifacts"