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
}
|