Revert "feat(gateway): 实现负载感知的账号调度优化 (#114)" (#117)

This reverts commit 8d252303fc.

backend/internal/repository/concurrency_cache.go

@@ -2,9 +2,7 @@ package repository
 
 import (
 	"context"
-	"errors"
 	"fmt"
-	"strconv"
 
 	"github.com/Wei-Shaw/sub2api/internal/service"
 	"github.com/redis/go-redis/v9"
@@ -29,8 +27,6 @@ const (
 	userSlotKeyPrefix = "concurrency:user:"
 	// 等待队列计数器格式: concurrency:wait:{userID}
 	waitQueueKeyPrefix = "concurrency:wait:"
-	// 账号级等待队列计数器格式: wait:account:{accountID}
-	accountWaitKeyPrefix = "wait:account:"
 
 	// 默认槽位过期时间（分钟），可通过配置覆盖
 	defaultSlotTTLMinutes = 15
@@ -116,112 +112,33 @@ var (
 			redis.call('EXPIRE', KEYS[1], ARGV[2])
 		end
 
-			return 1
-		`)
-
-	// incrementAccountWaitScript - account-level wait queue count
-	incrementAccountWaitScript = redis.NewScript(`
-			local current = redis.call('GET', KEYS[1])
-			if current == false then
-				current = 0
-			else
-				current = tonumber(current)
-			end
-
-			if current >= tonumber(ARGV[1]) then
-				return 0
-			end
-
-			local newVal = redis.call('INCR', KEYS[1])
-
-			-- Only set TTL on first creation to avoid refreshing zombie data
-			if newVal == 1 then
-				redis.call('EXPIRE', KEYS[1], ARGV[2])
-			end
-
-			return 1
-		`)
+		return 1
+	`)
 
 	// decrementWaitScript - same as before
 	decrementWaitScript = redis.NewScript(`
-			local current = redis.call('GET', KEYS[1])
-			if current ~= false and tonumber(current) > 0 then
-				redis.call('DECR', KEYS[1])
-			end
-			return 1
-		`)
-
-	// getAccountsLoadBatchScript - batch load query (read-only)
-	// ARGV[1] = slot TTL (seconds, retained for compatibility)
-	// ARGV[2..n] = accountID1, maxConcurrency1, accountID2, maxConcurrency2, ...
-	getAccountsLoadBatchScript = redis.NewScript(`
-			local result = {}
-
-			local i = 2
-			while i <= #ARGV do
-				local accountID = ARGV[i]
-				local maxConcurrency = tonumber(ARGV[i + 1])
-
-				local slotKey = 'concurrency:account:' .. accountID
-				local currentConcurrency = redis.call('ZCARD', slotKey)
-
-				local waitKey = 'wait:account:' .. accountID
-				local waitingCount = redis.call('GET', waitKey)
-				if waitingCount == false then
-					waitingCount = 0
-				else
-					waitingCount = tonumber(waitingCount)
-				end
-
-				local loadRate = 0
-				if maxConcurrency > 0 then
-					loadRate = math.floor((currentConcurrency + waitingCount) * 100 / maxConcurrency)
-				end
-
-				table.insert(result, accountID)
-				table.insert(result, currentConcurrency)
-				table.insert(result, waitingCount)
-				table.insert(result, loadRate)
-
-				i = i + 2
-			end
-
-			return result
-		`)
-
-	// cleanupExpiredSlotsScript - remove expired slots
-	// KEYS[1] = concurrency:account:{accountID}
-	// ARGV[1] = TTL (seconds)
-	cleanupExpiredSlotsScript = redis.NewScript(`
-			local key = KEYS[1]
-			local ttl = tonumber(ARGV[1])
-			local timeResult = redis.call('TIME')
-			local now = tonumber(timeResult[1])
-			local expireBefore = now - ttl
-			return redis.call('ZREMRANGEBYSCORE', key, '-inf', expireBefore)
-		`)
+		local current = redis.call('GET', KEYS[1])
+		if current ~= false and tonumber(current) > 0 then
+			redis.call('DECR', KEYS[1])
+		end
+		return 1
+	`)
 )
 
 type concurrencyCache struct {
-	rdb                 *redis.Client
-	slotTTLSeconds      int // 槽位过期时间（秒）
-	waitQueueTTLSeconds int // 等待队列过期时间（秒）
+	rdb            *redis.Client
+	slotTTLSeconds int // 槽位过期时间（秒）
 }
 
 // NewConcurrencyCache 创建并发控制缓存
 // slotTTLMinutes: 槽位过期时间（分钟），0 或负数使用默认值 15 分钟
-// waitQueueTTLSeconds: 等待队列过期时间（秒），0 或负数使用 slot TTL
-func NewConcurrencyCache(rdb *redis.Client, slotTTLMinutes int, waitQueueTTLSeconds int) service.ConcurrencyCache {
+func NewConcurrencyCache(rdb *redis.Client, slotTTLMinutes int) service.ConcurrencyCache {
 	if slotTTLMinutes <= 0 {
 		slotTTLMinutes = defaultSlotTTLMinutes
 	}
-	if waitQueueTTLSeconds <= 0 {
-		waitQueueTTLSeconds = slotTTLMinutes * 60
-	}
 	return &concurrencyCache{
-		rdb:                 rdb,
-		slotTTLSeconds:      slotTTLMinutes * 60,
-		waitQueueTTLSeconds: waitQueueTTLSeconds,
+		rdb:            rdb,
+		slotTTLSeconds: slotTTLMinutes * 60,
 	}
 }
 
@@ -238,10 +155,6 @@ func waitQueueKey(userID int64) string {
 	return fmt.Sprintf("%s%d", waitQueueKeyPrefix, userID)
 }
 
-func accountWaitKey(accountID int64) string {
-	return fmt.Sprintf("%s%d", accountWaitKeyPrefix, accountID)
-}
-
 // Account slot operations
 
 func (c *concurrencyCache) AcquireAccountSlot(ctx context.Context, accountID int64, maxConcurrency int, requestID string) (bool, error) {
@@ -312,75 +225,3 @@ func (c *concurrencyCache) DecrementWaitCount(ctx context.Context, userID int64)
 	_, err := decrementWaitScript.Run(ctx, c.rdb, []string{key}).Result()
 	return err
 }
-
-// Account wait queue operations
-
-func (c *concurrencyCache) IncrementAccountWaitCount(ctx context.Context, accountID int64, maxWait int) (bool, error) {
-	key := accountWaitKey(accountID)
-	result, err := incrementAccountWaitScript.Run(ctx, c.rdb, []string{key}, maxWait, c.waitQueueTTLSeconds).Int()
-	if err != nil {
-		return false, err
-	}
-	return result == 1, nil
-}
-
-func (c *concurrencyCache) DecrementAccountWaitCount(ctx context.Context, accountID int64) error {
-	key := accountWaitKey(accountID)
-	_, err := decrementWaitScript.Run(ctx, c.rdb, []string{key}).Result()
-	return err
-}
-
-func (c *concurrencyCache) GetAccountWaitingCount(ctx context.Context, accountID int64) (int, error) {
-	key := accountWaitKey(accountID)
-	val, err := c.rdb.Get(ctx, key).Int()
-	if err != nil && !errors.Is(err, redis.Nil) {
-		return 0, err
-	}
-	if errors.Is(err, redis.Nil) {
-		return 0, nil
-	}
-	return val, nil
-}
-
-func (c *concurrencyCache) GetAccountsLoadBatch(ctx context.Context, accounts []service.AccountWithConcurrency) (map[int64]*service.AccountLoadInfo, error) {
-	if len(accounts) == 0 {
-		return map[int64]*service.AccountLoadInfo{}, nil
-	}
-
-	args := []any{c.slotTTLSeconds}
-	for _, acc := range accounts {
-		args = append(args, acc.ID, acc.MaxConcurrency)
-	}
-
-	result, err := getAccountsLoadBatchScript.Run(ctx, c.rdb, []string{}, args...).Slice()
-	if err != nil {
-		return nil, err
-	}
-
-	loadMap := make(map[int64]*service.AccountLoadInfo)
-	for i := 0; i < len(result); i += 4 {
-		if i+3 >= len(result) {
-			break
-		}
-
-		accountID, _ := strconv.ParseInt(fmt.Sprintf("%v", result[i]), 10, 64)
-		currentConcurrency, _ := strconv.Atoi(fmt.Sprintf("%v", result[i+1]))
-		waitingCount, _ := strconv.Atoi(fmt.Sprintf("%v", result[i+2]))
-		loadRate, _ := strconv.Atoi(fmt.Sprintf("%v", result[i+3]))
-
-		loadMap[accountID] = &service.AccountLoadInfo{
-			AccountID:          accountID,
-			CurrentConcurrency: currentConcurrency,
-			WaitingCount:       waitingCount,
-			LoadRate:           loadRate,
-		}
-	}
-
-	return loadMap, nil
-}
-
-func (c *concurrencyCache) CleanupExpiredAccountSlots(ctx context.Context, accountID int64) error {
-	key := accountSlotKey(accountID)
-	_, err := cleanupExpiredSlotsScript.Run(ctx, c.rdb, []string{key}, c.slotTTLSeconds).Result()
-	return err
-}

backend/internal/repository/concurrency_cache_benchmark_test.go

@@ -22,7 +22,7 @@ func BenchmarkAccountConcurrency(b *testing.B) {
 		_ = rdb.Close()
 	}()
 
-	cache, _ := NewConcurrencyCache(rdb, benchSlotTTLMinutes, int(benchSlotTTL.Seconds())).(*concurrencyCache)
+	cache, _ := NewConcurrencyCache(rdb, benchSlotTTLMinutes).(*concurrencyCache)
 	ctx := context.Background()
 
 	for _, size := range []int{10, 100, 1000} {

backend/internal/repository/concurrency_cache_integration_test.go

@@ -27,7 +27,7 @@ type ConcurrencyCacheSuite struct {
 
 func (s *ConcurrencyCacheSuite) SetupTest() {
 	s.IntegrationRedisSuite.SetupTest()
-	s.cache = NewConcurrencyCache(s.rdb, testSlotTTLMinutes, int(testSlotTTL.Seconds()))
+	s.cache = NewConcurrencyCache(s.rdb, testSlotTTLMinutes)
 }
 
 func (s *ConcurrencyCacheSuite) TestAccountSlot_AcquireAndRelease() {
@@ -218,48 +218,6 @@ func (s *ConcurrencyCacheSuite) TestWaitQueue_DecrementNoNegative() {
 	require.GreaterOrEqual(s.T(), val, 0, "expected non-negative wait count")
 }
 
-func (s *ConcurrencyCacheSuite) TestAccountWaitQueue_IncrementAndDecrement() {
-	accountID := int64(30)
-	waitKey := fmt.Sprintf("%s%d", accountWaitKeyPrefix, accountID)
-
-	ok, err := s.cache.IncrementAccountWaitCount(s.ctx, accountID, 2)
-	require.NoError(s.T(), err, "IncrementAccountWaitCount 1")
-	require.True(s.T(), ok)
-
-	ok, err = s.cache.IncrementAccountWaitCount(s.ctx, accountID, 2)
-	require.NoError(s.T(), err, "IncrementAccountWaitCount 2")
-	require.True(s.T(), ok)
-
-	ok, err = s.cache.IncrementAccountWaitCount(s.ctx, accountID, 2)
-	require.NoError(s.T(), err, "IncrementAccountWaitCount 3")
-	require.False(s.T(), ok, "expected account wait increment over max to fail")
-
-	ttl, err := s.rdb.TTL(s.ctx, waitKey).Result()
-	require.NoError(s.T(), err, "TTL account waitKey")
-	s.AssertTTLWithin(ttl, 1*time.Second, testSlotTTL)
-
-	require.NoError(s.T(), s.cache.DecrementAccountWaitCount(s.ctx, accountID), "DecrementAccountWaitCount")
-
-	val, err := s.rdb.Get(s.ctx, waitKey).Int()
-	if !errors.Is(err, redis.Nil) {
-		require.NoError(s.T(), err, "Get waitKey")
-	}
-	require.Equal(s.T(), 1, val, "expected account wait count 1")
-}
-
-func (s *ConcurrencyCacheSuite) TestAccountWaitQueue_DecrementNoNegative() {
-	accountID := int64(301)
-	waitKey := fmt.Sprintf("%s%d", accountWaitKeyPrefix, accountID)
-
-	require.NoError(s.T(), s.cache.DecrementAccountWaitCount(s.ctx, accountID), "DecrementAccountWaitCount on non-existent key")
-
-	val, err := s.rdb.Get(s.ctx, waitKey).Int()
-	if !errors.Is(err, redis.Nil) {
-		require.NoError(s.T(), err, "Get waitKey")
-	}
-	require.GreaterOrEqual(s.T(), val, 0, "expected non-negative account wait count after decrement on empty")
-}
-
 func (s *ConcurrencyCacheSuite) TestGetAccountConcurrency_Missing() {
 	// When no slots exist, GetAccountConcurrency should return 0
 	cur, err := s.cache.GetAccountConcurrency(s.ctx, 999)
@@ -274,139 +232,6 @@ func (s *ConcurrencyCacheSuite) TestGetUserConcurrency_Missing() {
 	require.Equal(s.T(), 0, cur)
 }
 
-func (s *ConcurrencyCacheSuite) TestGetAccountsLoadBatch() {
-	s.T().Skip("TODO: Fix this test - CurrentConcurrency returns 0 instead of expected value in CI")
-	// Setup: Create accounts with different load states
-	account1 := int64(100)
-	account2 := int64(101)
-	account3 := int64(102)
-
-	// Account 1: 2/3 slots used, 1 waiting
-	ok, err := s.cache.AcquireAccountSlot(s.ctx, account1, 3, "req1")
-	require.NoError(s.T(), err)
-	require.True(s.T(), ok)
-	ok, err = s.cache.AcquireAccountSlot(s.ctx, account1, 3, "req2")
-	require.NoError(s.T(), err)
-	require.True(s.T(), ok)
-	ok, err = s.cache.IncrementAccountWaitCount(s.ctx, account1, 5)
-	require.NoError(s.T(), err)
-	require.True(s.T(), ok)
-
-	// Account 2: 1/2 slots used, 0 waiting
-	ok, err = s.cache.AcquireAccountSlot(s.ctx, account2, 2, "req3")
-	require.NoError(s.T(), err)
-	require.True(s.T(), ok)
-
-	// Account 3: 0/1 slots used, 0 waiting (idle)
-
-	// Query batch load
-	accounts := []service.AccountWithConcurrency{
-		{ID: account1, MaxConcurrency: 3},
-		{ID: account2, MaxConcurrency: 2},
-		{ID: account3, MaxConcurrency: 1},
-	}
-
-	loadMap, err := s.cache.GetAccountsLoadBatch(s.ctx, accounts)
-	require.NoError(s.T(), err)
-	require.Len(s.T(), loadMap, 3)
-
-	// Verify account1: (2 + 1) / 3 = 100%
-	load1 := loadMap[account1]
-	require.NotNil(s.T(), load1)
-	require.Equal(s.T(), account1, load1.AccountID)
-	require.Equal(s.T(), 2, load1.CurrentConcurrency)
-	require.Equal(s.T(), 1, load1.WaitingCount)
-	require.Equal(s.T(), 100, load1.LoadRate)
-
-	// Verify account2: (1 + 0) / 2 = 50%
-	load2 := loadMap[account2]
-	require.NotNil(s.T(), load2)
-	require.Equal(s.T(), account2, load2.AccountID)
-	require.Equal(s.T(), 1, load2.CurrentConcurrency)
-	require.Equal(s.T(), 0, load2.WaitingCount)
-	require.Equal(s.T(), 50, load2.LoadRate)
-
-	// Verify account3: (0 + 0) / 1 = 0%
-	load3 := loadMap[account3]
-	require.NotNil(s.T(), load3)
-	require.Equal(s.T(), account3, load3.AccountID)
-	require.Equal(s.T(), 0, load3.CurrentConcurrency)
-	require.Equal(s.T(), 0, load3.WaitingCount)
-	require.Equal(s.T(), 0, load3.LoadRate)
-}
-
-func (s *ConcurrencyCacheSuite) TestGetAccountsLoadBatch_Empty() {
-	// Test with empty account list
-	loadMap, err := s.cache.GetAccountsLoadBatch(s.ctx, []service.AccountWithConcurrency{})
-	require.NoError(s.T(), err)
-	require.Empty(s.T(), loadMap)
-}
-
-func (s *ConcurrencyCacheSuite) TestCleanupExpiredAccountSlots() {
-	accountID := int64(200)
-	slotKey := fmt.Sprintf("%s%d", accountSlotKeyPrefix, accountID)
-
-	// Acquire 3 slots
-	ok, err := s.cache.AcquireAccountSlot(s.ctx, accountID, 5, "req1")
-	require.NoError(s.T(), err)
-	require.True(s.T(), ok)
-	ok, err = s.cache.AcquireAccountSlot(s.ctx, accountID, 5, "req2")
-	require.NoError(s.T(), err)
-	require.True(s.T(), ok)
-	ok, err = s.cache.AcquireAccountSlot(s.ctx, accountID, 5, "req3")
-	require.NoError(s.T(), err)
-	require.True(s.T(), ok)
-
-	// Verify 3 slots exist
-	cur, err := s.cache.GetAccountConcurrency(s.ctx, accountID)
-	require.NoError(s.T(), err)
-	require.Equal(s.T(), 3, cur)
-
-	// Manually set old timestamps for req1 and req2 (simulate expired slots)
-	now := time.Now().Unix()
-	expiredTime := now - int64(testSlotTTL.Seconds()) - 10 // 10 seconds past TTL
-	err = s.rdb.ZAdd(s.ctx, slotKey, redis.Z{Score: float64(expiredTime), Member: "req1"}).Err()
-	require.NoError(s.T(), err)
-	err = s.rdb.ZAdd(s.ctx, slotKey, redis.Z{Score: float64(expiredTime), Member: "req2"}).Err()
-	require.NoError(s.T(), err)
-
-	// Run cleanup
-	err = s.cache.CleanupExpiredAccountSlots(s.ctx, accountID)
-	require.NoError(s.T(), err)
-
-	// Verify only 1 slot remains (req3)
-	cur, err = s.cache.GetAccountConcurrency(s.ctx, accountID)
-	require.NoError(s.T(), err)
-	require.Equal(s.T(), 1, cur)
-
-	// Verify req3 still exists
-	members, err := s.rdb.ZRange(s.ctx, slotKey, 0, -1).Result()
-	require.NoError(s.T(), err)
-	require.Len(s.T(), members, 1)
-	require.Equal(s.T(), "req3", members[0])
-}
-
-func (s *ConcurrencyCacheSuite) TestCleanupExpiredAccountSlots_NoExpired() {
-	accountID := int64(201)
-
-	// Acquire 2 fresh slots
-	ok, err := s.cache.AcquireAccountSlot(s.ctx, accountID, 5, "req1")
-	require.NoError(s.T(), err)
-	require.True(s.T(), ok)
-	ok, err = s.cache.AcquireAccountSlot(s.ctx, accountID, 5, "req2")
-	require.NoError(s.T(), err)
-	require.True(s.T(), ok)
-
-	// Run cleanup (should not remove anything)
-	err = s.cache.CleanupExpiredAccountSlots(s.ctx, accountID)
-	require.NoError(s.T(), err)
-
-	// Verify both slots still exist
-	cur, err := s.cache.GetAccountConcurrency(s.ctx, accountID)
-	require.NoError(s.T(), err)
-	require.Equal(s.T(), 2, cur)
-}
-
 func TestConcurrencyCacheSuite(t *testing.T) {
 	suite.Run(t, new(ConcurrencyCacheSuite))
 }

backend/internal/repository/wire.go

@@ -15,14 +15,7 @@ import (
 // ProvideConcurrencyCache 创建并发控制缓存，从配置读取 TTL 参数
 // 性能优化：TTL 可配置，支持长时间运行的 LLM 请求场景
 func ProvideConcurrencyCache(rdb *redis.Client, cfg *config.Config) service.ConcurrencyCache {
-	waitTTLSeconds := int(cfg.Gateway.Scheduling.StickySessionWaitTimeout.Seconds())
-	if cfg.Gateway.Scheduling.FallbackWaitTimeout > cfg.Gateway.Scheduling.StickySessionWaitTimeout {
-		waitTTLSeconds = int(cfg.Gateway.Scheduling.FallbackWaitTimeout.Seconds())
-	}
-	if waitTTLSeconds <= 0 {
-		waitTTLSeconds = cfg.Gateway.ConcurrencySlotTTLMinutes * 60
-	}
-	return NewConcurrencyCache(rdb, cfg.Gateway.ConcurrencySlotTTLMinutes, waitTTLSeconds)
+	return NewConcurrencyCache(rdb, cfg.Gateway.ConcurrencySlotTTLMinutes)
 }
 
 // ProviderSet is the Wire provider set for all repositories