File size: 10,688 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
282
283
284
285
286
287
288
// window.go 额度窗口登记表(借鉴 ardeyouxipianyi/workbuddy2api-hub 的 wb_window_probe.py)。
//
// 补的是一个此前完全空着的半段:上游的免费额度窗口按**首次请求**起算。某条
// (账号, 模型) 的配额打满后,6004 的 429 会给出一个「将在 … 重置」的绝对时刻。
// 到点之后如果没有任何请求进来,新一轮窗口就不会开始——额度一直空转,下一次真实
// 请求来的时候窗口起点才被动落到那一刻,整整晚一截。
//
// 我们原本的处理到「解除冷却」为止:CooldownSoftForModel 把 Until 对齐上游墙钟,
// 到点 healthyForModel 放行——这是**被动**的,只是允许请求进来,不是让窗口开始计时。
//
// 本文件负责登记侧:429 带重置时刻时记一条窗口。到点的执行在 scheduler(那里才有
// upstream 客户端),探针成功后调 ClearQuotaCooldown 清模型级冷却。
//
// 为什么不复用 modelCooldowns:那张表是**路由**语义(不可选/可选),6004 条目在
// Until 到期的瞬间就被 pruneExpiredModelCooldowns 删掉——正好是我们要处理的时刻。
// 窗口是**排程**语义(到点该发一个请求),生命周期比冷却长,必须独立存。
//
// 与参照实现的差异:不做 quota_scan(主动轮询还没被限流的配额线)。那是另一种
// 功能——它要用探针去发现「哪条线已经满了」,而本文件只处理「已经知道满了、只等
// 起窗」的那一段。把两者混在一起会让探针请求量随账号×模型数量增长,而这一段是
// 每个已登记窗口只发一次。
package pool

import (
	"sort"
	"time"
)

// windowKey 窗口键:账号 + 裸模型名(不含域前缀)。
//
// 为什么不带域:同一账号只属于一个域,键里再加 realm 是冗余维度,只会让查表多一次
// 拼接、让面板多一列解释。
func windowKey(uid, model string) string { return uid + "\x00" + model }

// ModelWindow 一个已登记的额度窗口(对外只读视图)。
type ModelWindow struct {
	// UID 账号;Model 裸模型名(上游认的那个,不含 cn:/global: 前缀)。
	UID   string `json:"uid"`
	Model string `json:"model"`
	// ResetAt 上游给的重置时刻——这是新一轮窗口该起算的时刻。
	ResetAt time.Time `json:"reset_at"`
	// Attempts 到点后已重试次数(上游常比宣称的时刻晚几秒放开)。
	Attempts int `json:"attempts"`
	// LastTry / LastResult 上次探针的时刻与结果摘要(面板与排障用)。
	LastTry    time.Time `json:"last_try,omitempty"`
	LastResult string    `json:"last_result,omitempty"`
	// Quota true = 这次是 6004「使用量已超出频率限制」判定额度用满,
	// 而不是普通 429 临时限流。只作展示与日志区分,不改变探针行为。
	Quota bool `json:"quota,omitempty"`
}

// stateModelWindow 窗口的持久化形态(与 ModelWindow 同构,字段名对齐)。
type stateModelWindow struct {
	UID        string    `json:"uid"`
	Model      string    `json:"model"`
	ResetAt    time.Time `json:"reset_at"`
	Attempts   int       `json:"attempts,omitempty"`
	LastTry    time.Time `json:"last_try,omitempty"`
	LastResult string    `json:"last_result,omitempty"`
	Quota      bool      `json:"quota,omitempty"`
}

// windowMaxAge 窗口过期这么久还没被处理就丢弃:账号大概已删除或这条额度线早已
// 换了一轮,再探也是白打上游。
const windowMaxAge = 7 * 24 * time.Hour

