Refactor RDP proxy handling and update related tests

agents/rap-node-agent/internal/mesh/fabric_route_pressure.go

@@ -0,0 +1,137 @@
+package mesh
+
+import (
+	"strings"
+	"sync"
+	"sync/atomic"
+)
+
+type FabricRoutePressureTracker struct {
+	mu                sync.Mutex
+	active            map[string]int
+	maxActive         map[string]int
+	acquiredTotal     uint64
+	releasedTotal     uint64
+	maxActiveTotal    int
+	lastAcquiredRoute string
+	lastReleasedRoute string
+}
+
+type FabricRoutePressureSnapshot struct {
+	Active            map[string]int `json:"active"`
+	MaxActive         map[string]int `json:"max_active"`
+	ActiveTotal       int            `json:"active_total"`
+	MaxActiveTotal    int            `json:"max_active_total"`
+	AcquiredTotal     uint64         `json:"acquired_total"`
+	ReleasedTotal     uint64         `json:"released_total"`
+	LastAcquiredRoute string         `json:"last_acquired_route,omitempty"`
+	LastReleasedRoute string         `json:"last_released_route,omitempty"`
+}
+
+func NewFabricRoutePressureTracker() *FabricRoutePressureTracker {
+	return &FabricRoutePressureTracker{
+		active:    map[string]int{},
+		maxActive: map[string]int{},
+	}
+}
+
+func (t *FabricRoutePressureTracker) Apply(routeSet FabricRouteSet) FabricRouteSet {
+	if t == nil {
+		return routeSet
+	}
+	active := t.Snapshot()
+	if len(active) == 0 {
+		return routeSet
+	}
+	apply := func(route FabricRoute) FabricRoute {
+		if count := active[route.RouteID]; count > 0 {
+			route.ActiveChannels += count
+		}
+		return route
+	}
+	routeSet.Primary = apply(routeSet.Primary)
+	for i := range routeSet.WarmStandby {
+		routeSet.WarmStandby[i] = apply(routeSet.WarmStandby[i])
+	}
+	for i := range routeSet.ColdFallbacks {
+		routeSet.ColdFallbacks[i] = apply(routeSet.ColdFallbacks[i])
+	}
+	return routeSet
+}
+
+func (t *FabricRoutePressureTracker) Acquire(routeID string) func() {
+	routeID = strings.TrimSpace(routeID)
+	if t == nil || routeID == "" {
+		return func() {}
+	}
+	t.mu.Lock()
+	if t.active == nil {
+		t.active = map[string]int{}
+	}
+	if t.maxActive == nil {
+		t.maxActive = map[string]int{}
+	}
+	t.active[routeID]++
+	if t.active[routeID] > t.maxActive[routeID] {
+		t.maxActive[routeID] = t.active[routeID]
+	}
+	t.acquiredTotal++
+	t.lastAcquiredRoute = routeID
+	if activeTotal := activeTotalLocked(t.active); activeTotal > t.maxActiveTotal {
+		t.maxActiveTotal = activeTotal
+	}
+	t.mu.Unlock()
+	var released atomic.Bool
+	return func() {
+		if released.Swap(true) {
+			return
+		}
+		t.mu.Lock()
+		if t.active[routeID] <= 1 {
+			delete(t.active, routeID)
+		} else {
+			t.active[routeID]--
+		}
+		t.releasedTotal++
+		t.lastReleasedRoute = routeID
+		t.mu.Unlock()
+	}
+}
+
+func (t *FabricRoutePressureTracker) Snapshot() map[string]int {
+	return t.SnapshotPressure().Active
+}
+
+func (t *FabricRoutePressureTracker) SnapshotPressure() FabricRoutePressureSnapshot {
+	if t == nil {
+		return FabricRoutePressureSnapshot{}
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	active := make(map[string]int, len(t.active))
+	for routeID, count := range t.active {
+		active[routeID] = count
+	}
+	maxActive := make(map[string]int, len(t.maxActive))
+	for routeID, count := range t.maxActive {
+		maxActive[routeID] = count
+	}
+	return FabricRoutePressureSnapshot{
+		Active:            active,
+		MaxActive:         maxActive,
+		ActiveTotal:       activeTotalLocked(active),
+		MaxActiveTotal:    t.maxActiveTotal,
+		AcquiredTotal:     t.acquiredTotal,
+		ReleasedTotal:     t.releasedTotal,
+		LastAcquiredRoute: t.lastAcquiredRoute,
+		LastReleasedRoute: t.lastReleasedRoute,
+	}
+}
+
+func activeTotalLocked(active map[string]int) int {
+	total := 0
+	for _, count := range active {
+		total += count
+	}
+	return total
+}