refactor: Improve application layer by restructuring dependencies

Author: manabusakai

init.go

@@ -4,13 +4,9 @@ import (
 	"context"
 	"errors"
 	"flag"
+	"time"
 
-	"github.com/aws/aws-sdk-go-v2/config"
-	"github.com/aws/aws-sdk-go-v2/service/ecs"
-)
-
-var (
-	ecsClient *ecs.Client
+	"github.com/manabusakai/tdtidy/internal/ecs"
 )
 
 var (
@@ -19,23 +15,11 @@ var (
 	familyPrefix    = flag.String("family-prefix", "", "Specify the family name of the task definitions. If specified, filter by family name.")
 )
 
-const (
-	Deregister command = "deregister"
-	Delete     command = "delete"
-)
-
 func New(ctx context.Context) (*App, error) {
-	cfg, err := config.LoadDefaultConfig(ctx)
-	if err != nil {
-		return nil, err
-	}
-	ecsClient = ecs.NewFromConfig(cfg)
-
 	opt, err := initOption()
 	if err != nil {
 		return nil, err
 	}
-
 	return &App{
 		ctx: ctx,
 		opt: opt,
@@ -52,9 +36,6 @@ func initOption() (*option, error) {
 	cmd, args := args[0], args[1:]
 	flag.CommandLine.Parse(args)
 
-	debug.Printf("subcommand: %s", cmd)
-	debug.Printf("dryRun: %t, retentionPeriod: %d, familyPrefix: %q", *dryRun, *retentionPeriod, *familyPrefix)
-
 	if *familyPrefix == "" {
 		familyPrefix = nil
 	}
@@ -66,3 +47,40 @@ func initOption() (*option, error) {
 		familyPrefix:    familyPrefix,
 	}, nil
 }
+
+type command string
+
+const (
+	Deregister command = "deregister"
+	Delete     command = "delete"
+)
+
+type option struct {
+	subcommand      command
+	dryRun          *bool
+	retentionPeriod *int
+	familyPrefix    *string
+}
+
+func (opt *option) threshold() time.Time {
+	return time.Now().AddDate(0, 0, -(*opt.retentionPeriod)).UTC()
+}
+
+type App struct {
+	ctx context.Context
+	opt *option
+}
+
+func (app *App) Run() {
+	debug.Printf("options: {subcommand: %s, dryRun: %t, retentionPeriod: %d, familyPrefix: %q}",
+		app.opt.subcommand,
+		*app.opt.dryRun,
+		*app.opt.retentionPeriod,
+		*app.opt.familyPrefix,
+	)
+	debug.Printf("threshold: %s", app.opt.threshold().Format(time.DateTime))
+
+	client := ecs.NewClient(app.ctx)
+	processor := NewProcessor(client, app.opt)
+	processor.Process()
+}

internal/ecs/client.go

@@ -0,0 +1,139 @@
+package ecs
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/service/ecs"
+	"github.com/aws/aws-sdk-go-v2/service/ecs/types"
+	"github.com/samber/lo"
+)
+
+const (
+	// The refill rate for API actions per second.
+	// https://docs.aws.amazon.com/AmazonECS/latest/APIReference/request-throttling.html
+	refillRate = 1
+)
+
+type TaskDefinition struct {
+	Arn            *string
+	Family         *string
+	Revision       int32
+	RegisteredAt   *time.Time
+	DeregisteredAt *time.Time
+}
+
+type TaskDefinitionStatus types.TaskDefinitionStatus
+
+const (
+	TaskDefinitionStatusActive   TaskDefinitionStatus = "ACTIVE"
+	TaskDefinitionStatusInactive TaskDefinitionStatus = "INACTIVE"
+)
+
+type Client interface {
+	ListTaskDefinitionStatus() []TaskDefinitionStatus
+	ListTaskDefinitions(familyPrefix *string, status TaskDefinitionStatus) ([]TaskDefinition, error)
+	DeregisterTaskDefinitions(tds []TaskDefinition) ([]TaskDefinition, error)
+	DeleteTaskDefinitions(tds []TaskDefinition) ([]TaskDefinition, error)
+}
+
+type client struct {
+	ctx       context.Context
+	ecsClient *ecs.Client
+}
+
+func NewClient(ctx context.Context) Client {
+	cfg, err := config.LoadDefaultConfig(ctx)
+	if err != nil {
+		log.Fatal(err)
+	}
+	ecsClient := ecs.NewFromConfig(cfg)
+	return &client{
+		ctx:       ctx,
+		ecsClient: ecsClient,
+	}
+}
+
+func (c *client) ListTaskDefinitionStatus() []TaskDefinitionStatus {
+	return []TaskDefinitionStatus{
+		TaskDefinitionStatusActive,
+		TaskDefinitionStatusInactive,
+	}
+}
+
+func (c *client) ListTaskDefinitions(familyPrefix *string, status TaskDefinitionStatus) ([]TaskDefinition, error) {
+	out := make([]TaskDefinition, 0)
+	p := ecs.NewListTaskDefinitionsPaginator(c.ecsClient, &ecs.ListTaskDefinitionsInput{
+		FamilyPrefix: familyPrefix,
+		Status:       types.TaskDefinitionStatus(status),
+	})
+	for p.HasMorePages() {
+		res, err := p.NextPage(c.ctx)
+		if err != nil {
+			return nil, err
+		}
+		for _, arn := range res.TaskDefinitionArns {
+			res, err := c.ecsClient.DescribeTaskDefinition(c.ctx, &ecs.DescribeTaskDefinitionInput{
+				TaskDefinition: &arn,
+			})
+			if err != nil {
+				return nil, err
+			}
+			out = append(out, mapToTaskDefinition(res.TaskDefinition))
+		}
+	}
+	return out, nil
+}
+
+func (c *client) DeregisterTaskDefinitions(tds []TaskDefinition) ([]TaskDefinition, error) {
+	out := make([]TaskDefinition, 0)
+	for _, td := range tds {
+		res, err := c.ecsClient.DeregisterTaskDefinition(c.ctx, &ecs.DeregisterTaskDefinitionInput{
+			TaskDefinition: td.Arn,
+		})
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, mapToTaskDefinition(res.TaskDefinition))
+		sleep()
+	}
+	return out, nil
+}
+
+func (c *client) DeleteTaskDefinitions(tds []TaskDefinition) ([]TaskDefinition, error) {
+	out := make([]TaskDefinition, 0)
+	maxDeletions := 10
+	chunks := lo.Chunk(tds, maxDeletions)
+	for _, tds := range chunks {
+		arns := lo.Map(tds, func(td TaskDefinition, _ int) string {
+			return *td.Arn
+		})
+		res, err := c.ecsClient.DeleteTaskDefinitions(c.ctx, &ecs.DeleteTaskDefinitionsInput{
+			TaskDefinitions: arns,
+		})
+		if err != nil {
+			return nil, err
+		}
+		for _, td := range res.TaskDefinitions {
+			out = append(out, mapToTaskDefinition(&td))
+		}
+		sleep()
+	}
+	return out, nil
+}
+
+func mapToTaskDefinition(td *types.TaskDefinition) TaskDefinition {
+	return TaskDefinition{
+		Arn:            td.TaskDefinitionArn,
+		Family:         td.Family,
+		Revision:       td.Revision,
+		RegisteredAt:   td.RegisteredAt,
+		DeregisteredAt: td.DeregisteredAt,
+	}
+}
+
+func sleep() {
+	time.Sleep(refillRate * time.Second)
+}

processor.go

@@ -0,0 +1,112 @@
+package tdtidy
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/manabusakai/tdtidy/internal/ecs"
+)
+
+type Processor struct {
+	client ecs.Client
+	opt    *option
+}
+
+func NewProcessor(client ecs.Client, opt *option) *Processor {
+	return &Processor{
+		client: client,
+		opt:    opt,
+	}
+}
+
+func (p *Processor) Process() {
+	tds := make(map[ecs.TaskDefinitionStatus][]ecs.TaskDefinition)
+	for _, status := range p.client.ListTaskDefinitionStatus() {
+		res, err := p.client.ListTaskDefinitions(p.opt.familyPrefix, status)
+		if err != nil {
+			log.Fatal(err)
+		}
+		tds[status] = p.filterTaskDefinitions(res)
+	}
+
+	err := p.executeSubcommand(tds)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func (p *Processor) filterTaskDefinitions(tds []ecs.TaskDefinition) []ecs.TaskDefinition {
+	filteredTds := make([]ecs.TaskDefinition, 0)
+	for _, td := range tds {
+		if p.isValidTaskDefinition(&td, p.opt.threshold()) {
+			filteredTds = append(filteredTds, td)
+		}
+	}
+	return filteredTds
+}
+
+func (p *Processor) isValidTaskDefinition(td *ecs.TaskDefinition, threshold time.Time) bool {
+	// Check if RegisteredAt is missing
+	if td.RegisteredAt == nil {
+		return false
+	}
+	// If not deregistered, RegisteredAt should be before threshold
+	if td.DeregisteredAt == nil && td.RegisteredAt.After(threshold) {
+		return false
+	}
+	// If deregistered, DeregisteredAt should be before threshold
+	if td.DeregisteredAt != nil && td.DeregisteredAt.After(threshold) {
+		return false
+	}
+	return true
+}
+
+func (p *Processor) executeSubcommand(tds map[ecs.TaskDefinitionStatus][]ecs.TaskDefinition) error {
+	var (
+		targetTds []ecs.TaskDefinition
+		action    func([]ecs.TaskDefinition) ([]ecs.TaskDefinition, error)
+	)
+	switch p.opt.subcommand {
+	case Deregister:
+		targetTds = tds[ecs.TaskDefinitionStatusActive]
+		action = p.client.DeregisterTaskDefinitions
+	case Delete:
+		targetTds = tds[ecs.TaskDefinitionStatusInactive]
+		action = p.client.DeleteTaskDefinitions
+	default:
+		return fmt.Errorf("unknown subcommand %q", p.opt.subcommand)
+	}
+
+	if len(targetTds) == 0 {
+		return nil
+	}
+	if *p.opt.dryRun {
+		p.printSummary(targetTds)
+		return nil
+	}
+
+	res, err := action(targetTds)
+	if err != nil {
+		return err
+	}
+	p.printSummary(res)
+	return nil
+}
+
+func (p *Processor) printSummary(tds []ecs.TaskDefinition) {
+	logPrefixes := map[command]string{
+		Deregister: "Deregistered",
+		Delete:     "Deleted",
+	}
+	logPrefix, ok := logPrefixes[p.opt.subcommand]
+	if !ok {
+		logPrefix = "Unknown"
+	}
+	if *p.opt.dryRun {
+		logPrefix = "[dry-run] " + logPrefix
+	}
+	for _, td := range tds {
+		fmt.Printf("%s: %s:%d\n", logPrefix, *td.Family, td.Revision)
+	}
+}