Merge pull request #147 from wata727/support_environment_variables

Support variables from environment variables

Author: wata727

evaluator/variable.go

@@ -1,7 +1,9 @@
 package evaluator
 
 import (
+	"os"
 	"reflect"
+	"strings"
 
 	"fmt"
 
@@ -31,13 +33,19 @@ func detectVariables(templates map[string]*hclast.File, varfile []*hclast.File)
 		if err := hcl.DecodeObject(&variables, template.Node.(*hclast.ObjectList).Filter("variable")); err != nil {
 			return nil, err
 		}
+		envVars, err := decodeEnvVars(variables)
+		if err != nil {
+			return nil, err
+		}
 		tfvars, err := decodeTFVars(varfile)
 		if err != nil {
 			return nil, err
 		}
 
 		for _, v := range variables {
-			if overriddenVariable(v, tfvars); v.Default == nil {
+			overriddenVariable(v, envVars)
+			overriddenVariable(v, tfvars)
+			if v.Default == nil {
 				continue
 			}
 			varName := "var." + v.Name
@@ -61,6 +69,44 @@ func decodeTFVars(varfile []*hclast.File) ([]map[string]interface{}, error) {
 	return result, nil
 }
 
+func decodeEnvVars(variables []*hclVariable) ([]map[string]interface{}, error) {
+	result := []map[string]interface{}{}
+
+	for _, e := range os.Environ() {
+		idx := strings.Index(e, "=")
+		envKey := e[:idx]
+		envVal := e[idx+1:]
+
+		if strings.HasPrefix(envKey, "TF_VAR_") {
+			varName := strings.Replace(envKey, "TF_VAR_", "", 1)
+			for _, v := range variables {
+				if v.Name != varName {
+					continue
+				}
+
+				var varType string
+				if v.DeclaredType == "" {
+					varType = deduceType(v.Default)
+				} else {
+					varType = v.DeclaredType
+				}
+
+				if varType == HCL_STRING_VARTYPE {
+					envVal = fmt.Sprintf("\"%s\"", envVal)
+				}
+
+				var r map[string]interface{}
+				if err := hcl.Decode(&r, fmt.Sprintf("%s = %s", varName, envVal)); err != nil {
+					return nil, err
+				}
+				result = append(result, r)
+			}
+		}
+	}
+
+	return result, nil
+}
+
 func overriddenVariable(v *hclVariable, tfvars []map[string]interface{}) {
 	for _, vars := range tfvars {
 		val := vars[v.Name]
@@ -83,8 +129,13 @@ func overriddenVariable(v *hclVariable, tfvars []map[string]interface{}) {
 	}
 }
 
-func parseVariable(val interface{}, varType string) hilast.Variable {
-	// varType is overwrite invariably. Because, happen panic when used in incorrect type
+func deduceType(val interface{}) string {
+	if val == nil {
+		return HCL_STRING_VARTYPE
+	}
+
+	var varType string
+
 	switch reflect.TypeOf(val).Kind() {
 	case reflect.String:
 		varType = HCL_STRING_VARTYPE
@@ -96,6 +147,13 @@ func parseVariable(val interface{}, varType string) hilast.Variable {
 		varType = HCL_STRING_VARTYPE
 	}
 
+	return varType
+}
+
+func parseVariable(val interface{}, varType string) hilast.Variable {
+	// varType is overwrite invariably. Because, happen panic when used in incorrect type
+	varType = deduceType(val)
+
 	var hilVar hilast.Variable
 	switch varType {
 	case HCL_STRING_VARTYPE:

evaluator/variable_test.go

@@ -1,6 +1,7 @@
 package evaluator
 
 import (
+	"os"
 	"reflect"
 	"testing"
 
@@ -222,6 +223,91 @@ complex = {
 	}
 }
 
+func TestDecodeEnvVars(t *testing.T) {
+	cases := []struct {
+		Name   string
+		Vars   []*hclVariable
+		Env    map[string]string
+		Result []map[string]interface{}
+	}{
+		{
+			Name: "Decode string",
+			Vars: []*hclVariable{
+				{
+					Name: "hoge",
+				},
+			},
+			Env: map[string]string{
+				"TF_VAR_hoge": "fuga",
+			},
+			Result: []map[string]interface{}{
+				{
+					"hoge": "fuga",
+				},
+			},
+		},
+		{
+			Name: "Decode list",
+			Vars: []*hclVariable{
+				{
+					Name:         "hoge",
+					DeclaredType: "list",
+				},
+			},
+			Env: map[string]string{
+				"TF_VAR_hoge": "[\"bar\", \"baz\"]",
+			},
+			Result: []map[string]interface{}{
+				{
+					"hoge": []interface{}{"bar", "baz"},
+				},
+			},
+		},
+		{
+			Name: "Decode map",
+			Vars: []*hclVariable{
+				{
+					Name:         "hoge",
+					DeclaredType: "map",
+				},
+			},
+			Env: map[string]string{
+				"TF_VAR_hoge": "{bar = \"baz\", hoge = \"fuga\"}",
+			},
+			Result: []map[string]interface{}{
+				{
+					"hoge": []map[string]interface{}{
+						{
+							"bar":  "baz",
+							"hoge": "fuga",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		for k, v := range tc.Env {
+			os.Setenv(k, v)
+		}
+
+		result, err := decodeEnvVars(tc.Vars)
+		if err != nil {
+			t.Fatalf("\nAn error occurred.\nError: %s\n\ntestcase: %s", err, tc.Name)
+			continue
+		}
+
+		if !reflect.DeepEqual(result, tc.Result) {
+			t.Fatalf("\nBad: %s\nExpected: %s\n\ntestcase: %s", pp.Sprint(result), pp.Sprint(tc.Result), tc.Name)
+		}
+
+		for k, _ := range tc.Env {
+			os.Unsetenv(k)
+		}
+	}
+}
+
 func TestOverriddenVariable(t *testing.T) {
 	cases := []struct {
 		Name             string