fix: when the user specifies a replicas other than 2 it is not properly reflected in the Helm chart values.yaml

assets/built-in/transformers/kubernetes/parameterizer/parameterizers/replicas.yaml

@@ -6,6 +6,7 @@ spec:
   parameterizers:
     - target: "spec.replicas"
       template: "${common.replicas}"
+      keepOriginalValueIfPresent: true
       default: 2
       filters:
         - kind: Deployment

transformer/kubernetes/parameterizer/parameterizer.go

@@ -49,6 +49,8 @@ var (
 
 // Parameterize does the parameterization based on a spec
 func Parameterize(srcDir, outDir string, packSpecConfig ParameterizerConfigT, ps []ParameterizerT) ([]string, error) {
+	logrus.Trace("Parameterize start")
+	defer logrus.Trace("Parameterize end")
 	filesWritten := []string{}
 	cleanSrcDir, err := filepath.Abs(srcDir)
 	if err != nil {
@@ -432,7 +434,15 @@ func fillCustomTemplate(templ, kind, apiVersion, metadataName string, matches ma
 // ------------------------------
 // Parameterization
 
-func parameterize(target ParamTargetT, envs []string, k k8sschema.K8sResourceT, ps []ParameterizerT, namedValues map[string]HelmValuesT, namedKustPatches map[string]map[string]PatchT, namedOCParams map[string]map[string]string) error {
+func parameterize(
+	target ParamTargetT,
+	envs []string,
+	k k8sschema.K8sResourceT,
+	ps []ParameterizerT,
+	namedValues map[string]HelmValuesT,
+	namedKustPatches map[string]map[string]PatchT,
+	namedOCParams map[string]map[string]string,
+) error {
 	for _, p := range ps {
 		ok, err := parameterizeFilter(envs, k, p)
 		if err != nil {
@@ -521,21 +531,27 @@ func parameterizeFilter(envs []string, k k8sschema.K8sResourceT, p Parameterizer
 	return false, nil
 }
 
-func parameterizeHelperHelm(envs []string, k k8sschema.K8sResourceT, p ParameterizerT, namedValues map[string]HelmValuesT, namedKustPatches map[string]map[string]PatchT, namedOCParams map[string]map[string]string) error {
-	logrus.Trace("start parameterizeHelperHelm")
-	defer logrus.Trace("end parameterizeHelperHelm")
-
+func parameterizeHelperHelm(
+	envs []string,
+	k k8sschema.K8sResourceT,
+	p ParameterizerT,
+	namedValues map[string]HelmValuesT,
+	namedKustPatches map[string]map[string]PatchT,
+	namedOCParams map[string]map[string]string,
+) error {
 	if len(p.Target) == 0 {
 		return fmt.Errorf("the target is empty")
 	}
+
 	kind, apiVersion, metadataName, err := k8sschema.GetInfoFromK8sResource(k)
 	if err != nil {
 		return fmt.Errorf("failed to get the kind, apiVersion, and name from the k8s resource: %+v\nError: %q", k, err)
 	}
 	resultKVs, err := GetAll(p.Target, k)
 	if err != nil {
-		return fmt.Errorf("the key %s does not exist on the k8s resource: %+v Error: %q", p.Target, k, err)
+		return fmt.Errorf("the key '%s' does not exist on the k8s resource: %+v Error: %w", p.Target, k, err)
 	}
+
 	for _, resultKV := range resultKVs {
 		t1 := []string{}
 		for _, k := range resultKV.Key {
@@ -546,14 +562,18 @@ func parameterizeHelperHelm(envs []string, k k8sschema.K8sResourceT, p Parameter
 		if templ == "" {
 			templ = fmt.Sprintf(`${"%s"."%s"."%s".%s}`, kind, apiVersion, metadataName, key)
 		}
+
 		parameters, err := getParameters(templ)
 		if err != nil {
-			return fmt.Errorf("failed to get the parameters from the template: %s\nError: %q", templ, err)
+			return fmt.Errorf("failed to get the parameters from the template: '%s' Error: %w", templ, err)
 		}
 		paramValue := p.Default
 		if paramValue == nil {
 			paramValue = resultKV.Value
 		}
+		if p.KeepOriginalValueIfPresent && resultKV.Value != nil {
+			paramValue = resultKV.Value
+		}
 		if p.Question != nil {
 			if p.Question.Type == "" {
 				p.Question.Type = qatypes.InputSolutionFormType
@@ -582,6 +602,7 @@ func parameterizeHelperHelm(envs []string, k k8sschema.K8sResourceT, p Parameter
 			}
 			p.Question.Desc = origQuesDesc
 		}
+
 		if len(parameters) == 1 {
 			parameter := parameters[0]
 			subKeys := GetSubKeys(parameter)
@@ -649,6 +670,7 @@ func parameterizeHelperHelm(envs []string, k k8sschema.K8sResourceT, p Parameter
 			}
 			return nil
 		}
+
 		// multiple parameters only make sense when the original value is a string
 		originalValueStr, ok := resultKV.Value.(string)
 		if !ok {
@@ -670,6 +692,7 @@ Actual value is %+v of type %T`,
 		if err != nil {
 			return fmt.Errorf("failed to parse the multi parameter template: %s\nError: %q", templ, err)
 		}
+
 		helmTemplates := []string{}
 		paramKeys := []string{}
 		for _, parameter := range parameters {
@@ -729,9 +752,11 @@ Actual value is %+v of type %T`,
 			fullHelmTemplate += currHelmTemplate
 			helmTemplateIdx++
 		}
+
 		if err := set(key, fullHelmTemplate, k); err != nil {
 			return fmt.Errorf("failed to set the key %s to the value %s in the k8s resource: %+v\nError: %q", key, fullHelmTemplate, k, err)
 		}
+
 		// set all the keys in the values.yaml
 		for i, parameter := range parameters {
 			paramKey := paramKeys[i]
@@ -793,6 +818,9 @@ func parameterizeHelperKustomize(envs []string, k k8sschema.K8sResourceT, p Para
 		if paramValue == nil {
 			paramValue = resultKV.Value
 		}
+		if p.KeepOriginalValueIfPresent && resultKV.Value != nil {
+			paramValue = resultKV.Value
+		}
 		if p.Question != nil {
 			if p.Question.Type == "" {
 				p.Question.Type = qatypes.InputSolutionFormType
@@ -881,6 +909,9 @@ func parameterizeHelperOCTemplates(envs []string, k k8sschema.K8sResourceT, p Pa
 		if paramValue == nil {
 			paramValue = resultKV.Value
 		}
+		if p.KeepOriginalValueIfPresent && resultKV.Value != nil {
+			paramValue = resultKV.Value
+		}
 		if p.Question != nil {
 			if p.Question.Type == "" {
 				p.Question.Type = qatypes.InputSolutionFormType

transformer/kubernetes/parameterizer/types.go

@@ -54,13 +54,14 @@ type ParameterizerSpecT struct {
 
 // ParameterizerT is a paramterizer
 type ParameterizerT struct {
-	Target     string            `yaml:"target" json:"target"`
-	Template   string            `yaml:"template,omitempty" json:"template,omitempty"`
-	Regex      string            `yaml:"regex,omitempty" json:"regex,omitempty"`
-	Default    interface{}       `yaml:"default,omitempty" json:"default,omitempty"`
-	Question   *qaengine.Problem `yaml:"question,omitempty" json:"question,omitempty"`
-	Filters    []FilterT         `yaml:"filters,omitempty" json:"filters,omitempty"`
-	Parameters []ParameterT      `yaml:"parameters,omitempty" json:"parameters,omitempty"`
+	Target                     string            `yaml:"target" json:"target"`
+	Template                   string            `yaml:"template,omitempty" json:"template,omitempty"`
+	Regex                      string            `yaml:"regex,omitempty" json:"regex,omitempty"`
+	KeepOriginalValueIfPresent bool              `yaml:"keepOriginalValueIfPresent,omitempty" json:"keepOriginalValueIfPresent,omitempty"`
+	Default                    interface{}       `yaml:"default,omitempty" json:"default,omitempty"`
+	Question                   *qaengine.Problem `yaml:"question,omitempty" json:"question,omitempty"`
+	Filters                    []FilterT         `yaml:"filters,omitempty" json:"filters,omitempty"`
+	Parameters                 []ParameterT      `yaml:"parameters,omitempty" json:"parameters,omitempty"`
 }
 
 // FilterT is used to choose the k8s resources that the parameterizer should be applied on

transformer/kubernetes/parameterizer/utils.go

@@ -342,6 +342,8 @@ func writeResourceStripQuotesAndAppendToFile(k8sResource k8sschema.K8sResourceT,
 
 // CollectParamsFromPath returns parameterizers found in a directory
 func CollectParamsFromPath(parameterizersDir string) (map[string][]ParameterizerT, error) {
+	logrus.Trace("CollectParamsFromPath start")
+	defer logrus.Trace("CollectParamsFromPath end")
 	yamlPaths, err := common.GetFilesByExt(parameterizersDir, []string{".yaml", ".yml"})
 	if err != nil {
 		return nil, err

transformer/kubernetes/parameterizertransformer.go

@@ -61,36 +61,33 @@ type ParameterizerPathTemplateConfig struct {
 }
 
 // Init Initializes the transformer
-func (t *Parameterizer) Init(tc transformertypes.Transformer, e *environment.Environment) error {
-	t.Config = tc
-	t.Env = e
-	t.ParameterizerConfig = &ParameterizerYamlConfig{}
-	err := common.GetObjFromInterface(t.Config.Spec.Config, t.ParameterizerConfig)
-	if err != nil {
-		logrus.Errorf("unable to load config for Transformer %+v into %T : %s", t.Config.Spec.Config, t.ParameterizerConfig, err)
-		return err
+func (paramTransformer *Parameterizer) Init(tc transformertypes.Transformer, e *environment.Environment) error {
+	paramTransformer.Config = tc
+	paramTransformer.Env = e
+	paramTransformer.ParameterizerConfig = &ParameterizerYamlConfig{}
+	if err := common.GetObjFromInterface(paramTransformer.Config.Spec.Config, paramTransformer.ParameterizerConfig); err != nil {
+		return fmt.Errorf("failed to load the config %+v into the type %T . Error: %w", paramTransformer.Config.Spec.Config, paramTransformer.ParameterizerConfig, err)
 	}
-	if t.ParameterizerConfig.ProjectName == "" {
-		t.ParameterizerConfig.ProjectName = e.ProjectName
+	if paramTransformer.ParameterizerConfig.ProjectName == "" {
+		paramTransformer.ParameterizerConfig.ProjectName = e.ProjectName
 	}
-	psmap, err := parameterizer.CollectParamsFromPath(t.Env.Context)
+	psmap, err := parameterizer.CollectParamsFromPath(paramTransformer.Env.Context)
 	if err != nil {
-		logrus.Errorf("Error while parsing for params : %s", err)
-		return err
+		return fmt.Errorf("failed to collect parameterizers from the directory at path '%s' . Error: %w", paramTransformer.Env.Context, err)
 	}
 	for _, p := range psmap {
-		t.parameterizers = append(t.parameterizers, p...)
+		paramTransformer.parameterizers = append(paramTransformer.parameterizers, p...)
 	}
 	return nil
 }
 
 // GetConfig returns the transformer config
-func (t *Parameterizer) GetConfig() (transformertypes.Transformer, *environment.Environment) {
-	return t.Config, t.Env
+func (paramTransformer *Parameterizer) GetConfig() (transformertypes.Transformer, *environment.Environment) {
+	return paramTransformer.Config, paramTransformer.Env
 }
 
 // DirectoryDetect runs detect in each subdirectory
-func (t *Parameterizer) DirectoryDetect(dir string) (namedServices map[string][]transformertypes.Artifact, err error) {
+func (paramTransformer *Parameterizer) DirectoryDetect(dir string) (namedServices map[string][]transformertypes.Artifact, err error) {
 	if len(k8sschema.GetKubernetesObjsInDir(dir)) != 0 {
 		na := transformertypes.Artifact{
 			Paths: map[transformertypes.PathType][]string{
@@ -104,11 +101,14 @@ func (t *Parameterizer) DirectoryDetect(dir string) (namedServices map[string][]
 }
 
 // Transform transforms artifacts
-func (t *Parameterizer) Transform(newArtifacts []transformertypes.Artifact, alreadySeenArtifacts []transformertypes.Artifact) (pathMappings []transformertypes.PathMapping, createdArtifacts []transformertypes.Artifact, err error) {
+func (paramTransformer *Parameterizer) Transform(
+	newArtifacts []transformertypes.Artifact,
+	alreadySeenArtifacts []transformertypes.Artifact,
+) (pathMappings []transformertypes.PathMapping, createdArtifacts []transformertypes.Artifact, err error) {
 	pathMappings = []transformertypes.PathMapping{}
 	for _, a := range newArtifacts {
 		yamlsPath := a.Paths[artifacts.KubernetesYamlsPathType][0]
-		tempPath, err := os.MkdirTemp(t.Env.TempPath, "*")
+		tempPath, err := os.MkdirTemp(paramTransformer.Env.TempPath, "*")
 		if err != nil {
 			logrus.Errorf("Unable to create temp dir : %s", err)
 		}
@@ -119,8 +119,8 @@ func (t *Parameterizer) Transform(newArtifacts []transformertypes.Artifact, alre
 		if err != nil {
 			logrus.Debugf("Unable to load config for Transformer into %T : %s", sConfig, err)
 		}
-		projectName, err := common.GetStringFromTemplate(t.ParameterizerConfig.ProjectName,
-			map[string]string{common.ProjectNameTemplatizedStringKey: t.Env.ProjectName,
+		projectName, err := common.GetStringFromTemplate(paramTransformer.ParameterizerConfig.ProjectName,
+			map[string]string{common.ProjectNameTemplatizedStringKey: paramTransformer.Env.ProjectName,
 				common.ArtifactNameTemplatizedStringKey: a.Name,
 				common.ServiceNameTemplatizedStringKey:  sConfig.ServiceName,
 				common.ArtifactTypeTemplatizedStringKey: string(a.Type)})
@@ -135,19 +135,19 @@ func (t *Parameterizer) Transform(newArtifacts []transformertypes.Artifact, alre
 			ProjectName: projectName,
 			Envs:        []string{},
 		}
-		if len(t.ParameterizerConfig.Envs) > 0 {
-			pt.Envs = t.ParameterizerConfig.Envs
+		if len(paramTransformer.ParameterizerConfig.Envs) > 0 {
+			pt.Envs = paramTransformer.ParameterizerConfig.Envs
 		}
-		if len(t.ParameterizerConfig.HelmPath) == 0 {
+		if len(paramTransformer.ParameterizerConfig.HelmPath) == 0 {
 			pt.Helm = ""
 		}
-		if len(t.ParameterizerConfig.KustomizePath) == 0 {
+		if len(paramTransformer.ParameterizerConfig.KustomizePath) == 0 {
 			pt.Kustomize = ""
 		}
-		if len(t.ParameterizerConfig.OCTemplatePath) == 0 {
+		if len(paramTransformer.ParameterizerConfig.OCTemplatePath) == 0 {
 			pt.OCTemplates = ""
 		}
-		filesWritten, err := parameterizer.Parameterize(yamlsPath, destPath, pt, t.parameterizers)
+		filesWritten, err := parameterizer.Parameterize(yamlsPath, destPath, pt, paramTransformer.parameterizers)
 		if err != nil {
 			logrus.Errorf("failed to parameterize the YAML files in the source directory %s and write to output directory %s . Error: %q", yamlsPath, destPath, err)
 			continue
@@ -162,10 +162,10 @@ func (t *Parameterizer) Transform(newArtifacts []transformertypes.Artifact, alre
 		if serviceFsPaths, ok := a.Paths[artifacts.ServiceDirPathType]; ok && len(serviceFsPaths) > 0 {
 			serviceFsPath = serviceFsPaths[0]
 		}
-		if len(t.ParameterizerConfig.HelmPath) != 0 {
+		if len(paramTransformer.ParameterizerConfig.HelmPath) != 0 {
 			pathMappings = append(pathMappings, transformertypes.PathMapping{
 				Type:           transformertypes.PathTemplatePathMappingType,
-				SrcPath:        t.ParameterizerConfig.HelmPath,
+				SrcPath:        paramTransformer.ParameterizerConfig.HelmPath,
 				TemplateConfig: ParameterizerPathTemplateConfig{YamlsPath: yamlsPath, PathTemplateName: helmKey, ServiceFsPath: serviceFsPath},
 			})
 			pathMappings = append(pathMappings, transformertypes.PathMapping{
@@ -174,10 +174,10 @@ func (t *Parameterizer) Transform(newArtifacts []transformertypes.Artifact, alre
 				DestPath: fmt.Sprintf("{{ .%s }}", helmKey),
 			})
 		}
-		if len(t.ParameterizerConfig.KustomizePath) != 0 {
+		if len(paramTransformer.ParameterizerConfig.KustomizePath) != 0 {
 			pathMappings = append(pathMappings, transformertypes.PathMapping{
 				Type:           transformertypes.PathTemplatePathMappingType,
-				SrcPath:        t.ParameterizerConfig.KustomizePath,
+				SrcPath:        paramTransformer.ParameterizerConfig.KustomizePath,
 				TemplateConfig: ParameterizerPathTemplateConfig{YamlsPath: yamlsPath, PathTemplateName: kustomizeKey, ServiceFsPath: serviceFsPath},
 			})
 			pathMappings = append(pathMappings, transformertypes.PathMapping{
@@ -186,10 +186,10 @@ func (t *Parameterizer) Transform(newArtifacts []transformertypes.Artifact, alre
 				DestPath: fmt.Sprintf("{{ .%s }}", kustomizeKey),
 			})
 		}
-		if len(t.ParameterizerConfig.OCTemplatePath) != 0 {
+		if len(paramTransformer.ParameterizerConfig.OCTemplatePath) != 0 {
 			pathMappings = append(pathMappings, transformertypes.PathMapping{
 				Type:           transformertypes.PathTemplatePathMappingType,
-				SrcPath:        t.ParameterizerConfig.OCTemplatePath,
+				SrcPath:        paramTransformer.ParameterizerConfig.OCTemplatePath,
 				TemplateConfig: ParameterizerPathTemplateConfig{YamlsPath: yamlsPath, PathTemplateName: octKey, ServiceFsPath: serviceFsPath},
 			})
 			pathMappings = append(pathMappings, transformertypes.PathMapping{