func()

in internal/pkg/cli/deploy/deploy.go [474:577]
96 lines of code
21 McCabe index (conditional complexity)

func (d *workloadDeployer) stackConfiguration(in *DeployWorkloadInput) (*stackConfigurationOutput, error) {
	rc, err := d.runtimeConfig(in)
	if err != nil {
		return nil, err
	}
	in.NewSvcUpdater(func(s *session.Session) ServiceForceUpdater {
		return ecs.New(s)
	})
	var output stackConfigurationOutput
	switch t := d.mft.(type) {
	case *manifest.LoadBalancedWebService:
		if err := validateLBWSRuntime(d.app, d.env.Name, t, in.AppVersionGetter); err != nil {
			return nil, err
		}

		var opts []stack.LoadBalancedWebServiceOption
		if !t.NLBConfig.IsEmpty() {
			cidrBlocks, err := in.PublicCIDRBlocksGetter.PublicCIDRBlocks()
			if err != nil {
				return nil, fmt.Errorf("get public CIDR blocks information from the VPC of environment %s: %w", d.env.Name, err)
			}
			opts = append(opts, stack.WithNLB(cidrBlocks))
		}
		if d.app.RequiresDNSDelegation() {
			opts = append(opts, stack.WithDNSDelegation(deploy.AppInformation{
				Name:                d.app.Name,
				DNSName:             d.app.Domain,
				AccountPrincipalARN: in.RootUserARN,
			}))

			if !t.RoutingRule.Disabled() {
				opts = append(opts, stack.WithHTTPS())
			}
		}
		output.conf, err = stack.NewLoadBalancedWebService(t, d.env.Name, d.app.Name, *rc, opts...)
	case *manifest.RequestDrivenWebService:
		if d.app.Domain == "" && t.Alias != nil {
			log.Errorf(aliasUsedWithoutDomainFriendlyText)
			return nil, errors.New("alias specified when application is not associated with a domain")
		}
		in.NewSvcUpdater(func(s *session.Session) ServiceForceUpdater {
			return apprunner.New(s)
		})
		appInfo := deploy.AppInformation{
			Name:                d.app.Name,
			DNSName:             d.app.Domain,
			AccountPrincipalARN: in.RootUserARN,
		}
		if t.Alias == nil {
			output.conf, err = stack.NewRequestDrivenWebService(t, d.env.Name, appInfo, *rc)
			break
		}

		output.rdSvcAlias = aws.StringValue(t.Alias)

		if err = validateRDSvcAliasAndAppVersion(d.name,
			aws.StringValue(t.Alias), d.env.Name, d.app, in.AppVersionGetter); err != nil {
			return nil, err
		}
		var urls map[string]string
		if urls, err = uploadRDWSCustomResources(&uploadRDWSCustomResourcesInput{
			customResourceUploader: in.CustomResourceUploader,
			s3Uploader:             in.S3Uploader,
			s3Bucket:               d.s3Bucket,
		}); err != nil {
			return nil, err
		}
		output.conf, err = stack.NewRequestDrivenWebServiceWithAlias(t, d.env.Name, appInfo, *rc, urls)
	case *manifest.BackendService:
		output.conf, err = stack.NewBackendService(t, d.env.Name, d.app.Name, *rc)
	case *manifest.WorkerService:
		var topics []deploy.Topic
		topics, err = in.SNSTopicsLister.ListSNSTopics(d.app.Name, d.env.Name)
		if err != nil {
			return nil, fmt.Errorf("get SNS topics for app %s and environment %s: %w", d.app.Name, d.env.Name, err)
		}
		var topicARNs []string
		for _, topic := range topics {
			topicARNs = append(topicARNs, topic.ARN())
		}
		type subscriptions interface {
			Subscriptions() []manifest.TopicSubscription
		}

		subscriptionGetter, ok := d.mft.(subscriptions)
		if !ok {
			return nil, errors.New("manifest does not have required method Subscriptions")
		}
		// Cache the subscriptions for later.
		output.subscriptions = subscriptionGetter.Subscriptions()

		if err = validateTopicsExist(output.subscriptions, topicARNs, d.app.Name, d.env.Name); err != nil {
			return nil, err
		}
		output.conf, err = stack.NewWorkerService(t, d.env.Name, d.app.Name, *rc)

	default:
		return nil, fmt.Errorf("unknown manifest type %T while creating the CloudFormation stack", t)
	}
	if err != nil {
		return nil, fmt.Errorf("create stack configuration: %w", err)
	}
	return &output, nil
}