allow overwriting the env-var while apply

Author: davidcheung

cmd/create.go

@@ -47,7 +47,11 @@ func Create(dir string, createConfigPath string) {
 		flog.Infof(":up_arrow: Done Rendering - committing repositories to version control.")
 
 		for _, module := range projectConfig.Modules {
-			vcs.InitializeRepository(module.Files.Repository, module.Parameters["github_access_token"])
+			err, githubApiKey := module.ReadVendorCredentials("github")
+			if err != nil {
+				flog.Errorf(err.Error())
+			}
+			vcs.InitializeRepository(module.Files.Repository, githubApiKey)
 		}
 	} else {
 		flog.Infof(":up_arrow: Done Rendering - you will need to commit the created projects to version control.")

internal/apply/apply.go

@@ -13,6 +13,7 @@ import (
 	"github.com/commitdev/zero/internal/util"
 	"github.com/hashicorp/terraform/dag"
 
+	"github.com/commitdev/zero/internal/config/moduleconfig"
 	"github.com/commitdev/zero/internal/config/projectconfig"
 	"github.com/commitdev/zero/pkg/util/exit"
 	"github.com/commitdev/zero/pkg/util/flog"
@@ -86,14 +87,24 @@ func applyAll(dir string, projectConfig projectconfig.ZeroProjectConfig, applyEn
 			exit.Fatal("Failed to load module config, credentials cannot be injected properly")
 		}
 
-		envList = util.AppendProjectEnvToCmdEnv(mod.Parameters, envList)
+		envVarTranslationMap := modConfig.GetParamEnvVarTranslationMap()
+		envList = util.AppendProjectEnvToCmdEnv(mod.Parameters, envList, envVarTranslationMap)
 		flog.Debugf("Env injected: %#v", envList)
 		flog.Infof("Executing apply command for %s...", modConfig.Name)
 		util.ExecuteCommand(exec.Command("make"), modulePath, envList)
 		return nil
 	})
 }
 
+func getParameterDefinition(modConfig moduleconfig.ModuleConfig, field string) moduleconfig.Parameter {
+	for i := 0; i < len(modConfig.Parameters); i++ {
+		if field == modConfig.Parameters[i].Field {
+			return modConfig.Parameters[i]
+		}
+	}
+	return moduleconfig.Parameter{}
+}
+
 // promptEnvironments Prompts the user for the environments to apply against and returns a slice of strings representing the environments
 func promptEnvironments() []string {
 	items := map[string][]string{
@@ -155,7 +166,12 @@ func summarizeAll(dir string, projectConfig projectconfig.ZeroProjectConfig, app
 		}
 		flog.Debugf("Loaded module: %s from %s", name, modulePath)
 
-		envList = util.AppendProjectEnvToCmdEnv(mod.Parameters, envList)
+		modConfig, err := module.ParseModuleConfig(modulePath)
+		if err != nil {
+			exit.Fatal("Failed to load module config, credentials cannot be injected properly")
+		}
+		envVarTranslationMap := modConfig.GetParamEnvVarTranslationMap()
+		envList = util.AppendProjectEnvToCmdEnv(mod.Parameters, envList, envVarTranslationMap)
 		flog.Debugf("Env injected: %#v", envList)
 		util.ExecuteCommand(exec.Command("make", "summary"), modulePath, envList)
 		return nil

internal/apply/apply_test.go

@@ -38,4 +38,11 @@ func TestApply(t *testing.T) {
 		assert.NoError(t, err)
 		assert.Equal(t, "baz: qux\n", string(content))
 	})
+
+	t.Run("Zero apply honors the envVarName overwrite from module definition", func(t *testing.T) {
+		content, err := ioutil.ReadFile(filepath.Join(tmpDir, "project1/feature.out"))
+		assert.NoError(t, err)
+		assert.Equal(t, "envVarName of viaEnvVarName: baz\n", string(content))
+	})
+
 }

internal/config/moduleconfig/module_config.go