// ScheduleModelWindow 登记一个额度窗口,返回是否新增/更新了记录。
//
// resetAt 必须在未来:已经过去的重置时刻说明窗口已经开始了(或者这是我们自己在
// 解析上的偏差),登记它只会在下一轮巡检里立刻触发一次无意义探针。
//
// 同一个窗口的重复 429(一次限流会连着撞好几次)时间戳一致,这里返回 false 不重写
// ——落盘由 dirty 标志触发,无谓地一直置 dirty 会让 flusher 每 5 秒写一次盘。
func (p *Pool) ScheduleModelWindow(uid, model string, resetAt time.Time, quota bool, now time.Time) bool {
	if uid == "" || model == "" || resetAt.IsZero() || !resetAt.After(now) {
		return false
	}
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.windows == nil {
		p.windows = map[string]*ModelWindow{}
	}
	// 顺手清掉过期太久的条目:窗口只在 429 时新增,长期运行的部署里被删除的账号
	// 会留下永不触发的记录,没有清理就会一直跟着 state.json 落盘。
	p.pruneWindowsLocked(now)
	key := windowKey(uid, model)
	if w, ok := p.windows[key]; ok && w.ResetAt.Equal(resetAt) {
		if quota && !w.Quota {
			w.Quota = true
			p.dirty.Store(true)
			return true
		}
		return false
	}
	p.windows[key] = &ModelWindow{UID: uid, Model: model, ResetAt: resetAt, Quota: quota}
	p.dirty.Store(true)
	return true
}

// ModelWindows 返回当前全部窗口的快照,按 ResetAt 升序(最该处理的在前)。
func (p *Pool) ModelWindows() []ModelWindow {
	p.mu.RLock()
	defer p.mu.RUnlock()
	return p.windowListLocked()
}

func (p *Pool) windowListLocked() []ModelWindow {
	out := make([]ModelWindow, 0, len(p.windows))
	for _, w := range p.windows {
		out = append(out, *w)
	}
	sort.Slice(out, func(i, j int) bool {
		if out[i].ResetAt.Equal(out[j].ResetAt) {
			return out[i].UID < out[j].UID
		}
		return out[i].ResetAt.Before(out[j].ResetAt)
	})
	return out
}

// DueModelWindows 已到点(ResetAt <= now)的窗口,按 ResetAt 升序。
func (p *Pool) DueModelWindows(now time.Time) []ModelWindow {
	p.mu.RLock()
	defer p.mu.RUnlock()
	var out []ModelWindow
	for _, w := range p.windows {
		if !w.ResetAt.After(now) {
			out = append(out, *w)
		}
	}
	sort.Slice(out, func(i, j int) bool {
		if out[i].ResetAt.Equal(out[j].ResetAt) {
			return out[i].UID < out[j].UID
		}
		return out[i].ResetAt.Before(out[j].ResetAt)
	})
	return out
}

// NextModelWindowDue 最近一个窗口的到点时刻;没有待处理窗口时 ok=false。
//
// 排程用:把下一次唤醒钉在重置那一刻附近,而不是等一个固定周期——固定周期意味着
// 平均半个周期的空转,正是本功能要消除的那段。
func (p *Pool) NextModelWindowDue() (time.Time, bool) {
	p.mu.RLock()
	defer p.mu.RUnlock()
	var next time.Time
	for _, w := range p.windows {
		if next.IsZero() || w.ResetAt.Before(next) {
			next = w.ResetAt
		}
	}
	return next, !next.IsZero()
}

// RecordWindowProbe 记一次探针结果。resetAt 非零表示上游又给了更晚的重置时刻
// (这条额度线确实进入新一轮等待),此时计数归零;resetAt 为零表示「还没放开」,
// 由调用方把 ResetAt 推到重试时刻并给出累计次数。
func (p *Pool) RecordWindowProbe(uid, model string, resetAt time.Time, attempts int, result string, now time.Time) bool {
	p.mu.Lock()
	defer p.mu.Unlock()
	w, ok := p.windows[windowKey(uid, model)]
	if !ok {
		return false
	}
	if !resetAt.IsZero() {
		w.ResetAt = resetAt
	}
	if !now.IsZero() {
		w.LastTry = now
	}
	w.Attempts = attempts
	if len(result) > 200 {
		result = result[:200]
	}
	w.LastResult = result
	p.dirty.Store(true)
	return true
}

