Set/unset param globals

Signed-off-by: bryanl <bryanliles@gmail.com>

actions/param_delete.go

@@ -26,6 +26,7 @@ import (
 
 type getModuleFn func(ksApp app.App, moduleName string) (component.Module, error)
 type deleteEnvFn func(ksApp app.App, envName, componentName, paramName string) error
+type deleteEnvGlobalFn func(a app.App, envName, paramName string) error
 
 // RunParamDelete runs `param set`
 func RunParamDelete(m map[string]interface{}) error {
@@ -46,9 +47,10 @@ type ParamDelete struct {
 	global  bool
 	envName string
 
-	deleteEnvFn   deleteEnvFn
-	getModuleFn   getModuleFn
-	resolvePathFn func(a app.App, path string) (component.Module, component.Component, error)
+	deleteEnvFn       deleteEnvFn
+	deleteEnvGlobalFn deleteEnvGlobalFn
+	getModuleFn       getModuleFn
+	resolvePathFn     func(a app.App, path string) (component.Module, component.Component, error)
 }
 
 // NewParamDelete creates an instance of ParamDelete.
@@ -57,15 +59,16 @@ func NewParamDelete(m map[string]interface{}) (*ParamDelete, error) {
 
 	pd := &ParamDelete{
 		app:     ol.loadApp(),
-		name:    ol.loadString(OptionName),
+		name:    ol.loadOptionalString(OptionName),
 		rawPath: ol.loadString(OptionPath),
 		global:  ol.loadOptionalBool(OptionGlobal),
 		envName: ol.loadOptionalString(OptionEnvName),
 		index:   ol.loadOptionalInt(OptionIndex),
 
-		deleteEnvFn:   env.DeleteParam,
-		resolvePathFn: component.ResolvePath,
-		getModuleFn:   component.GetModule,
+		deleteEnvFn:       env.DeleteParam,
+		deleteEnvGlobalFn: env.UnsetGlobalParams,
+		resolvePathFn:     component.ResolvePath,
+		getModuleFn:       component.GetModule,
 	}
 
 	if ol.err != nil {
@@ -82,7 +85,10 @@ func NewParamDelete(m map[string]interface{}) (*ParamDelete, error) {
 // Run runs the action.
 func (pd *ParamDelete) Run() error {
 	if pd.envName != "" {
-		return pd.deleteEnvFn(pd.app, pd.envName, pd.name, pd.rawPath)
+		if pd.name != "" {
+			return pd.deleteEnvFn(pd.app, pd.envName, pd.name, pd.rawPath)
+		}
+		return pd.deleteEnvGlobalFn(pd.app, pd.envName, pd.rawPath)
 	}
 
 	path := strings.Split(pd.rawPath, ".")

actions/param_delete_test.go

@@ -133,3 +133,28 @@ func TestParamDelete_env(t *testing.T) {
 		require.NoError(t, err)
 	})
 }
+
+func TestParamDelete_env_global(t *testing.T) {
+	withApp(t, func(appMock *amocks.App) {
+		path := "replicas"
+
+		in := map[string]interface{}{
+			OptionApp:     appMock,
+			OptionPath:    path,
+			OptionEnvName: "default",
+		}
+
+		a, err := NewParamDelete(in)
+		require.NoError(t, err)
+
+		envDelete := func(ksApp app.App, envName, pName string) error {
+			assert.Equal(t, "default", envName)
+			assert.Equal(t, "replicas", pName)
+			return nil
+		}
+		a.deleteEnvGlobalFn = envDelete
+
+		err = a.Run()
+		require.NoError(t, err)
+	})
+}

actions/param_set.go

@@ -16,7 +16,6 @@
 package actions
 
 import (
-	"strconv"
 	"strings"
 
 	"github.com/ksonnet/ksonnet/component"
@@ -47,9 +46,10 @@ type ParamSet struct {
 	global   bool
 	envName  string
 
-	getModuleFn   getModuleFn
-	resolvePathFn func(a app.App, path string) (component.Module, component.Component, error)
-	setEnvFn      func(ksApp app.App, envName, name, pName, value string) error
+	getModuleFn    getModuleFn
+	resolvePathFn  func(a app.App, path string) (component.Module, component.Component, error)
+	setEnvFn       func(ksApp app.App, envName, name, pName, value string) error
+	setGlobalEnvFn func(ksApp app.App, envName, pName, value string) error
 }
 
 // NewParamSet creates an instance of ParamSet.
@@ -58,16 +58,17 @@ func NewParamSet(m map[string]interface{}) (*ParamSet, error) {
 
 	ps := &ParamSet{
 		app:      ol.loadApp(),
-		name:     ol.loadString(OptionName),
+		name:     ol.loadOptionalString(OptionName),
 		rawPath:  ol.loadString(OptionPath),
 		rawValue: ol.loadString(OptionValue),
 		global:   ol.loadOptionalBool(OptionGlobal),
 		envName:  ol.loadOptionalString(OptionEnvName),
 		index:    ol.loadOptionalInt(OptionIndex),
 
-		getModuleFn:   component.GetModule,
-		resolvePathFn: component.ResolvePath,
-		setEnvFn:      setEnv,
+		getModuleFn:    component.GetModule,
+		resolvePathFn:  component.ResolvePath,
+		setEnvFn:       setEnv,
+		setGlobalEnvFn: setGlobalEnv,
 	}
 
 	if ol.err != nil {
@@ -88,13 +89,11 @@ func (ps *ParamSet) Run() error {
 		return errors.Wrap(err, "value is invalid")
 	}
 
-	evaluatedValue := ps.rawValue
-	if _, ok := value.(string); ok {
-		evaluatedValue = strconv.Quote(ps.rawValue)
-	}
-
 	if ps.envName != "" {
-		return ps.setEnvFn(ps.app, ps.envName, ps.name, ps.rawPath, evaluatedValue)
+		if ps.name != "" {
+			return ps.setEnvFn(ps.app, ps.envName, ps.name, ps.rawPath, ps.rawValue)
+		}
+		return ps.setGlobalEnvFn(ps.app, ps.envName, ps.rawPath, ps.rawValue)
 	}
 
 	path := strings.Split(ps.rawPath, ".")
@@ -147,3 +146,11 @@ func setEnv(ksApp app.App, envName, name, pName, value string) error {
 
 	return env.SetParams(envName, name, p, spc)
 }
+
+func setGlobalEnv(ksApp app.App, envName, pName, value string) error {
+	p := mp.Params{
+		pName: value,
+	}
+
+	return env.SetGlobalParams(ksApp, envName, p)
+}

actions/param_set_test.go

@@ -142,3 +142,31 @@ func TestParamSet_env(t *testing.T) {
 		require.NoError(t, err)
 	})
 }
+
+func TestParamSet_envGlobal(t *testing.T) {
+	withApp(t, func(appMock *amocks.App) {
+		path := "replicas"
+		value := "3"
+
+		in := map[string]interface{}{
+			OptionApp:     appMock,
+			OptionPath:    path,
+			OptionValue:   value,
+			OptionEnvName: "default",
+		}
+
+		a, err := NewParamSet(in)
+		require.NoError(t, err)
+
+		envSetter := func(ksApp app.App, envName, pName, value string) error {
+			assert.Equal(t, "default", envName)
+			assert.Equal(t, "replicas", pName)
+			assert.Equal(t, "3", value)
+			return nil
+		}
+		a.setGlobalEnvFn = envSetter
+
+		err = a.Run()
+		require.NoError(t, err)
+	})
+}

cmd/param_delete.go

@@ -16,9 +16,8 @@
 package cmd
 
 import (
-	"fmt"
-
 	"github.com/ksonnet/ksonnet/actions"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -32,14 +31,23 @@ var paramDeleteCmd = &cobra.Command{
 	Use:   "delete <component-name> <param-key>",
 	Short: paramShortDesc["delete"],
 	RunE: func(cmd *cobra.Command, args []string) error {
-		if len(args) != 2 {
-			return fmt.Errorf("'param delete' takes exactly two arguments, (1) the name of the component, and the key")
+		var name string
+		var path string
+
+		switch len(args) {
+		default:
+			return errors.New("invalid arguments for 'param delete'")
+		case 2:
+			name = args[0]
+			path = args[1]
+		case 1:
+			path = args[0]
 		}
 
 		m := map[string]interface{}{
 			actions.OptionApp:     ka,
-			actions.OptionName:    args[0],
-			actions.OptionPath:    args[1],
+			actions.OptionName:    name,
+			actions.OptionPath:    path,
 			actions.OptionEnvName: viper.GetString(vParamDeleteEnv),
 			actions.OptionIndex:   viper.GetInt(vParamDeleteIndex),
 		}

cmd/param_set.go

@@ -16,9 +16,8 @@
 package cmd
 
 import (
-	"fmt"
-
 	"github.com/ksonnet/ksonnet/actions"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -32,15 +31,27 @@ var paramSetCmd = &cobra.Command{
 	Use:   "set <component-name> <param-key> <param-value>",
 	Short: paramShortDesc["set"],
 	RunE: func(cmd *cobra.Command, args []string) error {
-		if len(args) != 3 {
-			return fmt.Errorf("'param set' takes exactly three arguments, (1) the name of the component, in addition to (2) the key and (3) value of the parameter")
+		var name string
+		var path string
+		var value string
+
+		switch len(args) {
+		default:
+			return errors.New("invalid arguments for 'param set'")
+		case 3:
+			name = args[0]
+			path = args[1]
+			value = args[2]
+		case 2:
+			path = args[0]
+			value = args[1]
 		}
 
 		m := map[string]interface{}{
 			actions.OptionApp:     ka,
-			actions.OptionName:    args[0],
-			actions.OptionPath:    args[1],
-			actions.OptionValue:   args[2],
+			actions.OptionName:    name,
+			actions.OptionPath:    path,
+			actions.OptionValue:   value,
 			actions.OptionEnvName: viper.GetString(vParamSetEnv),
 			actions.OptionIndex:   viper.GetInt(vParamSetIndex),
 		}

cmd/param_set_test.go

@@ -36,6 +36,25 @@ func Test_paramSetCmd(t *testing.T) {
 				actions.OptionIndex:   0,
 			},
 		},
+		{
+			name:   "set env global",
+			args:   []string{"param", "set", "param-name", "param-value", "--env", "default"},
+			action: actionParamSet,
+			expected: map[string]interface{}{
+				actions.OptionApp:     ka,
+				actions.OptionName:    "",
+				actions.OptionPath:    "param-name",
+				actions.OptionValue:   "param-value",
+				actions.OptionEnvName: "default",
+				actions.OptionIndex:   0,
+			},
+		},
+		{
+			name:   "invalid arguments",
+			args:   []string{"param", "set"},
+			action: actionParamSet,
+			isErr:  true,
+		},
 	}
 
 	runTestCmd(t, cases)

pkg/env/params.go

@@ -24,6 +24,84 @@ import (
 	"github.com/spf13/afero"
 )
 
+// SetGlobalParams sets global params for an environment.
+func SetGlobalParams(a app.App, envName string, p param.Params) error {
+	if err := ensureEnvExists(a, envName); err != nil {
+		return err
+	}
+
+	path := envPath(a, envName, globalsFileName)
+
+	exists, err := afero.Exists(a.Fs(), path)
+	if err != nil {
+		return err
+	}
+
+	if !exists {
+		if err = afero.WriteFile(a.Fs(), path, []byte("{\n}"), app.DefaultFilePermissions); err != nil {
+			return err
+		}
+	}
+
+	text, err := afero.ReadFile(a.Fs(), path)
+	if err != nil {
+		return err
+	}
+
+	egs := params.NewEnvGlobalsSet()
+	updated, err := egs.Set(string(text), p)
+	if err != nil {
+		return err
+	}
+
+	err = afero.WriteFile(a.Fs(), path, []byte(updated), app.DefaultFilePermissions)
+	if err != nil {
+		return err
+	}
+
+	log.WithField("environment-name", envName).
+		Debug("Set global parameters")
+	return nil
+}
+
+// UnsetGlobalParams un-sets global param for an environment.
+func UnsetGlobalParams(a app.App, envName, paramName string) error {
+	if err := ensureEnvExists(a, envName); err != nil {
+		return err
+	}
+
+	path := envPath(a, envName, globalsFileName)
+
+	exists, err := afero.Exists(a.Fs(), path)
+	if err != nil {
+		return err
+	}
+
+	if !exists {
+		return nil
+	}
+
+	text, err := afero.ReadFile(a.Fs(), path)
+	if err != nil {
+		return err
+	}
+
+	egu := params.NewEnvGlobalsUnset()
+	updated, err := egu.Unset(paramName, string(text))
+	if err != nil {
+		return err
+	}
+
+	err = afero.WriteFile(a.Fs(), path, []byte(updated), app.DefaultFilePermissions)
+	if err != nil {
+		return err
+	}
+
+	log.WithField("environment-name", envName).
+		Debug("Set global parameters")
+	return nil
+}
+
 // SetParamsConfig is config items for setting environment params.
 type SetParamsConfig struct {
 	App app.App