feat(routing): 引入多执行池智能调度

将 Worker 发现、路由画像、容量与执行传输抽象为平台无关接口，新增 Kubernetes 和静态容量适配器，并以 shadow 模式接入生产配置。实现网络与容量评分、路由防抖、池队列、同步 Worker 租约、一次性执行令牌，以及提交状态不明时禁止重复分配的安全语义。新增 0105 兼容迁移、管理接口、指标、OpenAPI 和回归测试。已执行全量 Go 测试、go vet、OpenAPI、迁移安全、Compose 与 Kustomize 验证。
2026-08-05 22:25:37 +08:00
parent 03c0873649
commit 7786692d32
58 changed files with 4510 additions and 348 deletions
@@ -5,8 +5,9 @@ import (
 	"sort"
 )

-type SiteResources struct {
-	Site                     string
+type PoolResources struct {
+	PoolID                   string
+	Demand                   int
 	CurrentReplicas          int
 	MinReplicas              int
 	MaxReplicas              int
@@ -47,11 +48,12 @@ type PlanInput struct {
 	SynchronousDatabasePeers    int
 	ScaleUpEligible             bool
 	ScaleDownEligible           bool
-	Sites                       []SiteResources
+	Pools                       []PoolResources
 }

-type SitePlan struct {
-	Site            string  `json:"site"`
+type PoolPlan struct {
+	PoolID          string  `json:"poolId"`
+	Demand          int     `json:"demand"`
 	CurrentReplicas int     `json:"currentReplicas"`
 	DesiredReplicas int     `json:"desiredReplicas"`
 	ResourceMax     int     `json:"resourceMax"`
@@ -64,7 +66,7 @@ type Plan struct {
 	DesiredTotal int        `json:"desiredTotal"`
 	CurrentTotal int        `json:"currentTotal"`
 	FrozenReason string     `json:"frozenReason,omitempty"`
-	Sites        []SitePlan `json:"sites"`
+	Pools        []PoolPlan `json:"pools"`
 }

 func CalculatePlan(input PlanInput) Plan {
@@ -88,33 +90,34 @@ func CalculatePlan(input PlanInput) Plan {
 	plan := Plan{RawDesired: rawDesired}
 	minTotal := 0
 	resourceMaxTotal := 0
-	for _, site := range input.Sites {
-		for _, node := range site.Nodes {
+	for _, pool := range input.Pools {
+		for _, node := range pool.Nodes {
 			if node.MemoryPressure {
-				site.MemoryPressure = true
+				pool.MemoryPressure = true
 			}
 		}
-		current := max(site.CurrentReplicas, 0)
-		minReplicas := max(site.MinReplicas, 0)
-		configMax := max(site.MaxReplicas, minReplicas)
-		resourceMax, memoryPercent, cpuPercent := siteResourceMaximum(
-			site,
+		current := max(pool.CurrentReplicas, 0)
+		minReplicas := max(pool.MinReplicas, 0)
+		configMax := max(pool.MaxReplicas, minReplicas)
+		resourceMax, memoryPercent, cpuPercent := poolResourceMaximum(
+			pool,
 			input.MemoryTargetPercent,
 			input.CPUTargetPercent,
 		)
 		resourceMax = min(resourceMax, configMax)
 		if resourceMax < minReplicas && plan.FrozenReason == "" {
-			plan.FrozenReason = "site_resource_budget"
+			plan.FrozenReason = "pool_resource_budget"
 		}
 		resourceMax = max(resourceMax, minReplicas)
-		plan.Sites = append(plan.Sites, SitePlan{
-			Site: site.Site, CurrentReplicas: current, DesiredReplicas: minReplicas,
+		plan.Pools = append(plan.Pools, PoolPlan{
+			PoolID: pool.PoolID, CurrentReplicas: current, DesiredReplicas: minReplicas,
+			Demand:      pool.Demand,
 			ResourceMax: resourceMax, MemoryPercent: memoryPercent, CPUPercent: cpuPercent,
 		})
 		plan.CurrentTotal += current
 		minTotal += minReplicas
 		resourceMaxTotal += resourceMax
-		if site.MemoryPressure || memoryPercent >= float64(input.MemoryHardPercent) {
+		if pool.MemoryPressure || memoryPercent >= float64(input.MemoryHardPercent) {
 			plan.FrozenReason = "node_memory_pressure"
 		}
 	}
@@ -123,10 +126,10 @@ func CalculatePlan(input PlanInput) Plan {
 			(input.DatabaseConnectionBudget-input.NonWorkerConnectionBudget)/input.WorkerDatabasePoolMax,
 			0,
 		)
-		capSiteResourceMaxima(plan.Sites, workerReplicaBudget)
+		capPoolResourceMaxima(plan.Pools, workerReplicaBudget)
 		resourceMaxTotal = 0
-		for _, site := range plan.Sites {
-			resourceMaxTotal += site.ResourceMax
+		for _, pool := range plan.Pools {
+			resourceMaxTotal += pool.ResourceMax
 		}
 		if workerReplicaBudget < minTotal && plan.FrozenReason == "" {
 			plan.FrozenReason = "database_connection_budget"
@@ -167,47 +170,47 @@ func CalculatePlan(input PlanInput) Plan {
 	}
 	desired = max(desired, minTotal)
 	plan.DesiredTotal = desired
-	distributeDesiredReplicas(plan.Sites, desired)
+	distributeDesiredReplicas(plan.Pools, desired)
 	return plan
 }

-func capSiteResourceMaxima(sites []SitePlan, total int) {
+func capPoolResourceMaxima(pools []PoolPlan, total int) {
 	minimum := 0
-	original := make(map[string]int, len(sites))
-	for index := range sites {
-		original[sites[index].Site] = sites[index].ResourceMax
-		sites[index].ResourceMax = sites[index].DesiredReplicas
-		minimum += sites[index].ResourceMax
+	original := make(map[string]int, len(pools))
+	for index := range pools {
+		original[pools[index].PoolID] = pools[index].ResourceMax
+		pools[index].ResourceMax = pools[index].DesiredReplicas
+		minimum += pools[index].ResourceMax
 	}
 	target := max(total, minimum)
 	assigned := minimum
 	for assigned < target {
-		sort.SliceStable(sites, func(left, right int) bool {
-			leftRoom := original[sites[left].Site] - sites[left].ResourceMax
-			rightRoom := original[sites[right].Site] - sites[right].ResourceMax
+		sort.SliceStable(pools, func(left, right int) bool {
+			leftRoom := original[pools[left].PoolID] - pools[left].ResourceMax
+			rightRoom := original[pools[right].PoolID] - pools[right].ResourceMax
 			if leftRoom != rightRoom {
 				return leftRoom > rightRoom
 			}
-			return sites[left].Site < sites[right].Site
+			return pools[left].PoolID < pools[right].PoolID
 		})
-		if original[sites[0].Site] <= sites[0].ResourceMax {
+		if original[pools[0].PoolID] <= pools[0].ResourceMax {
 			break
 		}
-		sites[0].ResourceMax++
+		pools[0].ResourceMax++
 		assigned++
 	}
 }

-func siteResourceMaximum(site SiteResources, memoryTargetPercent int, cpuTargetPercent int) (int, float64, float64) {
-	if len(site.Nodes) > 0 {
-		if site.WorkerRequestMemoryBytes <= 0 || site.WorkerRequestMilliCPU <= 0 {
+func poolResourceMaximum(pool PoolResources, memoryTargetPercent int, cpuTargetPercent int) (int, float64, float64) {
+	if len(pool.Nodes) > 0 {
+		if pool.WorkerRequestMemoryBytes <= 0 || pool.WorkerRequestMilliCPU <= 0 {
 			return 0, 0, 0
 		}
 		memoryMax := 0
 		cpuMax := 0
 		memoryPercent := float64(0)
 		cpuPercent := float64(0)
-		for _, node := range site.Nodes {
+		for _, node := range pool.Nodes {
 			nodeMemoryPercent := usagePercent(node.UsedMemoryBytes, node.AllocatableMemoryBytes)
 			nodeCPUPercent := usagePercent(node.UsedMilliCPU, node.AllocatableMilliCPU)
 			memoryPercent = max(memoryPercent, nodeMemoryPercent)
@@ -217,60 +220,65 @@ func siteResourceMaximum(site SiteResources, memoryTargetPercent int, cpuTargetP
 				0,
 			)
 			memoryBudget := node.AllocatableMemoryBytes*int64(memoryTargetPercent)/100 - nonWorkerMemory
-			memoryMax += int(max(memoryBudget, 0) / site.WorkerRequestMemoryBytes)
+			memoryMax += int(max(memoryBudget, 0) / pool.WorkerRequestMemoryBytes)
 			nonWorkerCPU := max(
 				node.UsedMilliCPU-node.WorkerUsedMilliCPU,
 				0,
 			)
 			cpuBudget := node.AllocatableMilliCPU*int64(cpuTargetPercent)/100 - nonWorkerCPU
-			cpuMax += int(max(cpuBudget, 0) / site.WorkerRequestMilliCPU)
+			cpuMax += int(max(cpuBudget, 0) / pool.WorkerRequestMilliCPU)
 		}
-		return min(site.MaxReplicas, min(memoryMax, cpuMax)), memoryPercent, cpuPercent
+		return min(pool.MaxReplicas, min(memoryMax, cpuMax)), memoryPercent, cpuPercent
 	}
-	memoryPercent := usagePercent(site.UsedMemoryBytes, site.AllocatableMemoryBytes)
-	cpuPercent := usagePercent(site.UsedMilliCPU, site.AllocatableMilliCPU)
-	memoryMax := site.MaxReplicas
-	if site.AllocatableMemoryBytes > 0 && site.WorkerRequestMemoryBytes > 0 {
-		nonWorker := max(site.UsedMemoryBytes-int64(site.CurrentReplicas)*site.WorkerRequestMemoryBytes, 0)
-		budget := site.AllocatableMemoryBytes*int64(memoryTargetPercent)/100 - nonWorker
-		memoryMax = int(max(budget, 0) / site.WorkerRequestMemoryBytes)
+	memoryPercent := usagePercent(pool.UsedMemoryBytes, pool.AllocatableMemoryBytes)
+	cpuPercent := usagePercent(pool.UsedMilliCPU, pool.AllocatableMilliCPU)
+	memoryMax := pool.MaxReplicas
+	if pool.AllocatableMemoryBytes > 0 && pool.WorkerRequestMemoryBytes > 0 {
+		nonWorker := max(pool.UsedMemoryBytes-int64(pool.CurrentReplicas)*pool.WorkerRequestMemoryBytes, 0)
+		budget := pool.AllocatableMemoryBytes*int64(memoryTargetPercent)/100 - nonWorker
+		memoryMax = int(max(budget, 0) / pool.WorkerRequestMemoryBytes)
 	}
-	cpuMax := site.MaxReplicas
-	if site.AllocatableMilliCPU > 0 && site.WorkerRequestMilliCPU > 0 {
-		nonWorker := max(site.UsedMilliCPU-int64(site.CurrentReplicas)*site.WorkerRequestMilliCPU, 0)
-		budget := site.AllocatableMilliCPU*int64(cpuTargetPercent)/100 - nonWorker
-		cpuMax = int(max(budget, 0) / site.WorkerRequestMilliCPU)
+	cpuMax := pool.MaxReplicas
+	if pool.AllocatableMilliCPU > 0 && pool.WorkerRequestMilliCPU > 0 {
+		nonWorker := max(pool.UsedMilliCPU-int64(pool.CurrentReplicas)*pool.WorkerRequestMilliCPU, 0)
+		budget := pool.AllocatableMilliCPU*int64(cpuTargetPercent)/100 - nonWorker
+		cpuMax = int(max(budget, 0) / pool.WorkerRequestMilliCPU)
 	}
-	return min(site.MaxReplicas, min(memoryMax, cpuMax)), memoryPercent, cpuPercent
+	return min(pool.MaxReplicas, min(memoryMax, cpuMax)), memoryPercent, cpuPercent
 }

-func distributeDesiredReplicas(sites []SitePlan, desired int) {
-	if len(sites) == 0 {
+func distributeDesiredReplicas(pools []PoolPlan, desired int) {
+	if len(pools) == 0 {
 		return
 	}
 	assigned := 0
-	for index := range sites {
-		assigned += sites[index].DesiredReplicas
+	for index := range pools {
+		assigned += pools[index].DesiredReplicas
 	}
 	for assigned < desired {
-		sort.SliceStable(sites, func(left, right int) bool {
-			leftRoom := sites[left].ResourceMax - sites[left].DesiredReplicas
-			rightRoom := sites[right].ResourceMax - sites[right].DesiredReplicas
+		sort.SliceStable(pools, func(left, right int) bool {
+			leftDemandPerReplica := float64(max(pools[left].Demand, 0)) / float64(max(pools[left].DesiredReplicas, 1))
+			rightDemandPerReplica := float64(max(pools[right].Demand, 0)) / float64(max(pools[right].DesiredReplicas, 1))
+			if leftDemandPerReplica != rightDemandPerReplica {
+				return leftDemandPerReplica > rightDemandPerReplica
+			}
+			leftRoom := pools[left].ResourceMax - pools[left].DesiredReplicas
+			rightRoom := pools[right].ResourceMax - pools[right].DesiredReplicas
 			if leftRoom != rightRoom {
 				return leftRoom > rightRoom
 			}
-			if sites[left].DesiredReplicas != sites[right].DesiredReplicas {
-				return sites[left].DesiredReplicas < sites[right].DesiredReplicas
+			if pools[left].DesiredReplicas != pools[right].DesiredReplicas {
+				return pools[left].DesiredReplicas < pools[right].DesiredReplicas
 			}
-			return sites[left].Site < sites[right].Site
+			return pools[left].PoolID < pools[right].PoolID
 		})
-		if sites[0].DesiredReplicas >= sites[0].ResourceMax {
+		if pools[0].DesiredReplicas >= pools[0].ResourceMax {
 			break
 		}
-		sites[0].DesiredReplicas++
+		pools[0].DesiredReplicas++
 		assigned++
 	}
-	sort.Slice(sites, func(left, right int) bool { return sites[left].Site < sites[right].Site })
+	sort.Slice(pools, func(left, right int) bool { return pools[left].PoolID < pools[right].PoolID })
 }

 func usagePercent(used int64, allocatable int64) float64 {