feat: state values

This adds `values` to state files as proposed in #640. ```yaml values: - key1: val1 - defaults.yaml environments: default: - values: - environments/default.yaml production: - values: - environments/production.yaml ``` Resolves #640
roboll · Jun 4, 2019 · 26bd667 · 26bd667
1 parent 16f3d7f
commit 26bd667
Show file tree

Hide file tree

Showing 11 changed files with 286 additions and 74 deletions.
diff --git a/pkg/app/app_test.go b/pkg/app/app_test.go
@@ -901,8 +901,38 @@ bar: "bar1"
 }
 
 func TestVisitDesiredStatesWithReleasesFiltered_StateValueOverrides(t *testing.T) {
-	files := map[string]string{
-		"/path/to/helmfile.yaml": `
+	envTmplExpr := "{{ .Values.foo }}-{{ .Values.bar }}-{{ .Values.baz }}-{{ .Values.hoge }}-{{ .Values.fuga }}-{{ .Values.a | first | pluck \"b\" | first | first | pluck \"c\" | first }}"
+	relTmplExpr := "\"{{`{{ .Values.foo }}-{{ .Values.bar }}-{{ .Values.baz }}-{{ .Values.hoge }}-{{ .Values.fuga }}-{{ .Values.a | first | pluck \\\"b\\\" | first | first | pluck \\\"c\\\" | first }}`}}\""
+
+	testcases := []struct {
+		expr, env, expected string
+	}{
+		{
+			expr:     envTmplExpr,
+			env:      "default",
+			expected: "foo-bar_default-baz_override-hoge_set-fuga_set-C",
+		},
+		{
+			expr:     envTmplExpr,
+			env:      "production",
+			expected: "foo-bar_production-baz_override-hoge_set-fuga_set-C",
+		},
+		{
+			expr:     relTmplExpr,
+			env:      "default",
+			expected: "foo-bar_default-baz_override-hoge_set-fuga_set-C",
+		},
+		{
+			expr:     relTmplExpr,
+			env:      "production",
+			expected: "foo-bar_production-baz_override-hoge_set-fuga_set-C",
+		},
+	}
+	for i := range testcases {
+		testcase := testcases[i]
+		t.Run(fmt.Sprintf("case %d", i), func(t *testing.T) {
+			files := map[string]string{
+				"/path/to/helmfile.yaml": fmt.Sprintf(`
 # The top-level "values" are "base" values has inherited to state values with the lowest priority.
 # The lowest priority results in environment-specific values to override values defined in the base.
 values:
@@ -917,67 +947,80 @@ environments:
     - production.yaml
 ---
 releases:
-- name: {{ .Values.foo }}-{{ .Values.bar }}-{{ .Values.baz }}
-  chart: stable/zipkin
-`,
-		"/path/to/values.yaml": `
+- name: %s
+  chart: %s
+  namespace: %s
+`, testcase.expr, testcase.expr, testcase.expr),
+				"/path/to/values.yaml": `
 foo: foo
 bar: bar
 baz: baz
 hoge: hoge
-fuga; fuga
+fuga: fuga
+
+a: []
 `,
-		"/path/to/default.yaml": `
+				"/path/to/default.yaml": `
 bar: "bar_default"
 baz: "baz_default"
+
+a:
+- b: []
 `,
-		"/path/to/production.yaml": `
+				"/path/to/production.yaml": `
 bar: "bar_production"
 baz: "baz_production"
+
+a:
+- b: []
 `,
-		"/path/to/overrides.yaml": `
+				"/path/to/overrides.yaml": `
 baz: baz_override
 hoge: hoge_override
+
+a:
+- b:
+  - c: C
 `,
-	}
+			}
 
-	testcases := []struct {
-		env, expected string
-	}{
-		{env: "default", expected: "foo-bar_default-baz_override-hoge_set-fuga_set"},
-		{env: "production", expected: "foo-bar_production-baz_override-hoge_set-fuga_set"},
-	}
-	for _, testcase := range testcases {
-		actual := []string{}
+			actual := []state.ReleaseSpec{}
 
-		collectReleases := func(st *state.HelmState, helm helmexec.Interface) []error {
-			for _, r := range st.Releases {
-				actual = append(actual, r.Name)
+			collectReleases := func(st *state.HelmState, helm helmexec.Interface) []error {
+				for _, r := range st.Releases {
+					actual = append(actual, r)
+				}
+				return []error{}
 			}
-			return []error{}
-		}
-		app := appWithFs(&App{
-			KubeContext: "default",
-			Logger:      helmexec.NewLogger(os.Stderr, "debug"),
-			Reverse:     false,
-			Namespace:   "",
-			Selectors:   []string{},
-			Env:         testcase.env,
-			ValuesFiles: []string{"overrides.yaml"},
-			Set:         map[string]interface{}{"hoge": "hoge_set", "fuga": "fuga_set"},
-		}, files)
-		err := app.VisitDesiredStatesWithReleasesFiltered(
-			"helmfile.yaml", collectReleases,
-		)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if len(actual) != 1 {
-			t.Errorf("unexpected number of processed releases: expected=1, got=%d", len(actual))
-		}
-		if actual[0] != testcase.expected {
-			t.Errorf("unexpected result: expected=%s, got=%s", testcase.expected, actual[0])
-		}
+			app := appWithFs(&App{
+				KubeContext: "default",
+				Logger:      helmexec.NewLogger(os.Stderr, "debug"),
+				Reverse:     false,
+				Namespace:   "",
+				Selectors:   []string{},
+				Env:         testcase.env,
+				ValuesFiles: []string{"overrides.yaml"},
+				Set:         map[string]interface{}{"hoge": "hoge_set", "fuga": "fuga_set"},
+			}, files)
+			err := app.VisitDesiredStatesWithReleasesFiltered(
+				"helmfile.yaml", collectReleases,
+			)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if len(actual) != 1 {
+				t.Errorf("unexpected number of processed releases: expected=1, got=%d", len(actual))
+			}
+			if actual[0].Name != testcase.expected {
+				t.Errorf("unexpected name: expected=%s, got=%s", testcase.expected, actual[0].Name)
+			}
+			if actual[0].Chart != testcase.expected {
+				t.Errorf("unexpected chart: expected=%s, got=%s", testcase.expected, actual[0].Chart)
+			}
+			if actual[0].Namespace != testcase.expected {
+				t.Errorf("unexpected namespace: expected=%s, got=%s", testcase.expected, actual[0].Namespace)
+			}
+		})
 	}
 }
 

diff --git a/pkg/app/desired_state_file_loader.go b/pkg/app/desired_state_file_loader.go
@@ -83,6 +83,7 @@ func (ld *desiredStateLoader) Load(f string, opts LoadOpts) (*state.HelmState, e
 func (ld *desiredStateLoader) loadFile(inheritedEnv *environment.Environment, baseDir, file string, evaluateBases bool) (*state.HelmState, error) {
 	return ld.loadFileWithOverrides(inheritedEnv, nil, baseDir, file, evaluateBases)
 }
+
 func (ld *desiredStateLoader) loadFileWithOverrides(inheritedEnv, overrodeEnv *environment.Environment, baseDir, file string, evaluateBases bool) (*state.HelmState, error) {
 	var f string
 	if filepath.IsAbs(file) {

diff --git a/pkg/app/two_pass_renderer.go b/pkg/app/two_pass_renderer.go
@@ -19,8 +19,8 @@ func prependLineNumbers(text string) string {
 	return buf.String()
 }
 
-func (r *desiredStateLoader) renderEnvironment(firstPassEnv *environment.Environment, baseDir, filename string, content []byte) *environment.Environment {
-	tmplData := state.EnvironmentTemplateData{Environment: *firstPassEnv, Namespace: r.namespace}
+func (r *desiredStateLoader) renderPrestate(firstPassEnv *environment.Environment, baseDir, filename string, content []byte) (*environment.Environment, *state.HelmState) {
+	tmplData := state.EnvironmentTemplateData{*firstPassEnv, r.namespace, map[string]interface{}{}}
 	firstPassRenderer := tmpl.NewFirstPassRenderer(baseDir, tmplData)
 
 	// parse as much as we can, tolerate errors, this is a preparse
@@ -29,7 +29,7 @@ func (r *desiredStateLoader) renderEnvironment(firstPassEnv *environment.Environ
 		r.logger.Debugf("first-pass rendering input of \"%s\":\n%s", filename, prependLineNumbers(string(content)))
 		if yamlBuf == nil { // we have a template syntax error, let the second parse report
 			r.logger.Debugf("template syntax error: %v", err)
-			return firstPassEnv
+			return firstPassEnv, nil
 		}
 	}
 	yamlData := yamlBuf.String()
@@ -57,7 +57,8 @@ func (r *desiredStateLoader) renderEnvironment(firstPassEnv *environment.Environ
 	if prestate != nil {
 		firstPassEnv = &prestate.Env
 	}
-	return firstPassEnv
+
+	return firstPassEnv, prestate
 }
 
 type RenderOpts struct {
@@ -88,13 +89,18 @@ func (r *desiredStateLoader) twoPassRenderTemplateToYaml(inherited, overrode *en
 		r.logger.Debugf("first-pass uses: %v", initEnv)
 	}
 
-	renderedEnv := r.renderEnvironment(initEnv, baseDir, filename, content)
+	renderedEnv, prestate := r.renderPrestate(initEnv, baseDir, filename, content)
 
 	if r.logger != nil {
 		r.logger.Debugf("first-pass produced: %v", renderedEnv)
 	}
 
-	finalEnv, err := renderedEnv.Merge(overrode)
+	finalEnv, err := inherited.Merge(renderedEnv)
+	if err != nil {
+		return nil, err
+	}
+
+	finalEnv, err = finalEnv.Merge(overrode)
 	if err != nil {
 		return nil, err
 	}
@@ -103,7 +109,19 @@ func (r *desiredStateLoader) twoPassRenderTemplateToYaml(inherited, overrode *en
 		r.logger.Debugf("first-pass rendering result of \"%s\": %v", filename, *finalEnv)
 	}
 
-	tmplData := state.EnvironmentTemplateData{Environment: *finalEnv, Namespace: r.namespace}
+	vals := map[string]interface{}{}
+	if prestate != nil {
+		prestate.Env = *finalEnv
+		vals, err = prestate.Values()
+		if err != nil {
+			return nil, err
+		}
+	}
+	if prestate != nil {
+		r.logger.Debugf("vals:\n%v\ndefaultVals:%v", vals, prestate.DefaultValues)
+	}
+
+	tmplData := state.EnvironmentTemplateData{*finalEnv, r.namespace, vals}
 	secondPassRenderer := tmpl.NewFileRenderer(r.readFile, baseDir, tmplData)
 	yamlBuf, err := secondPassRenderer.RenderTemplateContentToBuffer(content)
 	if err != nil {

diff --git a/pkg/environment/environment.go b/pkg/environment/environment.go
@@ -7,28 +7,44 @@ import (
 )
 
 type Environment struct {
-	Name   string
-	Values map[string]interface{}
+	Name     string
+	Values   map[string]interface{}
+	Defaults map[string]interface{}
 }
 
 var EmptyEnvironment Environment
 
 func (e Environment) DeepCopy() Environment {
-	bytes, err := yaml.Marshal(e.Values)
+	valuesBytes, err := yaml.Marshal(e.Values)
 	if err != nil {
 		panic(err)
 	}
 	var values map[string]interface{}
-	if err := yaml.Unmarshal(bytes, &values); err != nil {
+	if err := yaml.Unmarshal(valuesBytes, &values); err != nil {
 		panic(err)
 	}
 	values, err = maputil.CastKeysToStrings(values)
 	if err != nil {
 		panic(err)
 	}
+
+	defaultsBytes, err := yaml.Marshal(e.Defaults)
+	if err != nil {
+		panic(err)
+	}
+	var defaults map[string]interface{}
+	if err := yaml.Unmarshal(defaultsBytes, &defaults); err != nil {
+		panic(err)
+	}
+	defaults, err = maputil.CastKeysToStrings(defaults)
+	if err != nil {
+		panic(err)
+	}
+
 	return Environment{
-		Name:   e.Name,
-		Values: values,
+		Name:     e.Name,
+		Values:   values,
+		Defaults: defaults,
 	}
 }
 

diff --git a/pkg/maputil/maputil_test.go b/pkg/maputil/maputil_test.go
@@ -0,0 +1,61 @@
+package maputil
+
+import "testing"
+
+func TestMapUtil_StrKeys(t *testing.T) {
+	m := map[string]interface{}{
+		"a": []interface{}{
+			map[string]interface{}{
+				"b": []interface{}{
+					map[string]interface{}{
+						"c": "C",
+					},
+				},
+			},
+		},
+	}
+
+	r, err := CastKeysToStrings(m)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	a := r["a"].([]interface{})
+	a0 := a[0].(map[string]interface{})
+	b := a0["b"].([]interface{})
+	b0 := b[0].(map[string]interface{})
+	c := b0["c"]
+
+	if c != "C" {
+		t.Errorf("unexpected c: expected=C, got=%s", c)
+	}
+}
+
+func TestMapUtil_IFKeys(t *testing.T) {
+	m := map[interface{}]interface{}{
+		"a": []interface{}{
+			map[interface{}]interface{}{
+				"b": []interface{}{
+					map[interface{}]interface{}{
+						"c": "C",
+					},
+				},
+			},
+		},
+	}
+
+	r, err := CastKeysToStrings(m)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	a := r["a"].([]interface{})
+	a0 := a[0].(map[string]interface{})
+	b := a0["b"].([]interface{})
+	b0 := b[0].(map[string]interface{})
+	c := b0["c"]
+
+	if c != "C" {
+		t.Errorf("unexpected c: expected=C, got=%s", c)
+	}
+}