func()

in pkg/engine/transform/transform.go [254:348]

• 81 lines of code
• 30 McCabe index (conditional complexity)

func (t *Transformer) NormalizeForK8sVMASScalingUp(logger *logrus.Entry, templateMap map[string]interface{}) error {
	if err := t.RemoveResourcesAndOutputsForScaling(logger, templateMap); err != nil {
		return err
	}
	rtIndex := -1
	nsgIndex := -1
	vnetIndex := -1
	vmasIndexes := make([]int, 0)

	resources := templateMap[resourcesFieldName].([]interface{})
	for index, resource := range resources {
		resourceMap, ok := resource.(map[string]interface{})
		if !ok {
			logger.Warnf("Template improperly formatted for resource")
			continue
		}

		resourceType, ok := resourceMap[typeFieldName].(string)
		resourceName := resourceMap[nameFieldName].(string)

		if ok && resourceType == nsgResourceType && !strings.Contains(resourceName, "variables('jumpboxNetworkSecurityGroupName')") {

			if nsgIndex != -1 {
				err := t.Translator.Errorf("Found 2 resources with type %s in the template. There should only be 1", nsgResourceType)
				logger.Error(err.Error())
				return err
			}
			nsgIndex = index
		}
		if ok && resourceType == rtResourceType {
			if rtIndex != -1 {
				err := t.Translator.Errorf("Found 2 resources with type %s in the template. There should only be 1", rtResourceType)
				logger.Warn(err.Error())
				return err
			}
			rtIndex = index
		}
		if ok && resourceType == vnetResourceType {
			if vnetIndex != -1 {
				err := t.Translator.Errorf("Found 2 resources with type %s in the template. There should only be 1", vnetResourceType)
				logger.Warn(err.Error())
				return err
			}
			vnetIndex = index
		}
		if ok && resourceType == vmasResourceType {
			// All availability sets can be removed
			vmasIndexes = append(vmasIndexes, index)
		}

		dependencies, ok := resourceMap[dependsOnFieldName].([]interface{})
		if !ok {
			continue
		}

		for dIndex := len(dependencies) - 1; dIndex >= 0; dIndex-- {
			dependency := dependencies[dIndex].(string)
			if strings.Contains(dependency, nsgResourceType) || strings.Contains(dependency, nsgID) ||
				strings.Contains(dependency, rtResourceType) || strings.Contains(dependency, rtID) ||
				strings.Contains(dependency, vnetResourceType) || strings.Contains(dependency, vnetID) ||
				strings.Contains(dependency, vmasResourceType) {
				dependencies = append(dependencies[:dIndex], dependencies[dIndex+1:]...)
			}
		}

		if len(dependencies) > 0 {
			resourceMap[dependsOnFieldName] = dependencies
		} else {
			delete(resourceMap, dependsOnFieldName)
		}
	}

	indexesToRemove := []int{}

	if rtIndex == -1 {
		logger.Debugf("Found no resources with type %s in the template.", rtResourceType)
	} else {
		indexesToRemove = append(indexesToRemove, rtIndex)
	}

	if vnetIndex != -1 {
		indexesToRemove = append(indexesToRemove, vnetIndex)
	}

	if len(vmasIndexes) != 0 {
		indexesToRemove = append(indexesToRemove, vmasIndexes...)
	}
	if nsgIndex > 0 {
		indexesToRemove = append(indexesToRemove, nsgIndex)
	}

	templateMap[resourcesFieldName] = removeIndexesFromArray(resources, indexesToRemove)

	return nil
}