File size: 11,062 Bytes
e48a2d8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
// windowprobe.go 额度窗口探针(借鉴 ardeyouxipianyi/workbuddy2api-hub 的 wb_window_probe.py)。
//
// 登记侧在 pool/window.go:429 带「将在 … 重置」时记一条窗口。本文件是执行侧——
// 到点后为那个 (账号, 模型) 发一个最小请求,把新一轮配额窗口的计时起点钉在重置
// 那一刻。
//
// 为什么必须主动发:上游按**首次请求**起算窗口。重置时刻到了却没人发请求,窗口就
// 不开始,额度一直空转;等下一条真实请求进来,起点落到那一刻——通常晚了几分钟到
// 几十分钟,那段时间的额度等于白扔。我们原来的处理只到「解除冷却」(允许请求进来),
// 是被动的。
//
// 四种结果的处置:
//   - 探针 2xx         → 窗口已开:清掉该 (账号,模型) 的 6004 冷却,删窗口记录;
//   - 429 + 更晚的重置 → 上游确实开了新一轮,把 ResetAt 换成新的,计数归零;
//   - 429 + 同样/更早   → 上游还没放开(服务端时钟/处理延迟),过一会儿重试;
//   - 其它错误         → 同样按重试处理,连续 windowProbeMaxAttempts 次后放弃
//     (删记录,下一次真实 429 会重新登记)。
//
// 刻意**不**做的事:主动扫描还没被限流的「账号 × 模型」配额线(hub 的
// wb_quota_scan)。那是另一种功能:它要用探针去**发现**哪条线满了,请求量随
// 账号×模型数增长,与「已经知道满了、只等起窗」不是一件事。混在一起会让本机制的
// 请求量从「每个已登记窗口一次」变成「每 6 小时 × 账号数 × 模型数」。
package scheduler

import (
	"context"
	"encoding/json"
	"errors"
	"io"
	"log"
	"strconv"
	"time"

	"github.com/misakano7545/workbuddy2api-panel/internal/pool"
	"github.com/misakano7545/workbuddy2api-panel/internal/upstream"
)

const (
	// windowProbePrompt / windowProbeMaxTokens 探针请求要尽量小:它唯一的目的是让
	// 上游把这一轮窗口的计时起点定在此刻,产出什么都不重要。
	windowProbePrompt    = "Hi"
	windowProbeMaxTokens = 16
	// windowProbeTimeout 单次探针的硬上限。取 60s:上游劣化期 TTFB 可能到几十秒
	// (见 internal/server/upstreamhealth.go 的实测),但探针不值得为它等更久。
	windowProbeTimeout = 60 * time.Second
	// windowProbeRetryDelay 到点后上游常还没真正放开(服务端时钟/处理延迟几秒到
	// 几分钟)。15s 首次重试:太密是白打上游,太疏会错过窗口起点。
	windowProbeRetryDelay = 15 * time.Second
	// windowProbeMaxAttempts 连续这么多次探针仍未开窗就放弃。20 × 15s ≈ 5 分钟,
	// 覆盖「上游声明时刻比实际早几分钟」的常见偏差。
	windowProbeMaxAttempts = 20
	// windowProbeFreshMin 429 给的重置点比「现在 + 这个值」还远,才算上游真的开了
	// 一轮新窗口;否则只是探针发早了,仍按同一轮重试。
	windowProbeFreshMin = 30 * time.Second
	// windowProbeBatchLimit 一轮最多处理几个窗口:一个卡住的上游不该把巡检线程占满。
	windowProbeBatchLimit = 8
	// windowProbeGap 多个窗口同时到点时错开,别在同一秒向上游打一串请求。
	windowProbeGap = 400 * time.Millisecond
	// windowProbeIdle 没有待处理窗口时的巡检间隔。有窗口时按最近的 ResetAt 精确
	// 醒来(见 Run 循环),这个值只在完全空闲时用于兜底——比如面板手工登记、
	// 或另一个进程写了 state.json。
	windowProbeIdle = 30 * time.Second
)

// windowProbeBody 构造探针请求体。
//
// stream:true 是必须的(上游只认流式,非流式会 400/挂住,同 /v1/chat/completions
// 的 stream:false 路径也是按 SSE 聚合出来的)。
func windowProbeBody(model string) ([]byte, error) {
	return json.Marshal(map[string]any{
		"model": model,
		"messages": []map[string]any{
			{"role": "user", "content": windowProbePrompt},
		},
		"stream":     true,
		"max_tokens": windowProbeMaxTokens,
	})
}

