[ECS] Support Plan Preview for ECS

pkg/app/pipectl/cmd/planpreview/planpreview_test.go

@@ -165,6 +165,13 @@ NOTE: An error occurred while building plan-preview for applications of the foll
 							ApplicationKind: model.ApplicationKind_CLOUDRUN,
 							Error:           "missing key",
 						},
+						{
+							ApplicationId:   "app-5",
+							ApplicationName: "app-5",
+							ApplicationUrl:  "https://pipecd.dev/app-5",
+							ApplicationKind: model.ApplicationKind_ECS,
+							Error:           "wrong application configuration",
+						},
 					},
 				},
 				{
@@ -196,14 +203,17 @@ changes-1
 changes-2
   ---DETAILS_END---
 
-NOTE: An error occurred while building plan-preview for the following 2 applications:
+NOTE: An error occurred while building plan-preview for the following 3 applications:
 
 1. app: app-3, env: env-3, kind: TERRAFORM
   reason: wrong application configuration
 
 2. app: app-4, kind: CLOUDRUN
   reason: missing key
 
+3. app: app-5, kind: ECS
+  reason: wrong application configuration
+
 NOTE: An error occurred while building plan-preview for applications of the following 2 Pipeds:
 
 1. piped: piped-name-1 (piped-1)

pkg/app/piped/planpreview/builder.go

@@ -249,6 +249,8 @@
 		dr, err = b.terraformDiff(ctx, app, targetDSP, &buf)
 	case model.ApplicationKind_CLOUDRUN:
 		dr, err = b.cloudrundiff(ctx, app, targetDSP, preCommit, &buf)
+	case model.ApplicationKind_ECS:
+		dr, err = b.ecsdiff(ctx, app, targetDSP, preCommit, &buf)
 	default:
 		// TODO: Calculating planpreview's diff for other application kinds.
 		dr = &diffResult{

pkg/app/piped/planpreview/ecsdiff.go

@@ -0,0 +1,135 @@
+// Copyright 2024 The PipeCD Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package planpreview
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+
+	"github.com/pipe-cd/pipecd/pkg/app/piped/deploysource"
+	provider "github.com/pipe-cd/pipecd/pkg/app/piped/platformprovider/ecs"
+	"github.com/pipe-cd/pipecd/pkg/diff"
+	"github.com/pipe-cd/pipecd/pkg/model"
+)
+
+func (b *builder) ecsdiff(
+	ctx context.Context,
+	app *model.Application,
+	targetDSP deploysource.Provider,
+	lastCommit string,
+	buf *bytes.Buffer,
+) (*diffResult, error) {
+	var (
+		oldManifests, newManifests provider.ECSManifests
+		err                        error
+	)
+
+	newManifests, err = b.loadECSManifests(ctx, *app, targetDSP)
+	if err != nil {
+		fmt.Fprintf(buf, "failed to load ecs manifests at the head commit (%v)\n", err)
+		return nil, err
+	}
+
+	if lastCommit == "" {
+		fmt.Fprintf(buf, "failed to find the commit of the last successful deployment")
+		return nil, fmt.Errorf("cannot get the old manifests without the last successful deployment")
+	}
+
+	runningDSP := deploysource.NewProvider(
+		b.workingDir,
+		deploysource.NewGitSourceCloner(b.gitClient, b.repoCfg, "running", lastCommit),
+		*app.GitPath,
+		b.secretDecrypter,
+	)
+
+	oldManifests, err = b.loadECSManifests(ctx, *app, runningDSP)
+	if err != nil {
+		fmt.Fprintf(buf, "failed to load ecs manifests at the running commit (%v)\n", err)
+		return nil, err
+	}
+
+	result, err := provider.Diff(
+		oldManifests,
+		newManifests,
+		diff.WithEquateEmpty(),
+		diff.WithCompareNumberAndNumericString(),
+	)
+	if err != nil {
+		fmt.Fprintf(buf, "failed to compare manifests (%v)\n", err)
+		return nil, err
+	}
+
+	if result.NoChange() {
+		fmt.Fprintln(buf, "No changes were detected")
+		return &diffResult{
+			summary:  "No changes were detected",
+			noChange: true,
+		}, nil
+	}
+
+	summary := fmt.Sprintf("%d changes were detected", len(result.Diff.Nodes()))
+	details := result.Render(provider.DiffRenderOptions{
+		UseDiffCommand: true,
+	})
+	fmt.Fprintf(buf, "--- Last Deploy\n+++ Head Commit\n\n%s\n", details)
+
+	return &diffResult{
+		summary: summary,
+	}, nil
+
+}
+
+func (b *builder) loadECSManifests(ctx context.Context, app model.Application, dsp deploysource.Provider) (provider.ECSManifests, error) {
+	commit := dsp.Revision()
+	cache := provider.ECSManifestsCache{
+		AppID:  app.Id,
+		Cache:  b.appManifestsCache,
+		Logger: b.logger,
+	}
+
+	manifests, ok := cache.Get(commit)
+	if ok {
+		return manifests, nil
+	}
+
+	ds, err := dsp.Get(ctx, io.Discard)
+	if err != nil {
+		return provider.ECSManifests{}, err
+	}
+
+	appCfg := ds.ApplicationConfig.ECSApplicationSpec
+	if appCfg == nil {
+		return provider.ECSManifests{}, fmt.Errorf("malformed application configuration file")
+	}
+
+	taskDef, err := provider.LoadTaskDefinition(ds.AppDir, appCfg.Input.TaskDefinitionFile)
+	if err != nil {
+		return provider.ECSManifests{}, err
+	}
+	serviceDef, err := provider.LoadServiceDefinition(ds.AppDir, appCfg.Input.ServiceDefinitionFile)
+	if err != nil {
+		return provider.ECSManifests{}, err
+	}
+
+	manifests = provider.ECSManifests{
+		TaskDefinition:    &taskDef,
+		ServiceDefinition: &serviceDef,
+	}
+
+	cache.Put(commit, manifests)
+	return manifests, nil
+}

pkg/app/piped/platformprovider/ecs/cache.go

@@ -0,0 +1,68 @@
+// Copyright 2024 The PipeCD Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ecs
+
+import (
+	"errors"
+	"fmt"
+
+	"go.uber.org/zap"
+
+	"github.com/pipe-cd/pipecd/pkg/cache"
+)
+
+type ECSManifestsCache struct {
+	AppID  string
+	Cache  cache.Cache
+	Logger *zap.Logger
+}
+
+func (c ECSManifestsCache) Get(commit string) (ECSManifests, bool) {
+	key := ecsManifestsCacheKey(c.AppID, commit)
+	item, err := c.Cache.Get(key)
+	if err == nil {
+		return item.(ECSManifests), true
+	}
+
+	if errors.Is(err, cache.ErrNotFound) {
+		c.Logger.Info("ecs manifests were not found in cache",
+			zap.String("app-id", c.AppID),
+			zap.String("commit-hash", commit),
+		)
+		return ECSManifests{}, false
+	}
+
+	c.Logger.Error("failed while retrieving ecs manifests from cache",
+		zap.String("app-id", c.AppID),
+		zap.String("commit-hash", commit),
+		zap.Error(err),
+	)
+	return ECSManifests{}, false
+}
+
+func (c ECSManifestsCache) Put(commit string, sm ECSManifests) {
+	key := ecsManifestsCacheKey(c.AppID, commit)
+	if err := c.Cache.Put(key, sm); err != nil {
+		c.Logger.Error("failed while putting ecs manifests from cache",
+			zap.String("app-id", c.AppID),
+			zap.String("commit-hash", commit),
+			zap.Error(err),
+		)
+	}
+}
+
+func ecsManifestsCacheKey(appID, commit string) string {
+	return fmt.Sprintf("%s/%s", appID, commit)
+}

pkg/app/piped/platformprovider/ecs/diff.go

@@ -0,0 +1,100 @@
+// Copyright 2024 The PipeCD Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ecs
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+
+	"github.com/pipe-cd/pipecd/pkg/diff"
+)
+
+const (
+	diffCommand = "diff"
+)
+
+type DiffResult struct {
+	Diff *diff.Result
+	Old  ECSManifests
+	New  ECSManifests
+}
+
+func (d *DiffResult) NoChange() bool {
+	return len(d.Diff.Nodes()) == 0
+}
+
+func Diff(old, new ECSManifests, opts ...diff.Option) (*DiffResult, error) {
+	d, err := diff.DiffStructureds(old, new, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	if !d.HasDiff() {
+		return &DiffResult{Diff: d}, nil
+	}
+
+	ret := &DiffResult{
+		Old:  old,
+		New:  new,
+		Diff: d,
+	}
+	return ret, nil
+}
+
+type DiffRenderOptions struct {
+	// If true, use "diff" command to render.
+	UseDiffCommand bool
+}
+
+func (d *DiffResult) Render(opt DiffRenderOptions) string {
+	var b strings.Builder
+	opts := []diff.RenderOption{
+		diff.WithLeftPadding(1),
+	}
+	renderer := diff.NewRenderer(opts...)
+	if !opt.UseDiffCommand {
+		b.WriteString(renderer.Render(d.Diff.Nodes()))
+	} else {
+		d, err := diffByCommand(diffCommand, d.Old, d.New)
+		if err != nil {
+			b.WriteString(fmt.Sprintf("An error occurred while rendering diff (%v)", err))
+		} else {
+			b.Write(d)
+		}
+	}
+	b.WriteString("\n")
+
+	return b.String()
+}
+
+func diffByCommand(command string, old, new ECSManifests) ([]byte, error) {
+	taskDiff, err := diff.DiffByCommand(command, old.TaskDefinition, new.TaskDefinition)
+	if err != nil {
+		return nil, err
+	}
+
+	serviceDiff, err := diff.DiffByCommand(command, old.ServiceDefinition, new.ServiceDefinition)
+	if err != nil {
+		return nil, err
+	}
+
+	return bytes.Join([][]byte{
+		[]byte("# 1. ServiceDefinition"),
+		serviceDiff,
+		[]byte("\n# 2. TaskDefinition"),
+		taskDiff,
+	}, []byte("\n")), nil
+}