func()

in internal/pkg/deploy/cloudformation/stack/lb_web_svc.go [126:247]
114 lines of code
20 McCabe index (conditional complexity)

func (s *LoadBalancedWebService) Template() (string, error) {
	rulePriorityLambda, err := s.parser.Read(lbWebSvcRulePriorityGeneratorPath)
	if err != nil {
		return "", fmt.Errorf("read rule priority lambda: %w", err)
	}
	desiredCountLambda, err := s.parser.Read(desiredCountGeneratorPath)
	if err != nil {
		return "", fmt.Errorf("read desired count lambda: %w", err)
	}
	envControllerLambda, err := s.parser.Read(envControllerPath)
	if err != nil {
		return "", fmt.Errorf("read env controller lambda: %w", err)
	}
	addonsParams, err := s.addonsParameters()
	if err != nil {
		return "", err
	}
	addonsOutputs, err := s.addonsOutputs()
	if err != nil {
		return "", err
	}
	sidecars, err := convertSidecar(s.manifest.Sidecars)
	if err != nil {
		return "", fmt.Errorf("convert the sidecar configuration for service %s: %w", s.name, err)
	}
	publishers, err := convertPublish(s.manifest.Publish(), s.rc.AccountID, s.rc.Region, s.app, s.env, s.name)
	if err != nil {
		return "", fmt.Errorf(`convert "publish" field for service %s: %w`, s.name, err)
	}

	advancedCount, err := convertAdvancedCount(s.manifest.Count.AdvancedCount)
	if err != nil {
		return "", fmt.Errorf("convert the advanced count configuration for service %s: %w", s.name, err)
	}

	var autoscaling *template.AutoscalingOpts
	var desiredCountOnSpot *int
	var capacityProviders []*template.CapacityProviderStrategy

	if advancedCount != nil {
		autoscaling = advancedCount.Autoscaling
		desiredCountOnSpot = advancedCount.Spot
		capacityProviders = advancedCount.Cps
	}

	entrypoint, err := convertEntryPoint(s.manifest.EntryPoint)
	if err != nil {
		return "", err
	}
	command, err := convertCommand(s.manifest.Command)
	if err != nil {
		return "", err
	}

	var aliases []string
	if s.httpsEnabled {
		if aliases, err = convertAlias(s.manifest.RoutingRule.Alias); err != nil {
			return "", err
		}
	}

	var deregistrationDelay *int64 = aws.Int64(60)
	if s.manifest.RoutingRule.DeregistrationDelay != nil {
		deregistrationDelay = aws.Int64(int64(s.manifest.RoutingRule.DeregistrationDelay.Seconds()))
	}

	var allowedSourceIPs []string
	for _, ipNet := range s.manifest.RoutingRule.AllowedSourceIps {
		allowedSourceIPs = append(allowedSourceIPs, string(ipNet))
	}

	nlbConfig, err := s.convertNetworkLoadBalancer()
	if err != nil {
		return "", err
	}
	content, err := s.parser.ParseLoadBalancedWebService(template.WorkloadOpts{
		Variables:                      s.manifest.TaskConfig.Variables,
		Secrets:                        convertSecrets(s.manifest.TaskConfig.Secrets),
		Aliases:                        aliases,
		NestedStack:                    addonsOutputs,
		AddonsExtraParams:              addonsParams,
		Sidecars:                       sidecars,
		LogConfig:                      convertLogging(s.manifest.Logging),
		DockerLabels:                   s.manifest.ImageConfig.Image.DockerLabels,
		Autoscaling:                    autoscaling,
		CapacityProviders:              capacityProviders,
		DesiredCountOnSpot:             desiredCountOnSpot,
		ExecuteCommand:                 convertExecuteCommand(&s.manifest.ExecuteCommand),
		WorkloadType:                   manifest.LoadBalancedWebServiceType,
		HealthCheck:                    convertContainerHealthCheck(s.manifest.ImageConfig.HealthCheck),
		HTTPHealthCheck:                convertHTTPHealthCheck(&s.manifest.RoutingRule.HealthCheck),
		DeregistrationDelay:            deregistrationDelay,
		AllowedSourceIps:               allowedSourceIPs,
		RulePriorityLambda:             rulePriorityLambda.String(),
		DesiredCountLambda:             desiredCountLambda.String(),
		EnvControllerLambda:            envControllerLambda.String(),
		Storage:                        convertStorageOpts(s.manifest.Name, s.manifest.Storage),
		Network:                        convertNetworkConfig(s.manifest.Network),
		EntryPoint:                     entrypoint,
		Command:                        command,
		DependsOn:                      convertDependsOn(s.manifest.ImageConfig.Image.DependsOn),
		CredentialsParameter:           aws.StringValue(s.manifest.ImageConfig.Image.Credentials),
		ServiceDiscoveryEndpoint:       s.rc.ServiceDiscoveryEndpoint,
		Publish:                        publishers,
		Platform:                       convertPlatform(s.manifest.Platform),
		HTTPVersion:                    convertHTTPVersion(s.manifest.RoutingRule.ProtocolVersion),
		NLB:                            nlbConfig.settings,
		AppDNSName:                     nlbConfig.appDNSName,
		AppDNSDelegationRole:           nlbConfig.appDNSDelegationRole,
		NLBCertValidatorFunctionLambda: nlbConfig.certValidatorLambda,
		NLBCustomDomainFunctionLambda:  nlbConfig.customDomainLambda,
		ALBEnabled:                     !s.manifest.RoutingRule.Disabled(),
	})
	if err != nil {
		return "", err
	}
	overridenTpl, err := s.taskDefOverrideFunc(convertTaskDefOverrideRules(s.manifest.TaskDefOverrides), content.Bytes())
	if err != nil {
		return "", fmt.Errorf("apply task definition overrides: %w", err)
	}
	return string(overridenTpl), nil
}