func BuildAzureConfig()

in cluster-autoscaler/cloudprovider/azure/azure_config.go [132:286]
134 lines of code
35 McCabe index (conditional complexity)

func BuildAzureConfig(configReader io.Reader) (*Config, error) {
	var err error
	cfg := &Config{}

	if configReader != nil {
		body, err := ioutil.ReadAll(configReader)
		if err != nil {
			return nil, fmt.Errorf("failed to read config: %v", err)
		}
		err = json.Unmarshal(body, cfg)
		if err != nil {
			return nil, fmt.Errorf("failed to unmarshal config body: %v", err)
		}
	} else {
		cfg.Cloud = os.Getenv("ARM_CLOUD")
		cfg.Location = os.Getenv("LOCATION")
		cfg.ResourceGroup = os.Getenv("ARM_RESOURCE_GROUP")
		cfg.SubscriptionID = os.Getenv("ARM_SUBSCRIPTION_ID")
		cfg.TenantID = os.Getenv("ARM_TENANT_ID")
		cfg.AADClientID = os.Getenv("ARM_CLIENT_ID")
		cfg.AADClientSecret = os.Getenv("ARM_CLIENT_SECRET")
		cfg.VMType = strings.ToLower(os.Getenv("ARM_VM_TYPE"))
		cfg.AADClientCertPath = os.Getenv("ARM_CLIENT_CERT_PATH")
		cfg.AADClientCertPassword = os.Getenv("ARM_CLIENT_CERT_PASSWORD")
		cfg.Deployment = os.Getenv("ARM_DEPLOYMENT")
		cfg.ClusterName = os.Getenv("AZURE_CLUSTER_NAME")
		cfg.NodeResourceGroup = os.Getenv("AZURE_NODE_RESOURCE_GROUP")

		useManagedIdentityExtensionFromEnv := os.Getenv("ARM_USE_MANAGED_IDENTITY_EXTENSION")
		if len(useManagedIdentityExtensionFromEnv) > 0 {
			cfg.UseManagedIdentityExtension, err = strconv.ParseBool(useManagedIdentityExtensionFromEnv)
			if err != nil {
				return nil, err
			}
		}

		userAssignedIdentityIDFromEnv := os.Getenv("ARM_USER_ASSIGNED_IDENTITY_ID")
		if userAssignedIdentityIDFromEnv != "" {
			cfg.UserAssignedIdentityID = userAssignedIdentityIDFromEnv
		}

		if vmssCacheTTL := os.Getenv("AZURE_VMSS_CACHE_TTL"); vmssCacheTTL != "" {
			cfg.VmssCacheTTL, err = strconv.ParseInt(vmssCacheTTL, 10, 0)
			if err != nil {
				return nil, fmt.Errorf("failed to parse AZURE_VMSS_CACHE_TTL %q: %v", vmssCacheTTL, err)
			}
		}

		if vmssVmsCacheTTL := os.Getenv("AZURE_VMSS_VMS_CACHE_TTL"); vmssVmsCacheTTL != "" {
			cfg.VmssVmsCacheTTL, err = strconv.ParseInt(vmssVmsCacheTTL, 10, 0)
			if err != nil {
				return nil, fmt.Errorf("failed to parse AZURE_VMSS_VMS_CACHE_TTL %q: %v", vmssVmsCacheTTL, err)
			}
		}

		if vmssVmsCacheJitter := os.Getenv("AZURE_VMSS_VMS_CACHE_JITTER"); vmssVmsCacheJitter != "" {
			cfg.VmssVmsCacheJitter, err = strconv.Atoi(vmssVmsCacheJitter)
			if err != nil {
				return nil, fmt.Errorf("failed to parse AZURE_VMSS_VMS_CACHE_JITTER %q: %v", vmssVmsCacheJitter, err)
			}
		}

		if threshold := os.Getenv("AZURE_MAX_DEPLOYMENT_COUNT"); threshold != "" {
			cfg.MaxDeploymentsCount, err = strconv.ParseInt(threshold, 10, 0)
			if err != nil {
				return nil, fmt.Errorf("failed to parse AZURE_MAX_DEPLOYMENT_COUNT %q: %v", threshold, err)
			}
		}

		if enableBackoff := os.Getenv("ENABLE_BACKOFF"); enableBackoff != "" {
			cfg.CloudProviderBackoff, err = strconv.ParseBool(enableBackoff)
			if err != nil {
				return nil, fmt.Errorf("failed to parse ENABLE_BACKOFF %q: %v", enableBackoff, err)
			}
		}

		if cfg.CloudProviderBackoff {
			if backoffRetries := os.Getenv("BACKOFF_RETRIES"); backoffRetries != "" {
				retries, err := strconv.ParseInt(backoffRetries, 10, 0)
				if err != nil {
					return nil, fmt.Errorf("failed to parse BACKOFF_RETRIES %q: %v", retries, err)
				}
				cfg.CloudProviderBackoffRetries = int(retries)
			} else {
				cfg.CloudProviderBackoffRetries = backoffRetriesDefault
			}

			if backoffExponent := os.Getenv("BACKOFF_EXPONENT"); backoffExponent != "" {
				cfg.CloudProviderBackoffExponent, err = strconv.ParseFloat(backoffExponent, 64)
				if err != nil {
					return nil, fmt.Errorf("failed to parse BACKOFF_EXPONENT %q: %v", backoffExponent, err)
				}
			} else {
				cfg.CloudProviderBackoffExponent = backoffExponentDefault
			}

			if backoffDuration := os.Getenv("BACKOFF_DURATION"); backoffDuration != "" {
				duration, err := strconv.ParseInt(backoffDuration, 10, 0)
				if err != nil {
					return nil, fmt.Errorf("failed to parse BACKOFF_DURATION %q: %v", backoffDuration, err)
				}
				cfg.CloudProviderBackoffDuration = int(duration)
			} else {
				cfg.CloudProviderBackoffDuration = backoffDurationDefault
			}

			if backoffJitter := os.Getenv("BACKOFF_JITTER"); backoffJitter != "" {
				cfg.CloudProviderBackoffJitter, err = strconv.ParseFloat(backoffJitter, 64)
				if err != nil {
					return nil, fmt.Errorf("failed to parse BACKOFF_JITTER %q: %v", backoffJitter, err)
				}
			} else {
				cfg.CloudProviderBackoffJitter = backoffJitterDefault
			}
		}
	}
	cfg.TrimSpace()

	if cloudProviderRateLimit := os.Getenv("CLOUD_PROVIDER_RATE_LIMIT"); cloudProviderRateLimit != "" {
		cfg.CloudProviderRateLimit, err = strconv.ParseBool(cloudProviderRateLimit)
		if err != nil {
			return nil, fmt.Errorf("failed to parse CLOUD_PROVIDER_RATE_LIMIT: %q, %v", cloudProviderRateLimit, err)
		}
	}

	err = initializeCloudProviderRateLimitConfig(&cfg.CloudProviderRateLimitConfig)
	if err != nil {
		return nil, err
	}

	// Defaulting vmType to vmss.
	if cfg.VMType == "" {
		cfg.VMType = vmTypeVMSS
	}

	// Read parameters from deploymentParametersPath if it is not set.
	if cfg.VMType == vmTypeStandard && len(cfg.DeploymentParameters) == 0 {
		parameters, err := readDeploymentParameters(deploymentParametersPath)
		if err != nil {
			klog.Errorf("readDeploymentParameters failed with error: %v", err)
			return nil, err
		}

		cfg.DeploymentParameters = parameters
	}

	if cfg.MaxDeploymentsCount == 0 {
		cfg.MaxDeploymentsCount = int64(defaultMaxDeploymentsCount)
	}

	if err := cfg.validate(); err != nil {
		return nil, err
	}
	return cfg, nil
}