Download internal/scheduler/windowprobe.go from a3216/gcli2api: direct link, hf CLI and curl.
- Browser
- Download file 11.1 kB
-
https://huggingface.co/spaces/a3216/gcli2api/resolve/main/internal/scheduler/windowprobe.go
- Command line
-
hf download hf://spaces/a3216/gcli2api/internal/scheduler/windowprobe.go
-
curl -L -o windowprobe.go https://huggingface.co/spaces/a3216/gcli2api/resolve/main/internal/scheduler/windowprobe.go
11.1 kB
| // 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 | |
| } | |