func()

in internal/pkg/cli/svc_deploy.go [575:702]
119 lines of code
27 McCabe index (conditional complexity)

func (o *deploySvcOpts) stackConfiguration() (cloudformation.StackConfiguration, error) {
	mft, err := o.manifest()
	if err != nil {
		return nil, err
	}
	rc, err := o.runtimeConfig()
	if err != nil {
		return nil, err
	}
	o.newSvcUpdater(func(s *session.Session) svcForceUpdater {
		return ecs.New(s)
	})
	var conf cloudformation.StackConfiguration
	switch t := mft.(type) {
	case *manifest.LoadBalancedWebService:
		var appVersionGetter versionGetter
		appVersionGetter, err = o.newAppVersionGetter(o.appName)
		if err != nil {
			return nil, fmt.Errorf("new app describer for application %s: %w", o.appName, err)
		}
		if err := validateLBWSRuntime(o.targetApp, o.envName, t, appVersionGetter); err != nil {
			return nil, err
		}

		var opts []stack.LoadBalancedWebServiceOption
		if !t.NLBConfig.IsEmpty() {
			cidrBlocks, err := o.envDescriber.PublicCIDRBlocks()
			if err != nil {
				return nil, fmt.Errorf("get public CIDR blocks information from the VPC of environment %s: %w", o.envName, err)
			}
			opts = append(opts, stack.WithNLB(cidrBlocks))
		}
		if o.targetApp.RequiresDNSDelegation() {
			var caller identity.Caller
			caller, err = o.identity.Get()
			if err != nil {
				return nil, fmt.Errorf("get identity: %w", err)
			}
			opts = append(opts, stack.WithDNSDelegation(deploy.AppInformation{
				Name:                o.targetEnvironment.App,
				DNSName:             o.targetApp.Domain,
				AccountPrincipalARN: caller.RootUserARN,
			}))

			if !t.RoutingRule.Disabled() {
				opts = append(opts, stack.WithHTTPS())
			}
		}
		conf, err = stack.NewLoadBalancedWebService(t, o.targetEnvironment.Name, o.targetEnvironment.App, *rc, opts...)
	case *manifest.RequestDrivenWebService:
		if o.targetApp.Domain == "" && t.Alias != nil {
			log.Errorf(aliasUsedWithoutDomainFriendlyText)
			return nil, errors.New("alias specified when application is not associated with a domain")
		}
		o.newSvcUpdater(func(s *session.Session) svcForceUpdater {
			return apprunner.New(s)
		})
		var caller identity.Caller
		caller, err = o.identity.Get()
		if err != nil {
			return nil, fmt.Errorf("get identity: %w", err)
		}
		appInfo := deploy.AppInformation{
			Name:                o.targetEnvironment.App,
			DNSName:             o.targetApp.Domain,
			AccountPrincipalARN: caller.RootUserARN,
		}
		if t.Alias == nil {
			conf, err = stack.NewRequestDrivenWebService(t, o.targetEnvironment.Name, appInfo, *rc)
			break
		}

		o.rdSvcAlias = aws.StringValue(t.Alias)
		var (
			urls             map[string]string
			appVersionGetter versionGetter
		)
		if appVersionGetter, err = o.newAppVersionGetter(o.appName); err != nil {
			return nil, err
		}

		if err = validateRDSvcAliasAndAppVersion(o.name, aws.StringValue(t.Alias), o.envName, o.targetApp, appVersionGetter); err != nil {
			return nil, err
		}

		if err = o.retrieveAppResourcesForEnvRegion(); err != nil {
			return nil, err
		}
		if urls, err = uploadRDWSCustomResources(o.uploadOpts, o.appEnvResources); err != nil {
			return nil, err
		}
		conf, err = stack.NewRequestDrivenWebServiceWithAlias(t, o.targetEnvironment.Name, appInfo, *rc, urls)
	case *manifest.BackendService:
		conf, err = stack.NewBackendService(t, o.targetEnvironment.Name, o.targetEnvironment.App, *rc)
	case *manifest.WorkerService:
		var topics []deploy.Topic
		topics, err = o.snsTopicGetter.ListSNSTopics(o.appName, o.envName)
		if err != nil {
			return nil, fmt.Errorf("get SNS topics for app %s and environment %s: %w", o.appName, o.envName, err)
		}
		var topicARNs []string
		for _, topic := range topics {
			topicARNs = append(topicARNs, topic.ARN())
		}
		type subscriptions interface {
			Subscriptions() []manifest.TopicSubscription
		}

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

		if err = validateTopicsExist(o.subscriptions, topicARNs, o.appName, o.envName); err != nil {
			return nil, err
		}
		conf, err = stack.NewWorkerService(t, o.targetEnvironment.Name, o.targetEnvironment.App, *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 conf, nil
}