Implement calculate diffs and rendering diffs of k8s (#5674)

* Implement the diff list rendering.

Signed-off-by: Shinnosuke Sawada-Dazai <[email protected]>

* Add test for DiffListResult.Render

Signed-off-by: Shinnosuke Sawada-Dazai <[email protected]>

---------

Signed-off-by: Shinnosuke Sawada-Dazai <[email protected]>

Author: Warashi

pkg/app/pipedv1/plugin/kubernetes/provider/diff.go

@@ -15,6 +15,10 @@
 package provider
 
 import (
+	"fmt"
+	"sort"
+	"strings"
+
 	"go.uber.org/zap"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -81,3 +85,143 @@ func normalizeNewSecret(old, new *unstructured.Unstructured) (*unstructured.Unst
 
 	return &unstructured.Unstructured{Object: newO}, nil
 }
+
+type DiffListResult struct {
+	Adds    []Manifest
+	Deletes []Manifest
+	Changes []DiffListChange
+}
+
+type DiffListChange struct {
+	Old  Manifest
+	New  Manifest
+	Diff *diff.Result
+}
+
+func (r *DiffListResult) NoChanges() bool {
+	return len(r.Adds)+len(r.Deletes)+len(r.Changes) == 0
+}
+
+func (r *DiffListResult) TotalOutOfSync() int {
+	return len(r.Adds) + len(r.Deletes) + len(r.Changes)
+}
+
+func DiffList(liveManifests, desiredManifests []Manifest, logger *zap.Logger, opts ...diff.Option) (*DiffListResult, error) {
+	adds, deletes, newChanges, oldChanges := groupManifests(liveManifests, desiredManifests)
+	result := &DiffListResult{
+		Adds:    adds,
+		Deletes: deletes,
+		Changes: make([]DiffListChange, 0, len(newChanges)),
+	}
+
+	for i := 0; i < len(newChanges); i++ {
+		diffResult, err := Diff(oldChanges[i], newChanges[i], logger, opts...)
+		if err != nil {
+			logger.Error("Failed to diff manifests", zap.Error(err))
+			continue
+		}
+		if !diffResult.HasDiff() {
+			continue
+		}
+		result.Changes = append(result.Changes, DiffListChange{
+			Old:  oldChanges[i],
+			New:  newChanges[i],
+			Diff: diffResult,
+		})
+	}
+
+	return result, nil
+}
+
+func groupManifests(olds, news []Manifest) (adds, deletes, newChanges, oldChanges []Manifest) {
+	// Sort the manifests before comparing.
+	sort.Slice(news, func(i, j int) bool {
+		return news[i].Key().String() < news[j].Key().String()
+	})
+	sort.Slice(olds, func(i, j int) bool {
+		return olds[i].Key().String() < olds[j].Key().String()
+	})
+
+	var n, o int
+	for {
+		if n >= len(news) || o >= len(olds) {
+			break
+		}
+		if news[n].Key().String() == olds[o].Key().String() {
+			newChanges = append(newChanges, news[n])
+			oldChanges = append(oldChanges, olds[o])
+			n++
+			o++
+			continue
+		}
+		// Has in news but not in olds so this should be a added one.
+		if news[n].Key().String() < olds[o].Key().String() {
+			adds = append(adds, news[n])
+			n++
+			continue
+		}
+		// Has in olds but not in news so this should be an deleted one.
+		deletes = append(deletes, olds[o])
+		o++
+	}
+
+	if len(news) > n {
+		adds = append(adds, news[n:]...)
+	}
+	if len(olds) > o {
+		deletes = append(deletes, olds[o:]...)
+	}
+	return adds, deletes, newChanges, oldChanges
+}
+
+type DiffRenderOptions struct {
+	MaskSecret    bool
+	MaskConfigMap bool
+	// Maximum number of changed manifests should be shown.
+	// Zero means rendering all.
+	MaxChangedManifests int
+}
+
+func (r *DiffListResult) Render(opt DiffRenderOptions) string {
+	var b strings.Builder
+	index := 0
+	for _, delete := range r.Deletes {
+		index++
+		b.WriteString(fmt.Sprintf("- %d. %s\n\n", index, delete.Key().ReadableString()))
+	}
+	for _, add := range r.Adds {
+		index++
+		b.WriteString(fmt.Sprintf("+ %d. %s\n\n", index, add.Key().ReadableString()))
+	}
+
+	maxPrintDiffs := len(r.Changes)
+	if opt.MaxChangedManifests != 0 && opt.MaxChangedManifests < maxPrintDiffs {
+		maxPrintDiffs = opt.MaxChangedManifests
+	}
+
+	for _, change := range r.Changes[:maxPrintDiffs] {
+		key := change.Old.Key()
+		opts := []diff.RenderOption{
+			diff.WithLeftPadding(1),
+		}
+
+		if opt.MaskSecret && change.Old.IsSecret() {
+			opts = append(opts, diff.WithMaskPath("data"))
+		} else if opt.MaskConfigMap && change.Old.IsConfigMap() {
+			opts = append(opts, diff.WithMaskPath("data"))
+		}
+		renderer := diff.NewRenderer(opts...)
+
+		index++
+		b.WriteString(fmt.Sprintf("# %d. %s\n\n", index, key.ReadableString()))
+
+		b.WriteString(renderer.Render(change.Diff.Nodes()))
+		b.WriteString("\n")
+	}
+
+	if maxPrintDiffs < len(r.Changes) {
+		b.WriteString(fmt.Sprintf("... (omitted %d other changed manifests)\n", len(r.Changes)-maxPrintDiffs))
+	}
+
+	return b.String()
+}