func()

in internal/pkg/cli/app_show.go [137:230]
91 lines of code
16 McCabe index (conditional complexity)

func (o *showAppOpts) description() (*describe.App, error) {
	app, err := o.store.GetApplication(o.name)
	if err != nil {
		return nil, fmt.Errorf("get application %s: %w", o.name, err)
	}
	envs, err := o.store.ListEnvironments(o.name)
	if err != nil {
		return nil, fmt.Errorf("list environments in application %s: %w", o.name, err)
	}
	svcs, err := o.store.ListServices(o.name)
	if err != nil {
		return nil, fmt.Errorf("list services in application %s: %w", o.name, err)
	}
	jobs, err := o.store.ListJobs(o.name)
	if err != nil {
		return nil, fmt.Errorf("list jobs in application %s: %w", o.name, err)
	}
	wkldDeployedtoEnvs := make(map[string][]string)
	ctx, cancelWait := context.WithTimeout(context.Background(), waitForStackTimeout)
	defer cancelWait()
	g, _ := errgroup.WithContext(ctx)
	var mux sync.Mutex
	for i := range envs {
		env := envs[i]
		g.Go(func() error {
			return o.populateDeployedWorkloads(o.deployStore.ListDeployedJobs, wkldDeployedtoEnvs, env.Name, &mux)
		})
		g.Go(func() error {
			return o.populateDeployedWorkloads(o.deployStore.ListDeployedServices, wkldDeployedtoEnvs, env.Name, &mux)
		})
	}
	if err := g.Wait(); err != nil {
		return nil, err
	}
	// Sort the map values so that `output` is consistent and the unit test won't be flaky.
	for k := range wkldDeployedtoEnvs {
		sort.Strings(wkldDeployedtoEnvs[k])
	}

	pipelines, err := o.pipelineLister.ListDeployedPipelines(o.name)
	if err != nil {
		return nil, fmt.Errorf("list pipelines in application %s: %w", o.name, err)
	}
	var pipelineInfo []*codepipeline.Pipeline
	for _, pipeline := range pipelines {
		info, err := o.codepipeline.GetPipeline(pipeline.ResourceName)
		if err != nil {
			return nil, fmt.Errorf("get info for pipeline %s: %w", pipeline.Name, err)
		}
		pipelineInfo = append(pipelineInfo, info)
	}

	var trimmedEnvs []*config.Environment
	for _, env := range envs {
		trimmedEnvs = append(trimmedEnvs, &config.Environment{
			Name:      env.Name,
			AccountID: env.AccountID,
			Region:    env.Region,
		})
	}
	var trimmedSvcs []*config.Workload
	for _, svc := range svcs {
		trimmedSvcs = append(trimmedSvcs, &config.Workload{
			Name: svc.Name,
			Type: svc.Type,
		})
	}
	var trimmedJobs []*config.Workload
	for _, job := range jobs {
		trimmedJobs = append(trimmedJobs, &config.Workload{
			Name: job.Name,
			Type: job.Type,
		})
	}
	versionGetter, err := o.newVersionGetter(o.name)
	if err != nil {
		return nil, err
	}
	version, err := versionGetter.Version()
	if err != nil {
		return nil, fmt.Errorf("get version for application %s: %w", o.name, err)
	}
	return &describe.App{
		Name:                app.Name,
		Version:             version,
		URI:                 app.Domain,
		PermissionsBoundary: app.PermissionsBoundary,
		Envs:                trimmedEnvs,
		Services:            trimmedSvcs,
		Jobs:                trimmedJobs,
		Pipelines:           pipelineInfo,
		WkldDeployedtoEnvs:  wkldDeployedtoEnvs,
	}, nil
}