@@ -12,7 +12,6 @@ import (
 	"github.com/commitdev/zero/internal/config/projectconfig"
 	"github.com/commitdev/zero/pkg/util/flog"
 	"github.com/iancoleman/strcase"
-	"github.com/pkg/errors"
 )
 
 type ModuleConfig struct {
@@ -38,12 +37,13 @@ type Parameter struct {
 	Type                string      `yaml:"type,omitempty"`
 	OmitFromProjectFile bool        `yaml:"omitFromProjectFile,omitempty"`
 	Conditions          []Condition `yaml:"conditions,omitempty"`
+	EnvVarName          string      `yaml:"envVarName,omitempty"`
 }
 
 type Condition struct {
 	Action     string   `yaml:"action"`
 	MatchField string   `yaml:"matchField"`
-	WhenValue  string   `yaml:"whenValue,omitempty"`
+	WhenValue  string   `yaml:"whenValue"`
 	Data       []string `yaml:"data,omitempty"`
 }
 
@@ -68,6 +68,17 @@ func (cfg ModuleConfig) collectMissing() []string {
 	return missing
 }
 
+func (cfg ModuleConfig) GetParamEnvVarTranslationMap() map[string]string {
+	translationMap := make(map[string]string)
+	for i := 0; i < len(cfg.Parameters); i++ {
+		param := cfg.Parameters[i]
+		if param.EnvVarName != "" {
+			translationMap[param.Field] = param.EnvVarName
+		}
+	}
+	return translationMap
+}
+
 func LoadModuleConfig(filePath string) (ModuleConfig, error) {
 	config := ModuleConfig{}
 
@@ -81,7 +92,6 @@ func LoadModuleConfig(filePath string) (ModuleConfig, error) {
 		return config, err
 	}
 
-	validateParams(config.Parameters)
 	missing := config.collectMissing()
 	if len(missing) > 0 {
 		flog.Errorf("%v is missing information", filePath)
@@ -96,15 +106,6 @@ func LoadModuleConfig(filePath string) (ModuleConfig, error) {
 	return config, nil
 }
 
-func validateParams(params []Parameter) error {
-	for _, param := range params {
-		if param.Type != "" {
-			return errors.Errorf("type is not supported")
-		}
-	}
-	return nil
-}
-
 // Recurses through a datastructure to find any missing data.
 // This assumes several things:
 // 1. The structure matches that defined by ModuleConfig and its child datastructures.

internal/config/projectconfig/project_config.go

@@ -1,6 +1,7 @@
 package projectconfig
 
 import (
+	"errors"
 	"io/ioutil"
 	"log"
 
@@ -29,6 +30,21 @@ type Module struct {
 	Conditions []Condition `yaml:"conditions,omitempty"`
 }
 
+func (m Module) ReadVendorCredentials(vendor string) (error, string) {
+	// this mapping could be useful for module config as well
+	vendorToParamMap := map[string]string{
+		"github":   "githubAccessToken",
+		"circleci": "circleciApiKey",
+	}
+	if parameterKey, ok := vendorToParamMap[vendor]; ok {
+		if val, ok := m.Parameters[parameterKey]; ok {
+			return nil, val
+		}
+		return errors.New("Parameter not found in module."), ""
+	}
+	return errors.New("Unsupported vendor provided."), ""
+}
+
 type Parameters map[string]string
 
 type Condition struct {

internal/constants/constants.go

@@ -1,13 +1,12 @@
 package constants
 
 const (
-	TemplatesDir       = "tmp/templates"
-	ZeroProjectYml     = "zero-project.yml"
-	ZeroModuleYml      = "zero-module.yml"
-	UserCredentialsYml = "credentials.yml"
-	ZeroHomeDirectory  = ".zero"
-	IgnoredPaths       = "(?i)zero.module.yml|.git/"
-	TemplateExtn       = ".tmpl"
+	TemplatesDir      = "tmp/templates"
+	ZeroProjectYml    = "zero-project.yml"
+	ZeroModuleYml     = "zero-module.yml"
+	ZeroHomeDirectory = ".zero"
+	IgnoredPaths      = "(?i)zero.module.yml|.git/"
+	TemplateExtn      = ".tmpl"
 
 	// prompt constants
 

internal/init/custom-prompts.go

@@ -4,7 +4,6 @@ import (
 	"github.com/commitdev/zero/internal/config/moduleconfig"
 	project "github.com/commitdev/zero/pkg/credentials"
 	"github.com/commitdev/zero/pkg/util/flog"
-	"github.com/k0kubun/pp"
 )
 
 func CustomPromptHandler(promptType string, params map[string]string) {
@@ -31,11 +30,9 @@ func AWSProfilePicker(params map[string]string) {
 		Validate:  NoValidation,
 	}
 	_, value := promptParameter(awsPrompt)
-	pp.Print(value)
 	credErr := project.FillAWSProfile(value, params)
 	if credErr != nil {
 		flog.Errorf("Failed to retrieve profile, falling back to User input")
 		params["useExistingAwsProfile"] = "no"
 	}
-	pp.Print(params)
 }

internal/init/init.go

@@ -20,8 +20,9 @@ func Init(outDir string, localModulePath string) *projectconfig.ZeroProjectConfi
 	projectConfig := defaultProjConfig()
 
 	projectRootParams := map[string]string{}
+	emptyEnvVarTranslationMap := map[string]string{}
 	promptName := getProjectNamePrompt()
-	promptName.RunPrompt(projectRootParams)
+	promptName.RunPrompt(projectRootParams, emptyEnvVarTranslationMap)
 	projectConfig.Name = projectRootParams[promptName.Field]
 
 	rootDir := path.Join(outDir, projectConfig.Name)
@@ -41,19 +42,19 @@ func Init(outDir string, localModulePath string) *projectconfig.ZeroProjectConfi
 
 	initParams := make(map[string]string)
 	projectConfig.ShouldPushRepositories = true
-	prompts["ShouldPushRepositories"].RunPrompt(initParams)
+	prompts["ShouldPushRepositories"].RunPrompt(initParams, emptyEnvVarTranslationMap)
 	if initParams["ShouldPushRepositories"] == "n" {
 		projectConfig.ShouldPushRepositories = false
 	}
 
 	// Prompting for push-up stream, then conditionally prompting for github
-	prompts["GithubRootOrg"].RunPrompt(initParams)
+	prompts["GithubRootOrg"].RunPrompt(initParams, emptyEnvVarTranslationMap)
 
 	projectData := promptAllModules(moduleConfigs)
 
 	// Map parameter values back to specific modules
 	for moduleName, module := range moduleConfigs {
-		prompts[moduleName].RunPrompt(initParams)
+		prompts[moduleName].RunPrompt(initParams, emptyEnvVarTranslationMap)
 		repoName := initParams[prompts[moduleName].Field]
 		repoURL := fmt.Sprintf("%s/%s", initParams["GithubRootOrg"], repoName)
 		projectModuleParams := moduleconfig.SummarizeParameters(module, projectData)

internal/init/prompts.go

@@ -14,7 +14,6 @@ import (
 	"github.com/commitdev/zero/internal/util"
 	"github.com/commitdev/zero/pkg/util/exit"
 	"github.com/commitdev/zero/pkg/util/flog"
-	"github.com/k0kubun/pp"
 	"github.com/manifoldco/promptui"
 )
 
@@ -107,7 +106,7 @@ func ValidateProjectName(input string) error {
 // 1. Execute (this could potentially be refactored into type + data)
 // 2. type: specific ways of obtaining values (in AWS credential case it will set 2 values to the map)
 //3.
-func (p PromptHandler) RunPrompt(projectParams map[string]string) {
+func (p PromptHandler) RunPrompt(projectParams map[string]string, envVarTranslationMap map[string]string) {
 	var err error
 	var result string
 
@@ -120,7 +119,7 @@ func (p PromptHandler) RunPrompt(projectParams map[string]string) {
 		// so if community module has an `execute: twitter tweet $ENV`
 		// it wouldnt leak things the module shouldnt have access to
 		if p.Parameter.Execute != "" {
-			result = executeCmd(p.Parameter.Execute, projectParams)
+			result = executeCmd(p.Parameter.Execute, projectParams, envVarTranslationMap)
 		} else if p.Parameter.Type != "" {
 			CustomPromptHandler(p.Parameter.Type, projectParams)
 		} else if p.Parameter.Value != "" {
@@ -172,10 +171,11 @@ func promptParameter(prompt PromptHandler) (error, string) {
 	return nil, result
 }
 
-func executeCmd(command string, envVars map[string]string) string {
-	pp.Print(envVars)
+func executeCmd(command string, envVars map[string]string, envVarTranslationMap map[string]string) string {
 	cmd := exec.Command("bash", "-c", command)
-	cmd.Env = util.AppendProjectEnvToCmdEnv(envVars, os.Environ())
+	// Might need to pass down module's translation map as well,
+	// currently only works in `zero apply`
+	cmd.Env = util.AppendProjectEnvToCmdEnv(envVars, os.Environ(), envVarTranslationMap)
 	out, err := cmd.Output()
 	flog.Debugf("Running command: %s", command)
 	if err != nil {
@@ -193,7 +193,7 @@ func sanitizeParameterValue(str string) string {
 
 // PromptParams renders series of prompt UI based on the config
 func PromptModuleParams(moduleConfig moduleconfig.ModuleConfig, parameters map[string]string) (map[string]string, error) {
-
+	envVarTranslationMap := moduleConfig.GetParamEnvVarTranslationMap()
 	for _, parameter := range moduleConfig.Parameters {
 		// deduplicate fields already prompted and received
 		if _, isAlreadySet := parameters[parameter.Field]; isAlreadySet {
@@ -225,12 +225,9 @@ func PromptModuleParams(moduleConfig moduleconfig.ModuleConfig, parameters map[s
 		// for k, v := range parameters {
 		// 	credentialEnvs[k] = v
 		// }
-		promptHandler.RunPrompt(parameters)
-
-		// parameters[parameter.Field] = result
-		pp.Print("Module is done processing %s", moduleConfig.Name)
-		pp.Print(parameters)
+		promptHandler.RunPrompt(parameters, envVarTranslationMap)
 	}
+	flog.Debugf("Module %s prompt: \n %#v", moduleConfig.Name, parameters)
 	return parameters, nil
 }
 
@@ -257,8 +254,9 @@ func paramConditionsMapper(conditions []moduleconfig.Condition) CustomConditionS
 		return func(params map[string]string) bool {
 			// Prompts must pass every condition to proceed
 			for i := 0; i < len(conditions); i++ {
-				if !conditionHandler(conditions[i])(params) {
-					flog.Debugf("Did not meet condition %v, expected %v to be %v", conditions[i].Action, conditions[i].MatchField, conditions[i].WhenValue)
+				cond := conditions[i]
+				if !conditionHandler(cond)(params) {
+					flog.Debugf("Did not meet condition %v, expected %v to be %v", cond.Action, cond.MatchField, cond.WhenValue)
 					return false
 				}
 			}