func()

in internal/pkg/describe/status_describe.go [158:244]
82 lines of code
17 McCabe index (conditional complexity)

func (s *ecsStatusDescriber) Describe() (HumanJSONStringer, error) {
	svcDesc, err := s.svcDescriber.DescribeService(s.app, s.env, s.svc)
	if err != nil {
		return nil, fmt.Errorf("get ECS service description for %s: %w", s.svc, err)
	}
	service, err := s.ecsSvcGetter.Service(svcDesc.ClusterName, svcDesc.Name)
	if err != nil {
		return nil, fmt.Errorf("get service %s: %w", svcDesc.Name, err)
	}

	var taskStatus []awsecs.TaskStatus
	for _, task := range svcDesc.Tasks {
		status, err := task.TaskStatus()
		if err != nil {
			return nil, fmt.Errorf("get status for task %s: %w", aws.StringValue(task.TaskArn), err)
		}
		taskStatus = append(taskStatus, *status)
	}

	var stoppedTaskStatus []awsecs.TaskStatus
	for _, task := range svcDesc.StoppedTasks {
		status, err := task.TaskStatus()
		if err != nil {
			return nil, fmt.Errorf("get status for stopped task %s: %w", aws.StringValue(task.TaskArn), err)
		}
		stoppedTaskStatus = append(stoppedTaskStatus, *status)
	}
	// Using a map then converting it to a slice to avoid duplication.
	alarms := make(map[string]cloudwatch.AlarmStatus)
	taggedAlarms, err := s.cwSvcGetter.AlarmsWithTags(map[string]string{
		deploy.AppTagKey:     s.app,
		deploy.EnvTagKey:     s.env,
		deploy.ServiceTagKey: s.svc,
	})
	if err != nil {
		return nil, fmt.Errorf("get tagged CloudWatch alarms: %w", err)
	}
	for _, alarm := range taggedAlarms {
		alarms[alarm.Name] = alarm
	}
	autoscalingAlarms, err := s.ecsServiceAutoscalingAlarms(svcDesc.ClusterName, svcDesc.Name)
	if err != nil {
		return nil, err
	}
	for _, alarm := range autoscalingAlarms {
		alarms[alarm.Name] = alarm
	}
	rollbackAlarms, err := s.ecsServiceRollbackAlarms(s.app, s.env, s.svc)
	if err != nil {
		return nil, err
	}
	for _, alarm := range rollbackAlarms {
		alarms[alarm.Name] = alarm
	}
	alarmList := make([]cloudwatch.AlarmStatus, len(alarms))
	var i int
	for _, v := range alarms {
		alarmList[i] = v
		i++
	}
	// Sort by alarm type, then alarm name within type categories.
	sort.SliceStable(alarmList, func(i, j int) bool { return alarmList[i].Name < alarmList[j].Name })
	sort.SliceStable(alarmList, func(i, j int) bool { return alarmList[i].Type < alarmList[j].Type })
	var tasksTargetHealth []taskTargetHealth
	targetGroupsARN := service.TargetGroups()
	for _, groupARN := range targetGroupsARN {
		targetsHealth, err := s.targetHealthGetter.TargetsHealth(groupARN)
		if err != nil {
			continue
		}
		tasksTargetHealth = append(tasksTargetHealth, targetHealthForTasks(targetsHealth, svcDesc.Tasks, groupARN)...)
	}
	sort.SliceStable(tasksTargetHealth, func(i, j int) bool {
		if tasksTargetHealth[i].TargetGroupARN == tasksTargetHealth[j].TargetGroupARN {
			return tasksTargetHealth[i].TaskID < tasksTargetHealth[j].TaskID
		}
		return tasksTargetHealth[i].TargetGroupARN < tasksTargetHealth[j].TargetGroupARN
	})

	return &ecsServiceStatus{
		Service:                  service.ServiceStatus(),
		DesiredRunningTasks:      taskStatus,
		Alarms:                   alarmList,
		StoppedTasks:             stoppedTaskStatus,
		TargetHealthDescriptions: tasksTargetHealth,
	}, nil
}