diff --git a/actions/param_delete.go b/actions/param_delete.go
index ca0821d7842ce0d261da378d30211d78eafc4da5..decec6f7afcc042951d5cd8519cd34355b41eaff 100644
--- a/actions/param_delete.go
+++ b/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, ".")
diff --git a/actions/param_delete_test.go b/actions/param_delete_test.go
index c2fe01e7222ba304495b727c24d4ad9d40c669bc..ffd7cc2a5d7872e1c1013dee49232e3b7f927698 100644
--- a/actions/param_delete_test.go
+++ b/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)
+ })
+}
diff --git a/actions/param_set.go b/actions/param_set.go
index 24d8c9b6ae2935446a8aefb277fc38dcf164d38d..1b694745878b473d7a803e2c25e275626017d5a7 100644
--- a/actions/param_set.go
+++ b/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)
+}
diff --git a/actions/param_set_test.go b/actions/param_set_test.go
index c32163de97645c7c99631c872975eceab261a4b8..14c6be633d650f78e4d3620eb7e727bd5e6defa7 100644
--- a/actions/param_set_test.go
+++ b/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)
+ })
+}
diff --git a/cmd/param_delete.go b/cmd/param_delete.go
index d09db6d232b2b248f81e5af39c2b5c8020fb7100..a336419676b2b5bebb2698567fd219db473e27db 100644
--- a/cmd/param_delete.go
+++ b/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),
}
diff --git a/cmd/param_set.go b/cmd/param_set.go
index 1a715f1ecc39bb1d8d923581ecca0c4a255a1f8b..73a59b349af3bd69db95fabb22a26c71b5e53224 100644
--- a/cmd/param_set.go
+++ b/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),
}
diff --git a/cmd/param_set_test.go b/cmd/param_set_test.go
index c002e404e9b50272678d8f8d7c39b011ab39e134..66db1ac92369e86e0de35423ce482882c2d833d2 100644
--- a/cmd/param_set_test.go
+++ b/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)
diff --git a/component/jsonnet_test.go b/component/jsonnet_test.go
index e2c798fb4ab131bd5318e743e08a1dcd5a25404c..56a2fe5e881ca220450deaad4ddb668865b35e36 100644
--- a/component/jsonnet_test.go
+++ b/component/jsonnet_test.go
@@ -18,6 +18,7 @@ package component
import (
"testing"
+ "github.com/ksonnet/ksonnet/metadata/app"
"github.com/ksonnet/ksonnet/metadata/app/mocks"
"github.com/ksonnet/ksonnet/pkg/util/test"
"github.com/spf13/afero"
@@ -80,10 +81,20 @@ func TestJsonnet_Name(t *testing.T) {
func TestJsonnet_Objects(t *testing.T) {
withAppOsFs(t, "/app", func(a *mocks.App, fs afero.Fs) {
+ env := &app.EnvironmentSpec{
+ Destination: &app.EnvironmentDestinationSpec{
+ Namespace: "default",
+ Server: "http://example.com",
+ },
+ }
+
+ a.On("Environment", "default").Return(env, nil)
+
files := []string{"guestbook-ui.jsonnet", "params.libsonnet"}
for _, file := range files {
test.StageFile(t, fs, "guestbook/"+file, "/app/components/"+file)
}
+ fs.Mkdir("/app/vendor", 0755)
files = []string{"k.libsonnet", "k8s.libsonnet"}
for _, file := range files {
diff --git a/docs/cli-reference/ks_param_delete.md b/docs/cli-reference/ks_param_delete.md
index 4d7219a1c2c3edcbec899a5fb6d7f5a3af634c1c..259b06a839fd57581282eab8890e94c7e711d7df 100644
--- a/docs/cli-reference/ks_param_delete.md
+++ b/docs/cli-reference/ks_param_delete.md
@@ -17,7 +17,7 @@ The `delete` command deletes component or environment parameters.
```
-ks param delete <component-name> <param-key> [flags]
+ks param delete [component-name] <param-key> [flags]
```
### Examples
diff --git a/pkg/env/params.go b/pkg/env/params.go
index dc3a2485a1197a908e4b72666c8423f130d2791f..9b9fc8f24a0e5f8642b23dadaa77a3cc7d24bcbc 100644
--- a/pkg/env/params.go
+++ b/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
diff --git a/pkg/env/params_test.go b/pkg/env/params_test.go
index e57684149b3d7bf533ab0515e70d0103cfb6b240..4a9c5a7c3f837fa90ccfe066bae4611fe4cfb16b 100644
--- a/pkg/env/params_test.go
+++ b/pkg/env/params_test.go
@@ -25,6 +25,28 @@ import (
"github.com/stretchr/testify/require"
)
+func TestSetGlobalParams(t *testing.T) {
+ withEnv(t, func(appMock *mocks.App, fs afero.Fs) {
+ p := params.Params{
+ "foo": "bar",
+ }
+
+ err := SetGlobalParams(appMock, "env1", p)
+ require.NoError(t, err)
+
+ compareOutput(t, fs, "add-global.libsonnet", "/environments/env1/globals.libsonnet")
+ })
+}
+
+func TestUnsetGlobalParams(t *testing.T) {
+ withEnv(t, func(appMock *mocks.App, fs afero.Fs) {
+ err := UnsetGlobalParams(appMock, "env1", "foo")
+ require.NoError(t, err)
+
+ compareOutput(t, fs, "remove-global.libsonnet", "/environments/env1/globals.libsonnet")
+ })
+}
+
func TestSetParams(t *testing.T) {
withEnv(t, func(appMock *mocks.App, fs afero.Fs) {
config := SetParamsConfig{
diff --git a/pkg/env/testdata/add-global.libsonnet b/pkg/env/testdata/add-global.libsonnet
new file mode 100644
index 0000000000000000000000000000000000000000..5f11c2bea4daa74576ee25b2c9709e7e1ef236ef
--- /dev/null
+++ b/pkg/env/testdata/add-global.libsonnet
@@ -0,0 +1,3 @@
+{
+ foo: "bar",
+}
\ No newline at end of file
diff --git a/pkg/env/testdata/globals.libsonnet b/pkg/env/testdata/globals.libsonnet
new file mode 100644
index 0000000000000000000000000000000000000000..5f11c2bea4daa74576ee25b2c9709e7e1ef236ef
--- /dev/null
+++ b/pkg/env/testdata/globals.libsonnet
@@ -0,0 +1,3 @@
+{
+ foo: "bar",
+}
\ No newline at end of file
diff --git a/pkg/env/testdata/remove-global.libsonnet b/pkg/env/testdata/remove-global.libsonnet
new file mode 100644
index 0000000000000000000000000000000000000000..7a73a41bfdf76d6f793007240d80983a52f15f97
--- /dev/null
+++ b/pkg/env/testdata/remove-global.libsonnet
@@ -0,0 +1,2 @@
+{
+}
\ No newline at end of file
diff --git a/pkg/env/util_test.go b/pkg/env/util_test.go
index f5a65ad250c5ff0db28f7e302720721a6cc35eae..521a5a466aba114f9969502fd3a88d96b01558f8 100644
--- a/pkg/env/util_test.go
+++ b/pkg/env/util_test.go
@@ -66,6 +66,9 @@ func withEnv(t *testing.T, fn func(*mocks.App, afero.Fs)) {
paramsPath := filepath.Join(path, "params.libsonnet")
stageFile(t, fs, "params.libsonnet", paramsPath)
+
+ globalsPath := filepath.Join(path, "globals.libsonnet")
+ stageFile(t, fs, "globals.libsonnet", globalsPath)
}
componentParamsPath := filepath.Join("/", "components", "params.libsonnet")
diff --git a/pkg/params/env_globals_set.go b/pkg/params/env_globals_set.go
new file mode 100644
index 0000000000000000000000000000000000000000..a204be3c884cfb2166f41e3e58d7b8494c160cdb
--- /dev/null
+++ b/pkg/params/env_globals_set.go
@@ -0,0 +1,87 @@
+// Copyright 2018 The ksonnet 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 params
+
+import (
+ "bytes"
+
+ "github.com/ksonnet/ksonnet-lib/ksonnet-gen/astext"
+ nm "github.com/ksonnet/ksonnet-lib/ksonnet-gen/nodemaker"
+ "github.com/ksonnet/ksonnet/metadata/params"
+ "github.com/ksonnet/ksonnet/pkg/util/jsonnet"
+ "github.com/pkg/errors"
+ "github.com/sirupsen/logrus"
+)
+
+// EnvGlobalsSet sets environment globals.
+type EnvGlobalsSet struct {
+}
+
+// NewEnvGlobalsSet creates an instance of EnvGlobalsSet.
+func NewEnvGlobalsSet() *EnvGlobalsSet {
+ egs := &EnvGlobalsSet{}
+ return egs
+}
+
+// Set sets params in environment globals files.
+func (egs *EnvGlobalsSet) Set(snippet string, p params.Params) (string, error) {
+ logger := logrus.WithFields(logrus.Fields{})
+ logger.Info("setting environment globals")
+
+ n, err := jsonnet.ParseNode("globals.libsonnet", snippet)
+ if err != nil {
+ return "", err
+ }
+
+ obj, err := componentParams(n, "")
+ if err != nil {
+ return "", err
+ }
+
+ if err = egs.setParams(obj, p); err != nil {
+ return "", errors.Wrap(err, "delete entry")
+ }
+
+ // root node should be a local if not, return an error
+ var buf bytes.Buffer
+ if err = jsonnetPrinterFn(&buf, n); err != nil {
+ return "", errors.Wrap(err, "unable to update snippet")
+ }
+
+ return buf.String(), nil
+}
+
+func (egs *EnvGlobalsSet) setParams(obj *astext.Object, p params.Params) error {
+ for key := range p {
+ decoded, err := DecodeValue(p[key])
+ if err != nil {
+ return err
+ }
+
+ value, err := nm.ValueToNoder(decoded)
+ if err != nil {
+ return err
+ }
+
+ path := []string{key}
+ if err = jsonnetSetFn(obj, path, value.Node()); err != nil {
+ return err
+ }
+
+ }
+
+ return nil
+}
diff --git a/pkg/params/env_globals_set_test.go b/pkg/params/env_globals_set_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..323f1876765423003bc01ccec931681943a67271
--- /dev/null
+++ b/pkg/params/env_globals_set_test.go
@@ -0,0 +1,57 @@
+// Copyright 2018 The ksonnet 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 params
+
+import (
+ "path/filepath"
+ "testing"
+
+ "github.com/ksonnet/ksonnet/metadata/params"
+ "github.com/ksonnet/ksonnet/pkg/util/test"
+ "github.com/stretchr/testify/require"
+)
+
+func TestEnvGlobalsSet(t *testing.T) {
+ cases := []struct {
+ name string
+ input string
+ output string
+ params params.Params
+ }{
+ {
+ name: "in general",
+ input: filepath.Join("env", "globals", "set-global", "in.libsonnet"),
+ output: filepath.Join("env", "globals", "set-global", "out.libsonnet"),
+ params: params.Params{
+ "group": "dev",
+ },
+ },
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ snippet := test.ReadTestData(t, tc.input)
+
+ egs := NewEnvGlobalsSet()
+
+ got, err := egs.Set(snippet, tc.params)
+ require.NoError(t, err)
+
+ expected := test.ReadTestData(t, tc.output)
+ require.Equal(t, expected, got)
+ })
+ }
+}
diff --git a/pkg/params/env_globals_unset.go b/pkg/params/env_globals_unset.go
new file mode 100644
index 0000000000000000000000000000000000000000..3e88a136abe588506619a8a1a3d26b058042b552
--- /dev/null
+++ b/pkg/params/env_globals_unset.go
@@ -0,0 +1,89 @@
+// Copyright 2018 The ksonnet 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 params
+
+import (
+ "bytes"
+
+ "github.com/ksonnet/ksonnet-lib/ksonnet-gen/astext"
+ "github.com/ksonnet/ksonnet/pkg/util/jsonnet"
+ "github.com/pkg/errors"
+ "github.com/sirupsen/logrus"
+)
+
+// EnvGlobalsUnset un-sets global environment params.
+type EnvGlobalsUnset struct {
+}
+
+// NewEnvGlobalsUnset creates an instance of EnvGlobalsUnset.
+func NewEnvGlobalsUnset() *EnvGlobalsUnset {
+ egu := &EnvGlobalsUnset{}
+ return egu
+}
+
+// Unset un-sets globals.
+func (epu *EnvGlobalsUnset) Unset(paramName, snippet string) (string, error) {
+ if paramName == "" {
+ return "", errors.New("global name was blank")
+ }
+
+ logger := logrus.WithFields(logrus.Fields{})
+ logger.WithField("name", paramName).Info("removing environment global")
+
+ n, err := jsonnet.ParseNode("params.libsonnet", snippet)
+ if err != nil {
+ return "", err
+ }
+
+ obj, err := componentParams(n, "")
+ if err != nil {
+ return "", err
+ }
+
+ if err = epu.unsetEntry(obj, paramName); err != nil {
+ return "", errors.Wrap(err, "delete entry")
+ }
+
+ var buf bytes.Buffer
+ if err = jsonnetPrinterFn(&buf, n); err != nil {
+ return "", errors.Wrap(err, "unable to update snippet")
+ }
+
+ return buf.String(), nil
+}
+
+func (epu *EnvGlobalsUnset) unsetEntry(obj *astext.Object, paramName string) error {
+ match := -1
+
+ var id string
+ var err error
+ for i := range obj.Fields {
+ id, err = jsonnet.FieldID(obj.Fields[i])
+ if err != nil {
+ return err
+ }
+
+ if id == paramName {
+ match = i
+ }
+ }
+
+ if match >= 0 {
+ obj.Fields = append(obj.Fields[:match], obj.Fields[match+1:]...)
+ }
+
+ return nil
+}
diff --git a/pkg/params/env_globals_unset_test.go b/pkg/params/env_globals_unset_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..379899b1ffc9b56d434ec19e32cd0c3e7c206dcd
--- /dev/null
+++ b/pkg/params/env_globals_unset_test.go
@@ -0,0 +1,54 @@
+// Copyright 2018 The ksonnet 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 params
+
+import (
+ "path/filepath"
+ "testing"
+
+ "github.com/ksonnet/ksonnet/pkg/util/test"
+ "github.com/stretchr/testify/require"
+)
+
+func TestEnvGlobalsUnset(t *testing.T) {
+ cases := []struct {
+ name string
+ input string
+ output string
+ paramName string
+ }{
+ {
+ name: "in general",
+ input: filepath.Join("env", "globals", "unset-global", "in.libsonnet"),
+ output: filepath.Join("env", "globals", "unset-global", "out.libsonnet"),
+ paramName: "group",
+ },
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ snippet := test.ReadTestData(t, tc.input)
+
+ egu := NewEnvGlobalsUnset()
+
+ got, err := egu.Unset(tc.paramName, snippet)
+ require.NoError(t, err)
+
+ expected := test.ReadTestData(t, tc.output)
+ require.Equal(t, expected, got)
+ })
+ }
+}
diff --git a/pkg/params/params.go b/pkg/params/params.go
index f90562341495353c188a89c6a9b0c4bbdd9a17a3..e1fa31e8ed919e54663c56949815d14c511357b4 100644
--- a/pkg/params/params.go
+++ b/pkg/params/params.go
@@ -145,7 +145,6 @@ func ToMap(componentName, src, root string) (map[string]interface{}, error) {
return nil, err
}
- // child, err := jsonnetFindObjectFn(obj, path)
m, err := convertObjectToMapFn(componentObject)
if err != nil {
return nil, err
@@ -294,15 +293,18 @@ func mergeMaps(m1 map[string]interface{}, m2 map[string]interface{}, path []stri
func componentParams(node ast.Node, componentName string) (*astext.Object, error) {
switch t := node.(type) {
default:
- return nil, errors.New("unknown params format")
+ return nil, errors.Errorf("unknown params format: %T", t)
case *astext.Object:
- path := []string{"components", componentName}
- if componentName == "" {
- // NOTE: this is module params, so return global
- path = []string{"global"}
- }
+ if len(componentName) > 0 {
+ path := []string{"components", componentName}
+ if componentName == "" {
+ // NOTE: this is module params, so return global
+ path = []string{"global"}
+ }
- return jsonnetFindObjectFn(t, path)
+ return jsonnetFindObjectFn(t, path)
+ }
+ return t, nil
case *ast.Local:
root, ok := node.(*ast.Local)
if !ok {
diff --git a/pkg/params/params_test.go b/pkg/params/params_test.go
index bf6f7b1ff531fc81dd3aa6d21c6d34f2a812a75e..7b13bc4870b6c58d2a8969b61de365a61794cfa3 100644
--- a/pkg/params/params_test.go
+++ b/pkg/params/params_test.go
@@ -379,10 +379,10 @@ func TestToMap(t *testing.T) {
isErr: true,
},
{
- name: "unable to find object in params",
+ name: "unable to convert object to map",
paramsData: test.ReadTestData(t, "nested-params.libsonnet"),
init: func() {
- jsonnetFindObjectFn = func(*astext.Object, []string) (*astext.Object, error) {
+ convertObjectToMapFn = func(*astext.Object) (map[string]interface{}, error) {
return nil, errors.New("failed")
}
},
diff --git a/pkg/params/testdata/env/globals/set-global/in.libsonnet b/pkg/params/testdata/env/globals/set-global/in.libsonnet
new file mode 100644
index 0000000000000000000000000000000000000000..9e26dfeeb6e641a33dae4961196235bdb965b21b
--- /dev/null
+++ b/pkg/params/testdata/env/globals/set-global/in.libsonnet
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/pkg/params/testdata/env/globals/set-global/out.libsonnet b/pkg/params/testdata/env/globals/set-global/out.libsonnet
new file mode 100644
index 0000000000000000000000000000000000000000..48ec06e35883957a4a56d9012bd4d3b95173f044
--- /dev/null
+++ b/pkg/params/testdata/env/globals/set-global/out.libsonnet
@@ -0,0 +1,3 @@
+{
+ group: "dev",
+}
\ No newline at end of file
diff --git a/pkg/params/testdata/env/globals/unset-global/in.libsonnet b/pkg/params/testdata/env/globals/unset-global/in.libsonnet
new file mode 100644
index 0000000000000000000000000000000000000000..48ec06e35883957a4a56d9012bd4d3b95173f044
--- /dev/null
+++ b/pkg/params/testdata/env/globals/unset-global/in.libsonnet
@@ -0,0 +1,3 @@
+{
+ group: "dev",
+}
\ No newline at end of file
diff --git a/pkg/params/testdata/env/globals/unset-global/out.libsonnet b/pkg/params/testdata/env/globals/unset-global/out.libsonnet
new file mode 100644
index 0000000000000000000000000000000000000000..7a73a41bfdf76d6f793007240d80983a52f15f97
--- /dev/null
+++ b/pkg/params/testdata/env/globals/unset-global/out.libsonnet
@@ -0,0 +1,2 @@
+{
+}
\ No newline at end of file