// StartModelWindowProbe 启动额度窗口探针循环(独立 goroutine,ctx 取消即停)。
//
// 与 StartBalanceRefresh 同构:独立于 Run 的小时制排程——窗口到点是秒级事件,
// 不值得为它扩展 nextFire 的粒度。
func (s *Scheduler) StartModelWindowProbe(ctx context.Context) {
	if s.cfg.Pool == nil || s.cfg.Upstream == nil {
		return
	}
	go func() {
		for {
			due := s.cfg.Pool.DueModelWindows(time.Now())
			if len(due) > 0 {
				s.runWindowProbes(ctx, due)
				if ctx.Err() != nil {
					return
				}
				// 一轮处理完立刻回到循环顶重判(可能还有待处理窗口)。
				continue
			}
			wait := windowProbeIdle
			if next, ok := s.cfg.Pool.NextModelWindowDue(); ok {
				if d := time.Until(next); d < wait {
					wait = d
				}
			}
			if wait < 0 {
				wait = 0
			}
			timer := time.NewTimer(wait)
			select {
			case <-ctx.Done():
				timer.Stop()
				return
			case <-timer.C:
			}
		}
	}()
}

// RunModelWindowProbeNow 立即处理一轮到点的窗口,返回实际发出的探针数。
// 面板「立即探针」与测试用;正常路径由 StartModelWindowProbe 驱动。
func (s *Scheduler) RunModelWindowProbeNow() int {
	if s.cfg.Pool == nil || s.cfg.Upstream == nil {
		return 0
	}
	return s.runWindowProbes(context.Background(), s.cfg.Pool.DueModelWindows(time.Now()))
}

// runWindowProbes 逐条处理窗口。返回实际发出的探针数(不含被跳过的)。
func (s *Scheduler) runWindowProbes(ctx context.Context, due []pool.ModelWindow) int {
	if len(due) > windowProbeBatchLimit {
		due = due[:windowProbeBatchLimit]
	}
	sent := 0
	for i, w := range due {
		if ctx.Err() != nil {
			return sent
		}
		if i > 0 {
			// 可取消的错开等待:ctx 取消(停机)时不必等满。
			select {
			case <-ctx.Done():
				return sent
			case <-time.After(windowProbeGap):
			}
		}
		if s.probeWindow(ctx, w) {
			sent++
		}
	}
	return sent
}

// probeWindow 处理单个窗口,返回是否真的发出了上游请求。
func (s *Scheduler) probeWindow(ctx context.Context, w pool.ModelWindow) bool {
	a := s.cfg.Pool.AuthFor(w.UID)
	now := time.Now()
	if a == nil {
		// 账号已不在池中(被删/被替换):记录留着只会每轮都被取出来,删掉。
		s.cfg.Pool.DropModelWindow(w.UID, w.Model)
		log.Printf("INFO: [window] 账号 %s 已不在池中,丢弃 %s 的窗口记录", shortUID(w.UID), w.Model)
		return false
	}
	st, ok := s.cfg.Pool.Status(w.UID)
	if ok && st.Disabled {
		// 停用的号不该被自动唤醒:把 ResetAt 往后推一段,保留记录等它被重新启用。
		s.cfg.Pool.RecordWindowProbe(w.UID, w.Model, now.Add(windowProbeRetryDelay),
			w.Attempts+1, "账号已停用,暂不探针", now)
		return false
	}

	ok2, resetAt, detail := s.fireWindowProbe(ctx, w)
	now = time.Now()
	if ok2 {
		// 探针通了:这条额度线已经重置。清 6004 冷却 + 删窗口记录。
		//
		// 清冷却的对齐点是**这条窗口自己的 ResetAt**,不是现在:探针证明的是「这条
		// 窗口对应的那轮限额已经过去」,只有 ResetAt 不晚于它的冷却才该被清。探针
		// 期间若又撞上更新一轮的限额(ResetAt 更晚),那条是上游刚给的墙钟,不能被
		// 这次成功抹掉。
		cleared := s.cfg.Pool.ClearQuotaCooldown(w.UID, w.Model, w.ResetAt)
		s.cfg.Pool.DropModelWindow(w.UID, w.Model)
		log.Printf("INFO: [window] %s 的 %s 已开始新一轮计时(探针成功,清冷却=%v)",
			shortUID(w.UID), w.Model, cleared)
		return true
	}
	if !resetAt.IsZero() && resetAt.After(now.Add(windowProbeFreshMin)) {
		// 上游给了更晚的重置点:这条线确实进入了新的等待期,换成新墙钟、计数归零。
		s.cfg.Pool.RecordWindowProbe(w.UID, w.Model, resetAt, 0, detail, now)
		log.Printf("INFO: [window] %s 的 %s 仍在限流,下一轮重置 %s",
			shortUID(w.UID), w.Model, resetAt.Format("2006-01-02 15:04:05"))
		return true
	}
	attempts := w.Attempts + 1
	if attempts >= windowProbeMaxAttempts {
		s.cfg.Pool.DropModelWindow(w.UID, w.Model)
		log.Printf("WARN: [window] %s 的 %s 连续 %d 次未重置,放弃(下一次真实 429 会重新登记)",
			shortUID(w.UID), w.Model, attempts)
		return true
	}
	s.cfg.Pool.RecordWindowProbe(w.UID, w.Model, now.Add(windowProbeRetryDelay),
		attempts, detail, now)
	log.Printf("INFO: [window] %s 的 %s 尚未重置(%s),%s 后重试 (%d/%d)",
		shortUID(w.UID), w.Model, orNone(detail), windowProbeRetryDelay, attempts, windowProbeMaxAttempts)
	return true
}

