feat: add cli plan command

client/cmd/internal/plan/compositor.go

@@ -0,0 +1,76 @@
+package plan
+
+type Compositor struct {
+	deleteOperation map[string]Queue[*Plan]
+	createOperation map[string]Queue[*Plan]
+	result          []*Plan
+}
+
+func NewCompositor() Compositor {
+	return Compositor{
+		deleteOperation: make(map[string]Queue[*Plan]),
+		createOperation: make(map[string]Queue[*Plan]),
+		result:          make([]*Plan, 0),
+	}
+}
+
+// Add will append Plan and enqueue create and delete plan Operation
+func (compositor *Compositor) Add(addPlan *Plan) {
+	switch addPlan.Operation {
+	case OperationCreate:
+		createPlansByName, exist := compositor.createOperation[addPlan.KindName]
+		if !exist {
+			createPlansByName = NewQueue[*Plan]()
+		}
+		createPlansByName.Push(addPlan)
+		compositor.createOperation[addPlan.KindName] = createPlansByName
+	case OperationDelete:
+		deletePlanByName, exist := compositor.deleteOperation[addPlan.KindName]
+		if !exist {
+			deletePlanByName = NewQueue[*Plan]()
+		}
+		deletePlanByName.Push(addPlan)
+		compositor.deleteOperation[addPlan.KindName] = deletePlanByName
+	default:
+		compositor.result = append(compositor.result, addPlan)
+	}
+}
+
+func (compositor *Compositor) Merge() []*Plan {
+	if len(compositor.createOperation)+len(compositor.deleteOperation) == 0 {
+		return compositor.result
+	}
+
+	compositor.result = append(compositor.result, compositor.getPlan(compositor.createOperation, compositor.deleteOperation)...)
+	compositor.result = append(compositor.result, compositor.getPlan(compositor.deleteOperation, compositor.createOperation)...)
+	return compositor.result
+}
+
+// getPlan will dequeue create and delete plan Operation
+// if there are same Plan.KindName on different Plan.NamespaceName, it will be merged as one plan with OperationMigrate
+// else it will append as result directly
+func (Compositor) getPlan(createOperation, deleteOperation map[string]Queue[*Plan]) []*Plan {
+	var res []*Plan
+	for kindName, createPlanQueue := range createOperation {
+		if createPlanQueue == nil {
+			continue
+		}
+
+		deletePlanQueue := deleteOperation[kindName]
+		for createPlanQueue.Next() {
+			if !deletePlanQueue.Next() {
+				res = append(res, createPlanQueue.Pop())
+				continue
+			}
+
+			deletePlan := deletePlanQueue.Pop()
+			migratePlan := createPlanQueue.Pop()
+			migratePlan.Operation = OperationMigrate
+			migratePlan.OldNamespaceName = &deletePlan.NamespaceName
+			res = append(res, migratePlan)
+		}
+		createOperation[kindName] = createPlanQueue
+		deleteOperation[kindName] = deletePlanQueue
+	}
+	return res
+}

client/cmd/internal/plan/compositor_test.go

