fix: cn in the Bound phase should not be scaled in first

pkg/controllers/cnstore/controller.go

@@ -466,6 +466,7 @@ func (c *withCNSet) syncStats(ctx *recon.Context[*corev1.Pod]) error {
 		// clean previously recorded score and update startTime if CN is restarted
 		sc.Restarted(startedTime)
 	}
+	sc.Phase = pod.Labels[v1alpha1.CNPodPhaseLabel]
 
 	uid := v1alpha1.GetCNPodUUID(pod)
 	moVersion := common.GetSemanticVersion(&pod.ObjectMeta)

pkg/controllers/common/cnstore.go

@@ -39,6 +39,11 @@ const (
 	ReclaimedAt = "matrixorigin.io/reclaimed-at"
 
 	SemanticVersionAnno = "matrixorigin.io/semantic-version"
+
+	sessionWeight  = 1
+	pipelineWeight = 0
+	phaseWeight    = 100
+	maxCost        = 1000
 )
 
 func AddReadinessGate(podSpec *corev1.PodSpec, ct corev1.PodConditionType) {
@@ -151,10 +156,24 @@ type StoreScore struct {
 	PipelineCount int `json:"pipelineCount"`
 
 	StartedTime *time.Time `json:"startedTime,omitempty"`
+	Phase       string     `json:"phase,omitempty"`
 }
 
 func (s *StoreScore) GenDeletionCost() int {
-	return s.SessionCount
+	deletionCost := s.SessionCount*sessionWeight + s.PipelineCount*pipelineWeight
+	switch s.Phase {
+	case v1alpha1.CNPodPhaseBound:
+		deletionCost += phaseWeight * 2 // Bound should not be deleted
+	case v1alpha1.CNPodPhaseIdle, v1alpha1.CNPodPhaseTerminating:
+		deletionCost += phaseWeight * 0 // Idle and Terminating should be deleted first
+	case v1alpha1.CNPodPhaseDraining:
+		deletionCost += phaseWeight / 2 // Draining may be deleted later
+	}
+	// if deletion cost is larger than maxScore, normalize it from [0, maxCost]
+	for deletionCost > maxCost {
+		deletionCost >>= 1
+	}
+	return deletionCost
 }
 
 func (s *StoreScore) IsSafeToReclaim() bool {

pkg/controllers/common/cnstore_test.go

@@ -15,7 +15,10 @@
 package common
 
 import (
+	"github.com/matrixorigin/matrixone-operator/api/core/v1alpha1"
 	corev1 "k8s.io/api/core/v1"
+	"reflect"
+	"sort"
 	"testing"
 )
 
@@ -38,3 +41,70 @@ func TestNeedUpdateImage_DifferentImages(t *testing.T) {
 		t.Errorf("Expected true, got false")
 	}
 }
+
+func TestGenDeletionCostSorting(t *testing.T) {
+	type namedStoreScore struct {
+		Name  string
+		Score StoreScore
+	}
+	tests := []struct {
+		name   string
+		scores []namedStoreScore
+		want   []string
+	}{
+		{
+			name: "Basic sorting",
+			scores: []namedStoreScore{
+				{"A", StoreScore{SessionCount: 5, PipelineCount: 3, Phase: v1alpha1.CNPodPhaseBound}},
+				{"B", StoreScore{SessionCount: 2, PipelineCount: 1, Phase: v1alpha1.CNPodPhaseIdle}},
+				{"C", StoreScore{SessionCount: 10, PipelineCount: 5, Phase: v1alpha1.CNPodPhaseDraining}},
+			},
+			want: []string{"B", "C", "A"},
+		},
+		{
+			name: "Sorting with same scores",
+			scores: []namedStoreScore{
+				{"A", StoreScore{SessionCount: 5, PipelineCount: 3, Phase: v1alpha1.CNPodPhaseBound}},
+				{"B", StoreScore{SessionCount: 5, PipelineCount: 3, Phase: v1alpha1.CNPodPhaseBound}},
+				{"C", StoreScore{SessionCount: 2, PipelineCount: 1, Phase: v1alpha1.CNPodPhaseIdle}},
+			},
+			want: []string{"C", "A", "B"},
+		},
+		{
+			name: "Sorting with different phases",
+			scores: []namedStoreScore{
+				{"A", StoreScore{SessionCount: 5, PipelineCount: 3, Phase: v1alpha1.CNPodPhaseBound}},
+				{"B", StoreScore{SessionCount: 5, PipelineCount: 3, Phase: v1alpha1.CNPodPhaseIdle}},
+				{"C", StoreScore{SessionCount: 5, PipelineCount: 3, Phase: v1alpha1.CNPodPhaseDraining}},
+				{"D", StoreScore{SessionCount: 5, PipelineCount: 3, Phase: v1alpha1.CNPodPhaseTerminating}},
+			},
+			want: []string{"B", "D", "C", "A"},
+		},
+		{
+			name: "Sorting with different session count",
+			scores: []namedStoreScore{
+				{"A", StoreScore{SessionCount: 2, PipelineCount: 3, Phase: v1alpha1.CNPodPhaseBound}},
+				{"B", StoreScore{SessionCount: 3, PipelineCount: 3, Phase: v1alpha1.CNPodPhaseBound}},
+				{"C", StoreScore{SessionCount: 5, PipelineCount: 3, Phase: v1alpha1.CNPodPhaseBound}},
+			},
+			want: []string{"A", "B", "C"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sort.Slice(tt.scores, func(i, j int) bool {
+				return tt.scores[i].Score.GenDeletionCost() < tt.scores[j].Score.GenDeletionCost()
+			})
+
+			got := make([]string, len(tt.scores))
+			for i, score := range tt.scores {
+				got[i] = score.Name
+			}
+
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GenDeletionCost sorting = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}