fix: cap diff depth and batch collab reads

Signed-off-by: huanghongbo-hhb <huanghongbo@koderover.com>

Author: huanghongbo-hhb

pkg/microservice/aslan/core/release_plan/service/collaboration.go

@@ -444,23 +444,22 @@ func listActiveReleasePlanEditingSessions(planID string) ([]*ReleasePlanEditingS
 	if err != nil {
 		return nil, err
 	}
+	if len(sessionIDs) == 0 {
+		return []*ReleasePlanEditingSession{}, nil
+	}
 
-	resp := make([]*ReleasePlanEditingSession, 0, len(sessionIDs))
+	keys := make([]string, 0, len(sessionIDs))
 	for _, sessionID := range sessionIDs {
-		value, err := redisCache.GetString(releasePlanCollabSessionKey(sessionID))
-		if err != nil {
-			continue
-		}
-		session := new(ReleasePlanEditingSession)
-		if err := json.Unmarshal([]byte(value), session); err != nil {
-			continue
-		}
-		if session.PlanID != planID {
-			continue
-		}
-		resp = append(resp, session)
+		keys = append(keys, releasePlanCollabSessionKey(sessionID))
+	}
+
+	values, err := redisCache.MGet(keys)
+	if err != nil {
+		return nil, err
 	}
 
+	resp := decodeReleasePlanEditingSessions(planID, values)
+
 	sort.Slice(resp, func(i, j int) bool {
 		if resp[i].SectionKey == resp[j].SectionKey {
 			return resp[i].EditingStartedAt < resp[j].EditingStartedAt
@@ -471,6 +470,25 @@ func listActiveReleasePlanEditingSessions(planID string) ([]*ReleasePlanEditingS
 	return resp, nil
 }
 
+func decodeReleasePlanEditingSessions(planID string, values []interface{}) []*ReleasePlanEditingSession {
+	resp := make([]*ReleasePlanEditingSession, 0, len(values))
+	for _, value := range values {
+		raw, ok := value.(string)
+		if !ok || raw == "" {
+			continue
+		}
+		session := new(ReleasePlanEditingSession)
+		if err := json.Unmarshal([]byte(raw), session); err != nil {
+			continue
+		}
+		if session.PlanID != planID {
+			continue
+		}
+		resp = append(resp, session)
+	}
+	return resp
+}
+
 func persistReleasePlanEditingSession(session *ReleasePlanEditingSession) error {
 	if session == nil {
 		return errors.New("nil editing session")

pkg/microservice/aslan/core/release_plan/service/diff.go

@@ -36,6 +36,7 @@ import (
 const (
 	releasePlanHashPruneMinMapKeys     = 4
 	releasePlanHashPruneMinArrayItems  = 4
+	releasePlanDiffMaxDepth            = 50
 	releasePlanDiffChangeTypeOrder     = "order_changed"
 	releasePlanDiffDisplayApprovalSpec = "approval_spec"
 	releasePlanDiffDisplayWorkflowSpec = "workflow_spec"
@@ -368,6 +369,10 @@ func extractReleasePlanSectionSnapshot(snapshot interface{}, sectionKey string)
 }
 
 func diffReleasePlanValues(ctx releasePlanDiffContext, path string, left, right interface{}, entries *[]*releasePlanRawDiffEntry) {
+	diffReleasePlanValuesWithDepth(ctx, path, 0, left, right, entries)
+}
+
+func diffReleasePlanValuesWithDepth(ctx releasePlanDiffContext, path string, depth int, left, right interface{}, entries *[]*releasePlanRawDiffEntry) {
 	if shouldIgnoreReleasePlanDiffPath(path) {
 		return
 	}
@@ -380,6 +385,15 @@ func diffReleasePlanValues(ctx releasePlanDiffContext, path string, left, right
 		return
 	}
 
+	if depth >= releasePlanDiffMaxDepth {
+		*entries = append(*entries, &releasePlanRawDiffEntry{
+			Path:   path,
+			Before: left,
+			After:  right,
+		})
+		return
+	}
+
 	leftMap, leftIsMap := left.(map[string]interface{})
 	rightMap, rightIsMap := right.(map[string]interface{})
 	if leftIsMap || rightIsMap {
@@ -397,15 +411,15 @@ func diffReleasePlanValues(ctx releasePlanDiffContext, path string, left, right
 		sort.Strings(keys)
 		for _, key := range keys {
 			nextPath := joinReleasePlanDiffPath(path, key)
-			diffReleasePlanValues(ctx, nextPath, leftMap[key], rightMap[key], entries)
+			diffReleasePlanValuesWithDepth(ctx, nextPath, depth+1, leftMap[key], rightMap[key], entries)
 		}
 		return
 	}
 
 	leftList, leftIsList := left.([]interface{})
 	rightList, rightIsList := right.([]interface{})
 	if leftIsList || rightIsList {
-		diffReleasePlanArray(ctx, path, leftList, rightList, entries)
+		diffReleasePlanArray(ctx, path, depth, leftList, rightList, entries)
 		return
 	}
 
@@ -460,17 +474,17 @@ func hashReleasePlanSubtree(value interface{}) (string, error) {
 	return hex.EncodeToString(sum[:]), nil
 }
 
-func diffReleasePlanArray(ctx releasePlanDiffContext, path string, left, right []interface{}, entries *[]*releasePlanRawDiffEntry) {
+func diffReleasePlanArray(ctx releasePlanDiffContext, path string, depth int, left, right []interface{}, entries *[]*releasePlanRawDiffEntry) {
 	rule := matchReleasePlanArrayDiffRule(ctx, path)
 	if rule == nil || rule.Strategy == releasePlanArrayDiffStrategyIndex {
-		diffReleasePlanArrayByIndex(ctx, path, left, right, entries)
+		diffReleasePlanArrayByIndex(ctx, path, depth, left, right, entries)
 		return
 	}
 
 	leftMap, leftOrdered, leftMapped := buildReleasePlanArrayMap(left, rule.BuildKey)
 	rightMap, rightOrdered, rightMapped := buildReleasePlanArrayMap(right, rule.BuildKey)
 	if !leftMapped || !rightMapped {
-		diffReleasePlanArrayByIndex(ctx, path, left, right, entries)
+		diffReleasePlanArrayByIndex(ctx, path, depth, left, right, entries)
 		return
 	}
 
@@ -500,12 +514,12 @@ func diffReleasePlanArray(ctx releasePlanDiffContext, path string, left, right [
 				continue
 			}
 			nextPath := fmt.Sprintf("%s[%s]", path, key)
-			diffReleasePlanValues(ctx, nextPath, leftMap[key], rightMap[key], entries)
+			diffReleasePlanValuesWithDepth(ctx, nextPath, depth+1, leftMap[key], rightMap[key], entries)
 		}
 		return
 	}
 
-	diffReleasePlanArrayByIndex(ctx, path, left, right, entries)
+	diffReleasePlanArrayByIndex(ctx, path, depth, left, right, entries)
 }
 
 func shouldSkipReleasePlanWorkflowTaskPresenceChange(path string, left, right interface{}) bool {
@@ -516,7 +530,7 @@ func shouldSkipReleasePlanWorkflowTaskPresenceChange(path string, left, right in
 	return normalizedPath == "spec.workflow.jobs" || strings.HasSuffix(normalizedPath, ".spec.workflow.jobs")
 }
 
-func diffReleasePlanArrayByIndex(ctx releasePlanDiffContext, path string, left, right []interface{}, entries *[]*releasePlanRawDiffEntry) {
+func diffReleasePlanArrayByIndex(ctx releasePlanDiffContext, path string, depth int, left, right []interface{}, entries *[]*releasePlanRawDiffEntry) {
 	maxLen := len(left)
 	if len(right) > maxLen {
 		maxLen = len(right)
@@ -530,7 +544,7 @@ func diffReleasePlanArrayByIndex(ctx releasePlanDiffContext, path string, left,
 		if i < len(right) {
 			rightVal = right[i]
 		}
-		diffReleasePlanValues(ctx, nextPath, leftVal, rightVal, entries)
+		diffReleasePlanValuesWithDepth(ctx, nextPath, depth+1, leftVal, rightVal, entries)
 	}
 }
 

pkg/tool/cache/redis_cache.go

@@ -91,6 +91,13 @@ func (c *RedisCache) GetString(key string) (string, error) {
 	return c.redisClient.Get(context.TODO(), key).Result()
 }
 
+func (c *RedisCache) MGet(keys []string) ([]interface{}, error) {
+	if len(keys) == 0 {
+		return []interface{}{}, nil
+	}
+	return c.redisClient.MGet(context.TODO(), keys...).Result()
+}
+
 func (c *RedisCache) HGetString(key, field string) (string, error) {
 	return c.redisClient.HGet(context.TODO(), key, field).Result()
 }