@@ -0,0 +1,139 @@
+package plan_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/goto/optimus/client/cmd/internal/plan"
+)
+
+func TestPlanCompositor(t *testing.T) {
+	var (
+		projectName = "p-optimus-1"
+		job1        = "j-job-1"
+		namespace1  = "n-optimus-1"
+		namespace2  = "n-optimus-2"
+	)
+
+	t.Run("case migration only", func(t *testing.T) {
+		inputs := []*plan.Plan{
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationDelete, KindName: job1},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationCreate, KindName: job1},
+		}
+		expected := []*plan.Plan{
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationMigrate, KindName: job1, OldNamespaceName: &namespace1},
+		}
+
+		compositor := plan.NewCompositor()
+		for i := range inputs {
+			compositor.Add(inputs[i])
+		}
+
+		actual := compositor.Merge()
+		assert.ElementsMatch(t, actual, expected)
+	})
+
+	t.Run("case create update delete on different kind name and namespace", func(t *testing.T) {
+		inputs := []*plan.Plan{
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationCreate, KindName: "job-1"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationDelete, KindName: "job-3"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationCreate, KindName: "job-1"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationDelete, KindName: "job-3"},
+		}
+		expected := []*plan.Plan{
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationCreate, KindName: "job-1"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationCreate, KindName: "job-1"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationDelete, KindName: "job-3"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationDelete, KindName: "job-3"},
+		}
+
+		compositor := plan.NewCompositor()
+		for i := range inputs {
+			compositor.Add(inputs[i])
+		}
+
+		actual := compositor.Merge()
+		assert.Len(t, actual, len(expected), "actual has %d length, but expect has %d length", len(actual), len(expected))
+		assert.ElementsMatch(t, actual, expected)
+	})
+
+	t.Run("case migration from create to delete", func(t *testing.T) {
+		inputs := []*plan.Plan{
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationCreate, KindName: "job-1"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationDelete, KindName: "job-1"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationCreate, KindName: "job-3"},
+		}
+		expected := []*plan.Plan{
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationMigrate, KindName: "job-1", OldNamespaceName: &namespace2},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationCreate, KindName: "job-3"},
+		}
+
+		compositor := plan.NewCompositor()
+		for i := range inputs {
+			compositor.Add(inputs[i])
+		}
+
+		actual := compositor.Merge()
+		assert.ElementsMatch(t, actual, expected)
+	})
+
+	t.Run("case migration from delete to create", func(t *testing.T) {
+		inputs := []*plan.Plan{
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationDelete, KindName: "job-1"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationCreate, KindName: "job-1"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationCreate, KindName: "job-3"},
+		}
+		expected := []*plan.Plan{
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationMigrate, KindName: "job-1", OldNamespaceName: &namespace1},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationUpdate, KindName: "job-2"},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationCreate, KindName: "job-3"},
+		}
+
+		compositor := plan.NewCompositor()
+		for i := range inputs {
+			compositor.Add(inputs[i])
+		}
+
+		actual := compositor.Merge()
+		assert.ElementsMatch(t, actual, expected)
+	})
+
+	t.Run("case multiple migration on multiple namespace", func(t *testing.T) {
+		namespace3, namespace4, namespace5 := "n-optimus-3", "n-optimus-4", "n-optimus-5"
+		inputs := []*plan.Plan{
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace1, Operation: plan.OperationDelete, KindName: job1},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationCreate, KindName: job1},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace3, Operation: plan.OperationCreate, KindName: job1},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace4, Operation: plan.OperationDelete, KindName: job1},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace5, Operation: plan.OperationCreate, KindName: job1},
+		}
+		expected := []*plan.Plan{
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace2, Operation: plan.OperationMigrate, KindName: job1, OldNamespaceName: &namespace1},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace3, Operation: plan.OperationMigrate, KindName: job1, OldNamespaceName: &namespace4},
+			{Kind: plan.KindJob, ProjectName: projectName, NamespaceName: namespace5, Operation: plan.OperationCreate, KindName: job1},
+		}
+
+		compositor := plan.NewCompositor()
+		for i := range inputs {
+			compositor.Add(inputs[i])
+		}
+
+		actual := compositor.Merge()
+		assert.ElementsMatch(t, actual, expected)
+
+		// - make sure the actual result still same when its called multiple times
+		assert.ElementsMatch(t, compositor.Merge(), expected)
+	})
+}

client/cmd/internal/plan/kind.go

@@ -0,0 +1,8 @@
+package plan
+
+type Kind string
+
+const (
+	KindJob      Kind = "job"
+	KindResource Kind = "resource"
+)

client/cmd/internal/plan/operation.go

@@ -0,0 +1,29 @@
+package plan
+
+import "encoding/json"
+
+// Operation determine Plan Operation
+type Operation string
+
+const (
+	OperationDelete  Operation = "delete"
+	OperationCreate  Operation = "create"
+	OperationMigrate Operation = "migrate"
+	OperationUpdate  Operation = "update"
+)
+
+// String is fmt.Stringer implementation
+func (o Operation) String() string { return string(o) }
+
+// MarshalJSON implement json.Marshaler with returning its string value
+func (o Operation) MarshalJSON() ([]byte, error) { return json.Marshal(o.String()) }
+
+// UnmarshalJSON implement json.Unmarshaler and initialized based on string value of Operation
+func (o *Operation) UnmarshalJSON(value []byte) error {
+	var operationValue string
+	if err := json.Unmarshal(value, &operationValue); err != nil {
+		return err
+	}
+	*o = Operation(operationValue)
+	return nil
+}

client/cmd/internal/plan/plan.go

@@ -0,0 +1,15 @@
+package plan
+
+type Plan struct {
+	Kind          Kind      `json:"kind"`
+	ProjectName   string    `json:"project_name"`
+	NamespaceName string    `json:"namespace_name"`
+	KindName      string    `json:"kind_name"`
+	Operation     Operation `json:"operation"`
+	Executed      bool      `json:"executed"`
+
+	// OldNamespaceName used when Operation is OperationMigrate where it used on migrate namespace command / API
+	OldNamespaceName *string `json:"old_namespace_name"`
+}
+
+type Plans []*Plan

client/cmd/internal/plan/queue.go

@@ -0,0 +1,24 @@
+package plan
+
+type Queue[T any] []T
+
+func NewQueue[T any]() Queue[T] { return make(Queue[T], 0) }
+
+func (q *Queue[T]) Push(value T) {
+	*q = append(*q, value)
+}
+
+func (q *Queue[T]) Pop() T {
+	var front T
+	if !q.Next() {
+		return front
+	}
+
+	front = (*q)[0]
+	*q = (*q)[1:]
+	return front
+}
+
+func (q *Queue[T]) Next() bool {
+	return len(*q) > 0
+}

client/cmd/job/job.go

@@ -26,6 +26,7 @@ func NewJobCommand() *cobra.Command {
 		NewJobRunInputCommand(),
 		NewChangeNamespaceCommand(),
 		NewDeleteCommand(),
+		NewPlanCommand(),
 	)
 	return cmd
 }