// fireWindowProbe 发一次最小请求。
//
// 返回 (ok, resetAt, detail):
//   - ok=true       上游 2xx,该模型的额度窗口已重置;
//   - resetAt 非零  上游又回了 429 并给出重置时刻;
//   - detail        失败原因(日志与窗口记录用)。
func (s *Scheduler) fireWindowProbe(ctx context.Context, w pool.ModelWindow) (bool, time.Time, string) {
	a := s.cfg.Pool.AuthFor(w.UID)
	if a == nil {
		return false, time.Time{}, "账号已不在池中"
	}
	body, err := windowProbeBody(w.Model)
	if err != nil {
		return false, time.Time{}, "构造请求失败: " + err.Error()
	}
	pctx, cancel := context.WithTimeout(ctx, windowProbeTimeout)
	defer cancel()
	// AgentType=auxiliary:这是一次内部维护请求,不是用户主对话(口径同
	// web_search 的探测轮)。上游看到的仍是一个正常的 chat 请求。
	rc, status, respBody, err := s.cfg.Upstream.ChatStreamContext(pctx, a, body, "",
		upstream.ChatMeta{AgentType: upstream.AgentTypeAuxiliary}, nil)
	if err != nil {
		var ue *upstream.Error
		if errors.As(err, &ue) {
			// body 的重置文案优先(上游权威),其次看状态码。
			if resetAt, ok := upstream.ParseRateReset(ue.Msg); ok {
				return false, resetAt, clip(ue.Msg)
			}
			if ue.Status == 429 {
				return false, time.Time{}, clip(ue.Msg)
			}
			return false, time.Time{}, "HTTP " + strconv.Itoa(ue.Status) + ": " + clip(ue.Msg)
		}
		return false, time.Time{}, clip(err.Error())
	}
	if rc != nil {
		// 读干净再关:不读完的响应体不归还连接(net/http 语义),而这条连接后面
		// 还要被真实请求复用。max_tokens=16 时这一步是毫秒级。
		_, _ = io.Copy(io.Discard, rc)
		_ = rc.Close()
	}
	if status >= 400 {
		if resetAt, ok := upstream.ParseRateReset(string(respBody)); ok {
			return false, resetAt, clip(string(respBody))
		}
		return false, time.Time{}, "HTTP " + strconv.Itoa(status) + ": " + clip(string(respBody))
	}
	return true, time.Time{}, ""
}

// shortUID 日志里的账号称呼:前 8 位,不落完整 UID(同 dump.go 口径)。
func shortUID(uid string) string {
	if len(uid) > 8 {
		return uid[:8]
	}
	if uid == "" {
		return "?"
	}
	return uid
}

func orNone(s string) string {
	if s == "" {
		return "无详情"
	}
	return s
}

func clip(s string) string {
	if len(s) > 200 {
		return s[:200]
	}
	return s
}