func()

in pkg/engine/transform/transform.go [434:562]
112 lines of code
30 McCabe index (conditional complexity)

func (t *Transformer) NormalizeResourcesForK8sMasterUpgrade(logger *logrus.Entry, templateMap map[string]interface{}, isMasterManagedDisk bool, agentPoolsToPreserve map[string]bool) error {
	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,
		publicIPAddressResourceType: true, storageAccountsResourceType: true,
		keyVaultResourceType: true, rtResourceType: true,
		userAssignedIdentityResourceType: true}
	logger.Infoln(fmt.Sprintf("Resource count before running NormalizeResourcesForK8sMasterUpgrade: %d", len(resources)))

	filteredResources := resources[:0]

	// remove agent nodes resources if needed and set dataDisk createOption to attach
	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
		}

		switch resourceType {
		case vmssResourceType, vmResourceType, vmExtensionType, roleResourceType, nicResourceType:
			if !strings.Contains(resourceName, "variables('masterVMNamePrefix')") {
				filteredResources = filteredResources[:len(filteredResources)-1]
				continue
			}
			if resourceType == nicResourceType {
				delete(resourceMap, dependsOnFieldName)
			}
		case nsgResourceType:
			if strings.Contains(resourceName, "variables('nsgName')") {
				filteredResources = filteredResources[:len(filteredResources)-1]
				continue
			}
		case publicIPAddressResourceType, rtResourceType, userAssignedIdentityResourceType:
			filteredResources = filteredResources[:len(filteredResources)-1]
			continue
		case lbResourceType:
			if strings.Contains(resourceName, "variables('masterInternalLbName')") || strings.Contains(resourceName, "variables('masterLbName')") {
				filteredResources = filteredResources[:len(filteredResources)-1]
				continue
			}
		case vnetResourceType:
			if strings.Contains(resourceName, "variables('virtualNetworkName')") {
				filteredResources = filteredResources[:len(filteredResources)-1]
				continue
			}
		case storageAccountsResourceType:
			if !strings.Contains(resourceName, "variables('clusterKeyVaultName')") {
				filteredResources = filteredResources[:len(filteredResources)-1]
				continue
			}
		case keyVaultResourceType:
			if !strings.Contains(resourceName, "variables('clusterKeyVaultName')") {
				filteredResources = filteredResources[:len(filteredResources)-1]
				continue
			}
		}

		if resourceType == vmssResourceType || resourceType == vnetResourceType {
			RemoveNsgDependency(logger, resourceName, resourceMap)
			continue
		}

		if strings.EqualFold(resourceType, vmResourceType) &&
			strings.Contains(resourceName, "variables('masterVMNamePrefix')") {
			resourceProperties, ok := resourceMap[propertiesFieldName].(map[string]interface{})
			if !ok {
				logger.Warnf("Template improperly formatted for field name: %s, resource name: %s", propertiesFieldName, resourceName)
				continue
			}

			storageProfile, ok := resourceProperties[storageProfileFieldName].(map[string]interface{})
			if !ok {
				logger.Warnf("Template improperly formatted: %s", storageProfileFieldName)
				continue
			}

			dataDisks, ok := storageProfile[dataDisksFieldName].([]interface{})
			if !ok {
				logger.Warnf("Template improperly formatted for field name: %s, property name: %s", storageProfileFieldName, dataDisksFieldName)
				continue
			}

			dataDisk, ok := dataDisks[0].(map[string]interface{})
			if !ok {
				logger.Warnf("Template improperly formatted for field name: %s, there is no data disks defined", dataDisksFieldName)
				continue
			}

			dataDisk[createOptionFieldName] = "attach"

			if isMasterManagedDisk {
				managedDisk := compute.ManagedDiskParameters{}
				id := "[concat('/subscriptions/', variables('subscriptionId'), '/resourceGroups/', variables('resourceGroup'),'/providers/Microsoft.Compute/disks/', variables('masterVMNamePrefix'), copyIndex(variables('masterOffset')),'-etcddisk')]"
				managedDisk.ID = &id
				diskInterface := &managedDisk
				dataDisk[managedDiskFieldName] = diskInterface
			}
		}
	}

	templateMap[resourcesFieldName] = filteredResources
	delete(templateMap, outputsFieldName)

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