Resource type attribute changes and stability fixes for yaml parsing and other config changes APE-16695, APE-16692, APE-16734

pkg/iac-providers/cft/v1/load-file.go

@@ -132,7 +132,7 @@ func (a *CFTV1) extractTemplate(file string, data *[]byte) (*cloudformation.Temp
 	}
 
 	zap.S().Debug("sanitizing cft template file", zap.String("file", file))
-	sanitized, err := a.sanitizeCftTemplate(*data, isYaml)
+	sanitized, err := a.sanitizeCftTemplate(file, *data, isYaml)
 	if err != nil {
 		zap.S().Debug("failed to sanitize cft template file", zap.String("file", file), zap.Error(err))
 		return nil, err
@@ -219,7 +219,7 @@ func (*CFTV1) getFileType(file string, data *[]byte) string {
 		if isJSON(string(*data)) {
 			return JSONExtension
 		}
-		return YAMLExtension
+		return TXTExtension
 	}
 	return UnknownExtension
 }

pkg/iac-providers/cft/v1/sanitize-cft-template.go

@@ -36,31 +36,58 @@ const PARAMETERS = "Parameters"
 // RESOURCES is a constant to fetch Resources from CFT
 const RESOURCES = "Resources"
 
-func (a *CFTV1) sanitizeCftTemplate(data []byte, isYAML bool) (map[string]interface{}, error) {
+func (a *CFTV1) sanitizeCftTemplate(fileName string, data []byte, isYAML bool) (map[string]interface{}, error) {
 	var (
 		intrinsified []byte
 		err          error
 	)
-
 	if isYAML {
-		data, err = removeRefAnchors(data)
-		if err != nil {
-			return nil, err
-		}
+		fallbackToDefaultProcessing := false
 
-		// Process all AWS CloudFormation intrinsic functions (e.g. Fn::Join)
-		intrinsified, err = intrinsics.ProcessYAML(data, nil)
-		if err != nil {
-			return nil, fmt.Errorf("error while resolving intrinsic functions, error %w", err)
+		for i := 0; i < 1; i++ {
+			// convert the yaml into json
+			jsonData, err := a.ReadYAMLFileIntoJSON(fileName)
+			if err == nil {
+				jsonData, err := a.resolveResourceIDs(jsonData)
+				if err != nil {
+					zap.S().Debug(fmt.Sprintf("error while resolving Resource IDs, error %s", err.Error()))
+					fallbackToDefaultProcessing = true
+					break
+				}
+				intrinsified, err = intrinsics.ProcessJSON(jsonData, nil)
+				if err != nil {
+					zap.S().Debug(fmt.Sprintf("error while resolving Resource IDs, error %s", err.Error()))
+					fallbackToDefaultProcessing = true
+					break
+				}
+			}
+		}
+		if fallbackToDefaultProcessing || len(intrinsified) == 0 { // fallback to default behaviour of yaml processing
+			data, err = removeRefAnchors(data)
+			if err != nil {
+				return nil, err
+			}
+			// Process all AWS CloudFormation intrinsic functions (e.g. Fn::Join)
+			intrinsified, err = intrinsics.ProcessYAML(data, nil)
+			if err != nil {
+				return nil, fmt.Errorf("error while resolving intrinsic functions, error %w", err)
+			}
 		}
 	} else {
-		// Process all AWS CloudFormation intrinsic functions (e.g. Fn::Join)
-		intrinsified, err = intrinsics.ProcessJSON(data, nil)
-		if err != nil {
-			return nil, fmt.Errorf("error while resolving intrinsic functions, error %w", err)
+		jsonData, err := a.resolveResourceIDs(data)
+		if err == nil {
+			intrinsified, err = intrinsics.ProcessJSON(jsonData, nil)
+			if err != nil {
+				return nil, fmt.Errorf("error while resolving intrinsic functions, error %w", err)
+			}
+		} else {
+			// Process all AWS CloudFormation intrinsic functions (e.g. Fn::Join)
+			intrinsified, err = intrinsics.ProcessJSON(data, nil)
+			if err != nil {
+				return nil, fmt.Errorf("error while resolving intrinsic functions, error %w", err)
+			}
 		}
 	}
-
 	templateFileMap := make(map[string]interface{})
 
 	err = json.Unmarshal(intrinsified, &templateFileMap)
@@ -510,3 +537,117 @@ func findKeyAndReplace(obj interface{}, propValues map[string]interface{}) (inte
 	}
 	return nil, false
 }
+
+// ReadYAMLFileIntoJSON converts the given file into JSON string
+func (a *CFTV1) ReadYAMLFileIntoJSON(fileName string) ([]byte, error) {
+	templateSample, err := a.File(fileName)
+	if err != nil {
+		return nil, err
+	}
+	gostruct, err := templateSample.Map()
+	if err != nil {
+		zap.S().Errorf("failed to map yaml to json. error : %s in file %s", err.Error(), fileName)
+		return nil, err
+	}
+	jsonData, err := json.Marshal(gostruct)
+	if err != nil {
+		zap.S().Errorf("failed to convert yaml to json. error : %s", err.Error())
+		return nil, err
+	}
+	return jsonData, nil
+}
+func (a *CFTV1) getMapOfResourceIds(allData interface{}) map[string]string {
+	mapOfresourceIds := make(map[string]string)
+	mapOfParameters := make(map[string]interface{})
+	if templateFileMap, ok := allData.(map[string]interface{}); ok {
+		r, ok := templateFileMap[PARAMETERS]
+		if ok {
+			rMap, ok := r.(map[string]interface{})
+			if ok {
+				for rName, val := range rMap {
+					zap.S().Debug("inspecting resource", zap.String("Parameters Name", rName))
+					if val1, ok := val.(map[string]interface{}); ok {
+						mapOfParameters[rName] = val1["Default"]
+					}
+				}
+			}
+		}
+	}
+
+	if templateFileMap, ok := allData.(map[string]interface{}); ok {
+		r, ok := templateFileMap[RESOURCES]
+		if ok {
+			rMap, ok := r.(map[string]interface{})
+			if ok {
+				for rName := range rMap {
+					zap.S().Debug("inspecting resource", zap.String("Resource Name", rName))
+					if _, ok := mapOfParameters[rName]; !ok {
+						mapOfresourceIds[rName] = rName
+					}
+				}
+			}
+		}
+	}
+	return mapOfresourceIds
+}
+
+// resolveResourceIDs resolves the indirect resource to resource references
+func (a *CFTV1) resolveResourceIDs(jsonData []byte) ([]byte, error) {
+	var unmarshalled interface{}
+	if err := json.Unmarshal(jsonData, &unmarshalled); err != nil {
+		return nil, fmt.Errorf("invalid JSON: %s", err)
+	}
+	mapOfparentReferences := a.getMapOfResourceIds(unmarshalled)
+	unmarshalledResult := a.resolveIndirectReferences(nil, unmarshalled, "", mapOfparentReferences)
+	resultBytes, err := json.Marshal(unmarshalledResult)
+	if err != nil {
+		return nil, fmt.Errorf("invalid JSON: %s", err)
+	}
+	jsonData = resultBytes
+	return jsonData, nil
+}
+
+// resolveIndirectReferences finds if the references are of the Name of the resource and replace it with actual Name
+func (a *CFTV1) resolveIndirectReferences(parent interface{}, input interface{}, parentKey string, mapOfReferences map[string]string) interface{} {
+
+	switch value := input.(type) {
+
+	case map[string]interface{}:
+		processed := map[string]interface{}{}
+		for key, val := range value {
+			if key == "Ref" && parentKey != "" {
+				valuStr := fmt.Sprintf("%v", val)
+				if _, ok := mapOfReferences[valuStr]; ok {
+					if parentVal, ok := parent.(map[string]interface{}); ok {
+						parentVal[parentKey] = valuStr
+						val = valuStr
+						return val
+					}
+				}
+			}
+			processed[key] = a.resolveIndirectReferences(value, val, key, mapOfReferences)
+		}
+		return processed
+
+	case []interface{}:
+
+		// We found an array in the JSON - recurse through it's elements looking for intrinsic functions
+		processed := []interface{}{}
+		for _, val := range value {
+			processed = append(processed, a.resolveIndirectReferences(parent, val, parentKey, mapOfReferences))
+		}
+		return processed
+
+	case nil:
+		return value
+	case bool:
+		return value
+	case float64:
+		return value
+	case string:
+		return value
+	default:
+		return nil
+
+	}
+}

pkg/iac-providers/cft/v1/sanitize-cft-template_test.go

@@ -66,7 +66,7 @@ func TestCFTV1_sanitizeCftTemplate(t *testing.T) {
 				t.Error("CFTV1.sanitizeCftTemplate() got no error, expected parsing error")
 			}
 
-			templateMap, err := a.sanitizeCftTemplate(data, tt.args.isYAML)
+			templateMap, err := a.sanitizeCftTemplate(tt.inputFile, data, tt.args.isYAML)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("CFTV1.sanitizeCftTemplate() error = %v, wantErr %v", err, tt.wantErr)
 				return

pkg/iac-providers/cft/v1/testdata/deploy.yaml

@@ -26,5 +26,5 @@ Resources:
         Statement:
           - Effect: Allow
             Action: *
-            Principal: '*'
+            Principal: 'star'