// DropModelWindow 撤销一条窗口记录(探针成功、放弃、或账号已不在池中)。
func (p *Pool) DropModelWindow(uid, model string) bool {
	p.mu.Lock()
	defer p.mu.Unlock()
	key := windowKey(uid, model)
	if _, ok := p.windows[key]; !ok {
		return false
	}
	delete(p.windows, key)
	p.dirty.Store(true)
	return true
}

// ClearQuotaCooldown 探针成功后清掉该 (账号, 模型) 的 6004 模型级冷却。
//
// at 传**这条窗口自己的 ResetAt**(不是 time.Now()):探针证明的是「这条窗口对应的
// 那轮限额已经过去」,只有 ResetAt 不晚于它的冷却才该被清。
//
// 只清 **ResetAt 非零且不晚于 at** 的条目:11102 负缓存(ResetAt 零值)与「探针
// 期间又撞上的更新一轮限额」(ResetAt 更晚)都不能被一次成功抹掉——后者尤其危险,
// 那是上游刚给出的新墙钟,清掉等于立刻又去撞一次 429。
//
// 账号级冷却一概不碰:那是网络故障/余额类问题留下的,与本文件的额度窗口无关。
func (p *Pool) ClearQuotaCooldown(uid, model string, at time.Time) bool {
	if uid == "" || model == "" {
		return false
	}
	p.mu.Lock()
	defer p.mu.Unlock()
	e, ok := p.byUID[uid]
	if !ok {
		return false
	}
	mc, ok := e.modelCooldowns[model]
	if !ok || mc.ResetAt.IsZero() || mc.ResetAt.After(at) {
		return false
	}
	delete(e.modelCooldowns, model)
	if len(e.modelCooldowns) == 0 {
		e.modelCooldowns = nil
	}
	p.dirty.Store(true)
	return true
}

// pruneWindowsLocked 丢弃过期太久的窗口(惰性清理,防 map 无限增长)。
// 调用方必须已持有 p.mu 写锁。
func (p *Pool) pruneWindowsLocked(now time.Time) {
	for k, w := range p.windows {
		if w.ResetAt.IsZero() || w.ResetAt.Before(now.Add(-windowMaxAge)) {
			delete(p.windows, k)
		}
	}
	// 刻意不把空表置 nil:本函数在 ScheduleModelWindow 的写锁内、紧接着 map 赋值
	// 调用,置 nil 会让那次赋值 panic(nil map)。空 map 与 nil map 在读取侧等价
	// (range/len/查表都安全),不值得为省一个 map header 埋这个坑。
}

// loadWindowsLocked 从持久化记录恢复窗口表(惰性剔除过期太久与结构破损条目)。
func (p *Pool) loadWindowsLocked(windows map[string]stateModelWindow, now time.Time) {
	if len(windows) == 0 {
		return
	}
	for k, s := range windows {
		if s.UID == "" || s.Model == "" || s.ResetAt.IsZero() || s.ResetAt.Before(now.Add(-windowMaxAge)) {
			continue
		}
		if p.windows == nil {
			p.windows = map[string]*ModelWindow{}
		}
		p.windows[k] = &ModelWindow{
			UID:        s.UID,
			Model:      s.Model,
			ResetAt:    s.ResetAt,
			Attempts:   s.Attempts,
			LastTry:    s.LastTry,
			LastResult: s.LastResult,
			Quota:      s.Quota,
		}
	}
}

// windowsStateLocked 收集窗口表为持久化形态(只写未过期条目)。
func (p *Pool) windowsStateLocked(now time.Time) map[string]stateModelWindow {
	if len(p.windows) == 0 {
		return nil
	}
	out := make(map[string]stateModelWindow, len(p.windows))
	for k, w := range p.windows {
		if w.ResetAt.IsZero() || w.ResetAt.Before(now.Add(-windowMaxAge)) {
			continue
		}
		out[k] = stateModelWindow{
			UID:        w.UID,
			Model:      w.Model,
			ResetAt:    w.ResetAt,
			Attempts:   w.Attempts,
			LastTry:    w.LastTry,
			LastResult: w.LastResult,
			Quota:      w.Quota,
		}
	}
	if len(out) == 0 {
		return nil
	}
	return out
}