func()

in pkg/engine/transform/transform.go [604:761]

• 132 lines of code
• 40 McCabe index (conditional complexity)

func (t *Transformer) NormalizeResourcesForK8sAgentUpgrade(logger *logrus.Entry, templateMap map[string]interface{}, isMasterManagedDisk bool, agentPoolsToPreserve map[string]bool) error {
	logger.Infoln("Running NormalizeResourcesForK8sMasterUpgrade....")
	resources := templateMap[resourcesFieldName].([]interface{})
	resourceTypeToProcess := map[string]bool{
		vmResourceType: true, vmExtensionType: true, nicResourceType: true,
		vnetResourceType: true, nsgResourceType: true, lbResourceType: true,
		vmssResourceType: true, vmasResourceType: true, roleResourceType: true,
		storageAccountsResourceType: true}
	logger.Infoln(fmt.Sprintf("Resource count before running NormalizeResourcesForK8sMasterUpgrade: %d", len(resources)))

	filteredResources := resources[:0]

	for _, resource := range resources {
		filteredResources = append(filteredResources, resource)
		resourceMap, ok := resource.(map[string]interface{})
		if !ok {
			logger.Warnf("Template improperly formatted for field name: %s", resourcesFieldName)
			continue
		}

		resourceType, ok := resourceMap[typeFieldName].(string)
		if !ok {
			continue
		}

		_, process := resourceTypeToProcess[resourceType]
		if !process {
			continue
		}

		filteredResources = removeVMAS(logger, filteredResources, resourceMap)

		resourceName, ok := resourceMap[nameFieldName].(string)
		if !ok {
			logger.Warnf("Template improperly formatted for field name: %s", nameFieldName)
			continue
		}

		// Remove control plane resources
		switch resourceType {
		case vmResourceType, vmExtensionType, roleResourceType, nicResourceType:
			if strings.Contains(resourceName, "variables('masterVMNamePrefix')") {
				filteredResources = filteredResources[:len(filteredResources)-1]
				continue
			}
		case nsgResourceType:
			if strings.Contains(resourceName, "variables('nsgName')") {
				filteredResources = filteredResources[:len(filteredResources)-1]
				continue
			}
		case publicIPAddressResourceType, lbResourceType:
			if strings.Contains(resourceName, "variables('master") {
				filteredResources = filteredResources[:len(filteredResources)-1]
				continue
			}
		case vnetResourceType:
			RemoveNsgDependency(logger, resourceName, resourceMap)
		case vmssResourceType:
			filteredResources = filteredResources[:len(filteredResources)-1]
			continue
		}

		tags, _ := resourceMap[tagsFieldName].(map[string]interface{})
		poolName := fmt.Sprint(tags["poolName"])

		// Remove resources for node pools not being upgraded
		switch resourceType {
		case vmResourceType:
			logger.Infoln(fmt.Sprintf("Evaluating if agent pool: %s, resource: %s needs to be removed", poolName, resourceName))
			logger.Infoln(fmt.Sprintf("agentPoolsToPreserve: %v...", agentPoolsToPreserve))

			removeVM := true

			for pool, preserve := range agentPoolsToPreserve {
				if strings.Contains(resourceName, "variables('"+pool) && preserve {
					removeVM = false
				}
			}

			if removeVM {
				logger.Infoln(fmt.Sprintf("Removing agent resource: %s from template", resourceName))
				filteredResources = filteredResources[:len(filteredResources)-1]
			}
		case roleResourceType:
			logger.Infoln(fmt.Sprintf("Evaluating if agent resource: %s needs to be removed", resourceName))
			removeRole := true

			for pool, preserve := range agentPoolsToPreserve {
				if strings.Contains(resourceName, "variables('"+pool) && preserve {
					removeRole = false
				}
			}

			if removeRole {
				logger.Infoln(fmt.Sprintf("Removing agent resource: %s from template", resourceName))
				filteredResources = filteredResources[:len(filteredResources)-1]
			}
		case vmExtensionType:
			logger.Infoln(fmt.Sprintf("Evaluating if extension: %s needs to be removed", resourceName))
			logger.Infoln(fmt.Sprintf("agentPoolsToPreserve: %v...", agentPoolsToPreserve))

			removeExtension := true
			for poolName, preserve := range agentPoolsToPreserve {
				if strings.Contains(resourceName, "variables('"+poolName) && preserve {
					removeExtension = false
				}
			}

			if removeExtension {
				logger.Infoln(fmt.Sprintf("Removing extension: %s from template", resourceName))
				filteredResources = filteredResources[:len(filteredResources)-1]
			}
		case storageAccountsResourceType:
			logger.Infoln(fmt.Sprintf("Evaluating if storage account: %s needs to be removed", resourceName))
			logger.Infoln(fmt.Sprintf("agentPoolsToPreserve: %v...", agentPoolsToPreserve))

			removeStorageAccount := true
			for poolName, preserve := range agentPoolsToPreserve {
				if strings.Contains(resourceName, "variables('"+poolName) && preserve {
					removeStorageAccount = false
				}
			}

			if removeStorageAccount {
				logger.Infoln(fmt.Sprintf("Removing storage account: %s from template", resourceName))
				filteredResources = filteredResources[:len(filteredResources)-1]
			}
		case nicResourceType:
			logger.Infoln(fmt.Sprintf("Evaluating if NIC: %s needs to be removed", resourceName))
			logger.Infoln(fmt.Sprintf("agentPoolsToPreserve: %v...", agentPoolsToPreserve))

			removeNIC := true
			for poolName, preserve := range agentPoolsToPreserve {
				if strings.Contains(resourceName, "variables('"+poolName) && preserve {
					removeNIC = false
				}
			}

			if removeNIC {
				logger.Infoln(fmt.Sprintf("Removing NIC: %s from template", resourceName))
				filteredResources = filteredResources[:len(filteredResources)-1]
			}
		}
	}

	templateMap[resourcesFieldName] = filteredResources

	logger.Infoln(fmt.Sprintf("Resource count after running NormalizeResourcesForK8sMasterUpgrade: %d",
		len(templateMap[resourcesFieldName].([]interface{}))))

	logger.Infoln("Running NormalizeForK8sVMASScalingUp....")
	if err := t.NormalizeForK8sVMASScalingUp(logger, templateMap); err != nil {
		log.Fatalln(err)
		return err
	}

	return nil
}