feat: Environment and Environment Values

Gopkg.toml

@@ -9,3 +9,7 @@
 [prune]
   go-tests = true
   unused-packages = true
+
+[[constraint]]
+  name = "github.com/imdario/mergo"
+  version = "0.3.4"

README.md

@@ -371,6 +371,70 @@ proxy:
   scheme: {{ env "SCHEME" | default "https" }}
 ```
 
+## Environment
+
+When you want to customize the contents of `helmfile.yaml` or `values.yaml` files per environment, use this feature.
+
+You can define as many environments as you want under `environments` in `helmfile.yaml`.
+
+The environment name defaults to `default`, that is, `helmfile sync` implies the `default` environment.
+The selected environment name can be referenced from `helmfile.yaml` and `values.yaml.gotmpl` by `{{ .Environment.Name }}`.
+
+If you want to specify a non-default environment, provide a `--environment NAME` flag to `helmfile` like `helmfile --environment production sync`.
+
+The below example shows how to define a production-only release:
+
+```yaml
+environments:
+  default:
+  production:
+
+releases:
+
+{{ if (eq .Environment.Name "production" }}
+- name: newrelic-agent
+  # snip
+{{ end }}
+- name: myapp
+  # snip  
+```
+
+## Environment Values
+
+Environment Values allows you to inject a set of values specific to the selected environment, into values.yaml templates.
+Use it to inject common values from the environment to multiple values files, to make your configuration DRY.
+
+Suppose you have three files `helmfile.yaml`, `production.yaml` and `values.yaml.gotmpl`:
+
+`helmfile.yaml`
+
+```yaml
+environments:
+  production:
+    values:
+    - production.yaml
+
+releases:
+- name: myapp
+  values:
+  - values.yaml.gotmpl
+```
+
+`production.yaml`
+
+```yaml
+domain: prod.example.com
+```
+
+`values.yaml.gotmpl`
+
+```yaml
+domain: {{ .Environment.Values.domain | default "dev.example.com" }}
+```
+
+`helmfile sync` installs `myapp` with the value `domain=dev.example.com`,
+whereas `helmfile --environment production sync` installs the app with the value `domain=production.example.com`.
+
 ## Separating helmfile.yaml into multiple independent files
 
 Once your `helmfile.yaml` got to contain too many releases,

environment/environment.go

@@ -0,0 +1,8 @@
+package environment
+
+type Environment struct {
+	Name   string
+	Values map[string]interface{}
+}
+
+var EmptyEnvironment Environment

main.go

@@ -12,6 +12,7 @@ import (
 	"os/exec"
 
 	"github.com/roboll/helmfile/args"
+	"github.com/roboll/helmfile/environment"
 	"github.com/roboll/helmfile/helmexec"
 	"github.com/roboll/helmfile/state"
 	"github.com/roboll/helmfile/tmpl"
@@ -68,6 +69,10 @@ func main() {
 			Name:  "file, f",
 			Usage: "load config from file or directory. defaults to `helmfile.yaml` or `helmfile.d`(means `helmfile.d/*.yaml`) in this preference",
 		},
+		cli.StringFlag{
+			Name:  "environment, e",
+			Usage: "specify the environment name. defaults to `default`",
+		},
 		cli.BoolFlag{
 			Name:  "quiet, q",
 			Usage: "Silence output. Equivalent to log-level warn",
@@ -463,18 +468,24 @@ func findAndIterateOverDesiredStatesUsingFlags(c *cli.Context, converge func(*st
 	namespace := c.GlobalString("namespace")
 	selectors := c.GlobalStringSlice("selector")
 	logger := c.App.Metadata["logger"].(*zap.SugaredLogger)
-	return findAndIterateOverDesiredStates(fileOrDir, converge, kubeContext, namespace, selectors, logger)
+
+	env := c.GlobalString("environment")
+	if env == "" {
+		env = state.DefaultEnv
+	}
+
+	return findAndIterateOverDesiredStates(fileOrDir, converge, kubeContext, namespace, selectors, env, logger)
 }
 
-func findAndIterateOverDesiredStates(fileOrDir string, converge func(*state.HelmState, helmexec.Interface) []error, kubeContext, namespace string, selectors []string, logger *zap.SugaredLogger) error {
+func findAndIterateOverDesiredStates(fileOrDir string, converge func(*state.HelmState, helmexec.Interface) []error, kubeContext, namespace string, selectors []string, env string, logger *zap.SugaredLogger) error {
 	desiredStateFiles, err := findDesiredStateFiles(fileOrDir)
 	if err != nil {
 		return err
 	}
 	allSelectorNotMatched := true
 	for _, f := range desiredStateFiles {
 		logger.Debugf("Processing %s", f)
-		yamlBuf, err := tmpl.NewFileRenderer(ioutil.ReadFile, "").RenderTemplateFileToBuffer(f)
+		yamlBuf, err := tmpl.NewFileRenderer(ioutil.ReadFile, "", environment.EmptyEnvironment).RenderTemplateFileToBuffer(f)
 		if err != nil {
 			return err
 		}
@@ -484,6 +495,7 @@ func findAndIterateOverDesiredStates(fileOrDir string, converge func(*state.Helm
 			kubeContext,
 			namespace,
 			selectors,
+			env,
 			logger,
 		)
 		if err != nil {
@@ -498,7 +510,7 @@ func findAndIterateOverDesiredStates(fileOrDir string, converge func(*state.Helm
 				}
 				sort.Strings(matches)
 				for _, m := range matches {
-					if err := findAndIterateOverDesiredStates(m, converge, kubeContext, namespace, selectors, logger); err != nil {
+					if err := findAndIterateOverDesiredStates(m, converge, kubeContext, namespace, selectors, env, logger); err != nil {
 						return fmt.Errorf("failed processing %s: %v", globPattern, err)
 					}
 				}
@@ -579,8 +591,8 @@ func directoryExistsAt(path string) bool {
 	return err == nil && fileInfo.Mode().IsDir()
 }
 
-func loadDesiredStateFromFile(yaml []byte, file string, kubeContext, namespace string, labels []string, logger *zap.SugaredLogger) (*state.HelmState, helmexec.Interface, bool, error) {
-	st, err := state.CreateFromYaml(yaml, file, logger)
+func loadDesiredStateFromFile(yaml []byte, file string, kubeContext, namespace string, labels []string, env string, logger *zap.SugaredLogger) (*state.HelmState, helmexec.Interface, bool, error) {
+	st, err := state.CreateFromYaml(yaml, file, env, logger)
 	if err != nil {
 		return nil, nil, false, fmt.Errorf("failed to read %s: %v", file, err)
 	}

main_test.go

@@ -16,7 +16,7 @@ func TestReadFromYaml_DuplicateReleaseName(t *testing.T) {
   labels:
     stage: post
 `)
-	_, _, _, err := loadDesiredStateFromFile(yamlContent, yamlFile, "default", "default", []string{}, logger)
+	_, _, _, err := loadDesiredStateFromFile(yamlContent, yamlFile, "default", "default", []string{}, "default", logger)
 	if err == nil {
 		t.Error("error expected but not happened")
 	}

state/create.go

@@ -0,0 +1,71 @@
+package state
+
+import (
+	"fmt"
+	"github.com/imdario/mergo"
+	"github.com/roboll/helmfile/environment"
+	"github.com/roboll/helmfile/valuesfile"
+	"go.uber.org/zap"
+	"gopkg.in/yaml.v2"
+	"io/ioutil"
+	"path/filepath"
+)
+
+func CreateFromYaml(content []byte, file string, env string, logger *zap.SugaredLogger) (*HelmState, error) {
+	return createFromYamlWithFileReader(content, file, env, logger, ioutil.ReadFile)
+}
+
+func createFromYamlWithFileReader(content []byte, file string, env string, logger *zap.SugaredLogger, readFile func(string) ([]byte, error)) (*HelmState, error) {
+	var state HelmState
+
+	state.basePath, _ = filepath.Abs(filepath.Dir(file))
+	if err := yaml.UnmarshalStrict(content, &state); err != nil {
+		return nil, err
+	}
+	state.FilePath = file
+
+	if len(state.DeprecatedReleases) > 0 {
+		if len(state.Releases) > 0 {
+			return nil, fmt.Errorf("failed to parse %s: you can't specify both `charts` and `releases` sections", file)
+		}
+		state.Releases = state.DeprecatedReleases
+		state.DeprecatedReleases = []ReleaseSpec{}
+	}
+
+	state.logger = logger
+
+	e, err := state.loadEnv(env, readFile)
+	if err != nil {
+		return nil, err
+	}
+	state.env = *e
+
+	state.readFile = readFile
+
+	return &state, nil
+}
+
+func (state *HelmState) loadEnv(name string, readFile func(string) ([]byte, error)) (*environment.Environment, error) {
+	envVals := map[string]interface{}{}
+	envSpec, ok := state.Environments[name]
+	if ok {
+		r := valuesfile.NewRenderer(readFile, state.basePath, environment.EmptyEnvironment)
+		for _, envvalFile := range envSpec.Values {
+			bytes, err := r.RenderToBytes(filepath.Join(state.basePath, envvalFile))
+			if err != nil {
+				return nil, fmt.Errorf("failed to load environment values file \"%s\": %v", envvalFile, err)
+			}
+			m := map[string]interface{}{}
+			if err := yaml.Unmarshal(bytes, &m); err != nil {
+				return nil, fmt.Errorf("failed to load environment values file \"%s\": %v", envvalFile, err)
+			}
+			if err := mergo.Merge(&envVals, &m, mergo.WithOverride); err != nil {
+				return nil, fmt.Errorf("failed to load \"%s\": %v", envvalFile, err)
+			}
+		}
+	} else if name != DefaultEnv {
+		return nil, fmt.Errorf("environment \"%s\" is not defined in \"%s\"", name, state.FilePath)
+	}
+
+	return &environment.Environment{Name: name, Values: envVals}, nil
+}