feat(llm): 上游账号冷却改指数退避 + 真实请求探测闭环 (1.0.44)

天锚定重置边界计算(resets)删掉:锚点算错过两次(1.0.14 / 1.0.24),
线上表现为「厂商 15:00 已重置、网关锁到 18:00」。resets 只存不路由。

新口径:uac: = <backoff>:<next_probe>:<hard_cap>
- 到期放一个「无绑定/绑定失效」的真实请求过去探测,2xx → clear_cool 回队;
- 仍耗尽 → 退避翻倍(首轮 ipass_probe_min,默认 60s,30min 硬顶无条件回队自愈);
- 绑定流量永不被劫持当探测(保 prompt 缓存亲和)。
- pick_account 必须纯决策:四个 $llm_* 变量各求值一次,副作用只在 log 阶段记一次。

fix: 探测窗口判定改严格小于 —— 秒级时钟下 >= 会让「标记于 45.95s、next_probe=46」
的账号在 46.05s 即被当探测目标,1s 退避实际只等 0.05s,冷却形同虚设(回归暴露)。

回归 370 条全绿(网关 108 + LLM 262,新增「探测恢复闭环」剧本)。
This commit is contained in:
admin committed 2026-09-17 07:19:35 +08:00
1 parent 515dcb3134
commit 0a9047840d
19 files changed
+561 -202

No files matched your search

+14 -9
View File
@@ -116,7 +116,7 @@ rust/
| `plugin-llm` | `llm`(slot 解析/变量求值)、`upstreams`(CRUD/写穿/健康/**多账号路由**/账号负载)、`usage_filter`(body filter 抓 usage+耗尽 marker,走 `loc::enabled`+`ctx_index`)、`llm_audit`(对话审计落盘)、`stats`(用量账本+趋势)、`stats_persist`(统计落盘/恢复,1.0.18)、`handlers`(Llm/LlmHealth/Audit)、`api`、`config/models/store` | `up:` `upa:` `uac:` `ukb:` `upe:` `uh:` `ust:` `ums:` `utt:` `utms:` `ud:` `udu:` `uds:` `uda:` `uex:` `spr:` |
| `plugin-apix` | `apix`(slug/拼体/写穿)、`handlers`(ApiProxyHandler)、`api`、`config/models/store` | `ax:` |
gateway 只剩:模块壳(7 条指令 + `ModuleConfig` 开关 + 变量/装载装配循环)、
gateway 只剩:模块壳(8 条指令(含 1.0.44 `ipass_probe_min`)+ `ModuleConfig` 开关 + 变量/装载装配循环)、
`ApiHandler`(读体后按 PLUGINS 顺序分发、统一 404)、`/api/admin/trend`
(需 users+upstreams+apix 三方名册,属组合根)。
@@ -198,8 +198,11 @@ POST /openai/v1/chat/completions Authorization: Bearer sk_<本网关签
| 位置 | 职责 |
| --- | --- |
| `crates/plugin-llm/src/llm.rs` | 热路径:slot 解析、Bearer 提取、身份查询、OpenAI 兼容错误体、三个变量的 get_handler |
| `crates/plugin-llm/src/upstreams.rs` | 上游校验/读写/写穿共享内存,是域名插件在 LLM 侧的翻版;`models` 登记 + `available()` / `models_flat()` 模型发现;**多账号路由**(`pick_account` 粘性 + FNV-1a 冷分散 + 天锚定冷却 `cool_until_until`)、**账号级负载**(`uda:`/`uex:` 日桶,`view()` 投影)、**`normalize_auth`**(裸 key 自动补 `Bearer `,写入 `upsert` + 读出 `read_upa` 双处应用) |
| `crates/plugin-llm/src/llm.rs` | 热路径:slot 解析、Bearer 提取、身份查询、OpenAI 兼容错误体、四个 `$llm_*` 变量的 get_handler(共享、每次求值各调一次 pick,故 pick 保持纯决策) |
| `crates/plugin-llm/src/upstreams.rs` | 上游校验/读写/写穿共享内存,是域名插件在 LLM 侧的翻版;`models` 登记 + `available()` / `models_flat()` 模型发现;**多账号路由**(`pick_account` 粘性 + FNV-1a 冷分散 + **探测闭环冷却**:`uac:` 值
`<backoff>:<next_probe>:<hard_cap>`,到期放一个无绑定真实请求去探测,2xx 即 `clear_cool` 回队、
失败 `mark_exhausted` 内 re-arm 翻倍;**pick 必须保持纯决策**——副作用归 log 阶段,
四个 `$llm_*` 变量各求值一次 pick。1.0.44 删除天锚定边界计算,`resets` 只存不路由)、**账号级负载**(`uda:`/`uex:` 日桶,`view()` 投影)、**`normalize_auth`**(裸 key 自动补 `Bearer `,写入 `upsert` + 读出 `read_upa` 双处应用) |
| `crates/plugin-llm/src/stats.rs` | 用量账本(`ust:` 每账号 / `ums:` 每账号×上游,请求级、只读 shm)与 `overview()` 投影;**唯一写点在 `LlmHandler` 鉴权全通过之后** |
| `crates/plugin-llm/src/stats_persist.rs` | 统计落盘/恢复(1.0.18):快照 `data/llm-stats.json`、白名单 `PREFIXES`、退出钩子 + 周期落盘、put-if-absent 恢复、`spr:last` 恢复记录 / `spd:last` 落盘记录(**都在 shm、都别放进程内静态量**) |
| `data/llm-upstreams.json` | 上游表(**含真实密钥**);`base` 可带路径,`auth` 是完整的 Authorization 值,`models` 仅供模型发现 |
@@ -287,6 +290,8 @@ location 与 80 端口 LLM server 是两份拷贝,改一处记得同步另一
| --- | --- |
| 全站 401 | `ukey:` 索引没装载 → 看启动日志「已装载 N 个账号 Key」;Key 刚重置则旧 Key 立即失效 |
| 某账号一直 403 | `allowed_models` 非空且不含该 slot;记住空表 = 不限 |
| 账号耗尽后迟迟不恢复(1.0.44 探测闭环) | 看 `uac:` 时间线:`agent.sh upstreams` 的冷却徽章 hover / view 的 `probe_next`。到期未被探测 = 一直没有**无绑定**流量(绑定流量永不劫持,属预期);最长硬顶 30min,过期回队若仍耗尽会被再标 |
| 探测请求吃了 429(用户投诉偶发失败) | 设计如此:恢复只能靠真实请求验证,代价被退避封顶(每账号每轮 ≤1 个无绑定请求)。想更快恢复就调低 `ipass_probe_min`;想更省就调高 |
| 404 但上游明明配了 | `enabled: false` 会被摘除;或手改了 json 没重启(热路径无回源兜底) |
| 上游 404 且**响应体为空** | 上游 `base` 带 `/v1` 而客户端也带 `/v1` → 拼成 `/v1/v1/...`;查 `llm::join_target` 的去重分支 |
| `/v1/models` 反而 404 | `is_models_probe` 的位置错了:**必须在解析 slot 之前**,否则被当成 `slot=v1` |
@@ -295,8 +300,8 @@ location 与 80 端口 LLM server 是两份拷贝,改一处记得同步另一
| **发版后用量/趋势全变 0** | 快照没落上:查 `data/llm-stats.json` 是否存在 / 可写(数据卷),看 error log 有无 `[stats]` 报错。⚠️ 注意**登录会话(`sess:`)与配额(`st:`)重启清零是设计如此**,别把这两样当成故障 |
| `restored_keys == 0` 但 `file_keys > 0` | 快照版本不符 / 解析失败(会改名 `.bad` 留档)/ 全部过期。看 error log 的 `[stats]` 行 |
| 某维度发版后从 0 开始、别的维度不丢 | 新加的统计前缀**漏加进 `stats_persist::PREFIXES`**(不报错,只在发版后暴露) |
| 账号负载数是真实值的 3 倍 | `bump_acct_load` 被放进了 `pick_account` —— `$llm_target`/`$llm_auth`/`$llm_acct` 三个变量各触发一次。**只能在 log 阶段记一次** |
| 某把 Key 耗尽后一直在冷却 / 迟迟不恢复 | `resets` 填成滚动时长(`now+5h`)而非天锚定周期;MiniMax 视角的 5h 窗口末段只有 4h(见 `upstreams::cool_until_until`) |
| 账号负载数是真实值的 3 倍 | `bump_acct_load` 被放进了 `pick_account` —— `$llm_target`/`$llm_host`/`$llm_auth`/`$llm_acct` 四个变量各触发一次。**只能在 log 阶段记一次**(冷却 re-arm / 清冷却同理,见 1.0.44 探测闭环) |
| (冷却恢复)排查之后仍觉得不对 | ⚠️ 历史事故(勿回退):1.0.44 前按 `cool_until_until` 算重置边界,锚点两次算错(1.0.14 的 28800→北京16:00、1.0.24 的 0→北京08:00,纯 epoch 算术**不看容器 TZ**),造成「厂商 15:00 重置、网关锁到 18:00」。天锚定与 `resets` 路由语义已整体删除。详情 `docs/llm/MULTI_ACCOUNT_ROUTING.md` §五 |
| 同一下游 Key 每次换上游账号 | 粘性绑定 `ukb:` 没写(下行 Key 缺失时本就不写);或该 Key 哈希落点恰好在冷却账号上 |
| 流式退化成一次性返回 | `proxy_buffering off` 丢了 |
| 上游报 Host / 证书错 | `proxy_set_header Host $llm_host` 或 `proxy_ssl_server_name on` 丢了 |
@@ -304,7 +309,7 @@ location 与 80 端口 LLM server 是两份拷贝,改一处记得同步另一
| query 参数丢失 | 变量形式的 `proxy_pass` 不会自动追加 args,靠 `llm::upstream_uri` 拼好 |
**本机验证夹具**:`tests/llm/`,由 `bash tests/run.sh llm` 一并起假上游(18999)、LLM 网关(18090)
与**管理端口 18091**(跑 `/api/v1/*` 账号态断言)后跑断言。当前规模:网关 **102 条** + LLM **197 条**
与**管理端口 18091**(跑 `/api/v1/*` 账号态断言)后跑断言。当前规模:网关 **108 条** + LLM **262 条**
(`bash tests/run.sh all`,期望失败 0)。
`tests/llm/upstream.py` 会把收到的 `path` / `auth` / `host` / `body` 记到 `.run/llm/upstream.log`
@@ -624,7 +629,7 @@ curl -s -H "$T" -H 'Content-Type: application/json' -d '{}' $A/rollback
夹具**在仓库里**(`tests/`),不再放 `/tmp` —— 那儿的脚本一重启就没了,也没法 review。
```bash
bash tests/run.sh # 全部 299 项:域名网关 102 条 + LLM 代理 197 条
bash tests/run.sh # 全部 370 项:域名网关 108 条 + LLM 代理 262 条
bash tests/run.sh gateway # 只跑域名网关
bash tests/run.sh llm # 只跑 LLM 代理(自动起假上游)
```
@@ -636,8 +641,8 @@ bash tests/run.sh llm # 只跑 LLM 代理(自动起假上游)
| 路径 | 作用 |
| --- | --- |
| `tests/run.sh` | 统一入口:编译 + 渲染配置 + 起停 + 跑断言 |
| `tests/gateway/e2e.sh` | **102 条断言**:鉴权会话 / 账号(含展示名)/ 申请审核 / 免审 / 越权隔离 / Key 重置 / 上游多模型与用量 / **自动子域名(`i`+8位+`dm`)与点击复制** / 管理端与清理 |
| `tests/llm/e2e.sh` | **197 条断言**:鉴权 / 白名单 / 停用摘除 / **Key 替换** / 路径拼接(含版本段去重)/ SSE / 限流 / HTTPS / **模型发现** / **账号态用量** / **管理员用量与删账号清用量** /**base_url 端口自适应** / **统计落盘与重启恢复** |
| `tests/gateway/e2e.sh` | **108 条断言**:鉴权会话 / 账号(含展示名)/ 申请审核 / 免审 / 越权隔离 / Key 重置 / 上游多模型与用量 / **自动子域名(`i`+8位+`dm`)与点击复制** / 管理端与清理 |
| `tests/llm/e2e.sh` | **262 条断言**:鉴权 / 白名单 / 停用摘除 / **Key 替换** / 路径拼接(含版本段去重)/ SSE / 限流 / HTTPS / **模型发现** / **账号态用量** / **管理员用量与删账号清用量** /**base_url 端口自适应** / **统计落盘与重启恢复** / **探测恢复闭环**(标记→到期探测→回队;绑定流量不被劫持;退避翻倍) |
| `tests/.run/` | 运行目录(渲染出的配置、`data/`、`logs/`、cookie)——**已 gitignore,随时可删** |
**两条不许破的线**:
+64 -29
View File
@@ -1,6 +1,8 @@
# LLM 上游多账号路由与额度耗尽自动切换
> 适用版本:`ipass-1.0.14`(插件化后的 `plugin-llm`)。
> 适用版本:`ipass-1.0.14` 引入(插件化后的 `plugin-llm`);
> `ipass-1.0.44` 起冷却与恢复改为**指数退避 + 真实请求探测闭环**(§五),
> 天锚定边界计算已删除,`resets` 配置退出路由。
> 涉及文件:`rust/crates/plugin-llm/src/{models,upstreams,llm,usage_filter,handlers,api}.rs`、
> `conf/nginx.conf`(LLM server)、`tests/llm/{e2e.sh,upstream.py,fixtures/llm-upstreams.json}`。
@@ -14,7 +16,8 @@
1. **下游用户 Key → 上游账号 Key 粘性绑定**:同一下游 Key 尽量一直走同一个上游账号
(便于对账、便于厂商侧按账号看用量),但这是**尽力语义**——重启后重新绑定。
2. **额度耗尽自动切换**:某上游账号被厂商判额度耗尽,下次请求自动切到同厂商下一个可用账号。
3. **重置窗口感知**:额度按周期清零,冷却时长取「最近一个重置边界」,不盲目冷却整段固定时间。
3. **探测恢复**:冷却账号按指数退避到期后,放行**一个**真实请求当探测——
2xx 即自动回队、仍耗尽则退避翻倍。不猜厂商的重置窗口口径(见 §五 的历史教训)。
---
@@ -42,7 +45,7 @@
| `accounts` | 多账号数组。**取代旧版单 `auth` 字段**;`accounts` 为空时由顶层 `auth` 兼容合成单账号 |
| `accounts[].auth` | 完整的 `Authorization` 头值(如 `Bearer sk-xxx`)。**只填裸 key 也行**——读出时 `normalize_auth` 自动补 `Bearer `,避免上游回 1004(详情见 §10) |
| `accounts[].note` | 备注(如「华东主账号」),仅展示 |
| `accounts[].resets` | 该账号的**额度重置周期(秒)数组**,如 `[604800, 18000]` = 周 + 5 小时。全空=不自动切换 |
| `accounts[].resets` | **历史字段(1.0.44 起不参与路由)**:原为「重置周期(秒)数组」供天锚定边界计算;探测闭环上线后仅保留存储与展示,UI 已移除该输入,填错也不再影响任何行为 |
| `exhaust_status` | 命中即判「额度耗尽」的 HTTP 状态码(**上游级,所有账号共用**)。如 `[401,402,429,403]` |
| `exhaust_markers` | 响应体含任一子串即判耗尽(逐字节匹配,大小写敏感)。用于厂商「HTTP 200 + body 报错」的场景 |
@@ -53,13 +56,21 @@
## 三、路由逻辑(access 阶段 `pick_account`)
```
1. 查下游 Key 的粘性绑定 ukb:<downstream_key> → 已有账号下标
2. 无绑定 → FNV-1a(key) % 可用数 → 冷分散(不是固定 avail[0],也不是随机)
3. 绑定账号在冷却中 → 跳过,按下流 key 在剩余可用里重新分散
4. 全部冷却中 → 选「最早恢复」的账号(min cool_until)
5. 选定后写/刷新 ukb 粘性绑定(TTL = max(resets),兜底 7 天)
1. 绑定账号可用 → 直接用它。粘性与 prompt 缓存亲和高于一切,
绑定流量【永不】被劫持当探测(1.0.44)
2. 有冷却账号到期 → 本请求路由过去当探测(min next_probe;
哪怕池里有健康账号——无绑定/绑定失效流量承担,
代价被指数退避封顶)
3. 无到期探测、有可用账号 → FNV-1a(key) % 可用数 → 冷分散(绑定账号冷却/被删也走这支)
4. 全部冷却且无到期 → best-effort 选「最快要到期」的账号继续转发(不消耗探测窗口)
5. 选定后写/刷新 ukb 粘性绑定(TTL = 7 天常量)
```
⚠️ **`pick_account` 必须是纯决策**:`$llm_target/$llm_host/$llm_auth/$llm_acct` 四个变量
会把它求值多次(nginx 在 proxy_pass / Host / Authorization 各自求值时调用)。
副作用(re-arm、记账、清冷却)一律放 **log 阶段**——放 pick 里会让同一请求三次翻倍退避,
甚至 target 与 auth 落到不同账号(1.0.44 开发中真实踩过,e2e 探测组抓到)。
### 3.1 冷分配为什么用「键哈希」而不是「随机」或「固定第 0 个」
三者要同时满足两个看似矛盾的目标:
@@ -89,29 +100,47 @@
| 响应体标记 | `usage_filter` 在 body **流式**扫描 `exhaust_markers`,`take_exhausted` 透给 log | 厂商「HTTP 200 + body 报错」(如 MiniMax `status_code:1004`) |
任一命中 → 读 `$llm_acct`(本次 access 阶段选中的账号下标,确定一致)→
`mark_exhausted(slot, idx, resets)` 写冷却。
`mark_exhausted(slot, idx)` 写/推进冷却;
**2xx 且无耗尽信号 → `clear_cool(slot, idx)` 清冷却**(探测成功的判定就这半边,幂等)。
log 阶段同时是 re-arm 的唯一落点(见 §三 的纯决策约束):
`mark_exhausted` 对已在冷却的账号,若 `now >= next_probe`(= 探测到期后仍失败)
则退避翻倍关窗;未到期(best-effort 撞墙)则时间线不动。
---
## 五、冷却窗口(天锚定,关键)
## 五、冷却与恢复(探测闭环,1.0.44 起)
`cool_until_until(resets, now)` 的边界计算**锚定到「当天的 0 点」**,而非简单 `now + 窗口` 滚动:
不再猜厂商的重置时刻,而是**用真实流量验证恢复**:
```
day0 = RESET_DAY_OFFSET_SEC + floor((now - RESET_DAY_OFFSET_SEC) / 86400) * 86400
elapsed = now - day0
boundary = day0 + ceil(elapsed / 窗口) * 窗口,且封顶到 day0 + 86400(次日 0 点)
标记耗尽(log 阶段) → 写 uac:<slot>:<i> = "<backoff>:<next_probe>:<hard_cap>"
首轮退避 = ipass_probe_min(默认 60s);键 TTL = 硬顶 30min
冷却期(access 求值) → now < next_probe:完全跳过(除非全池冷却走 best-effort 转发)
到期(next_probe ≤ now)→ 下一个「无绑定/绑定失效」的真实请求被路由过去当探测
log 阶段合流 → 2xx 且无耗尽信号 → 删键,账号【立即回队】
命中耗尽(= 探测失败)→ re-arm:退避翻倍(60s→2m→4m→…→30m 封顶)
其它结果(400/5xx/断连)→ 窗口原样,下个无绑定请求再试
硬顶到期(30min 无验证)→ 键自然过期、无条件回队;若仍耗尽,真实流量会再标——自愈
```
**为什么必须天锚定**(MiniMax 实测口径):
MiniMax 的 5 小时额度从当天 0 点起每 5h 清一次,但 `24 = 5×4 + 4`——
最后一段窗口 `20:00–24:00` **只有 4 小时**,到点随「天」一起重置。
如果简单 `now + 5h` 滚动,21:00 耗尽会冷却到次日 01:00,与厂商口径对不上;
天锚定后封顶到当日 24:00(差 3h),与厂商行为一致。
**为什么放弃边界计算**(线上事故记录,别再走回头路):
旧实现 `cool_until_until(resets, now)` 把冷却锁到「下一个天锚定重置边界」,
边界由纯 epoch 算术算出、**不随容器 TZ 变化**,但两次改动都以为会:
- `RESET_DAY_OFFSET_SEC`(默认 `28800` = 北京时间)让 MiniMax 描述的开箱即用;其他时区厂商改成 `0` 即可。
- **多窗口取最早恢复**:`resets=[604800, 18000]` 时,周额度与 5h 额度哪个先恢复用哪个。
- `resets` 全空 → 兜底滚动冷却 `ACCT_COOLDOWN_DEFAULT = 4h`。
| 版本 | `RESET_DAY_OFFSET_SEC` | 作者以为锚 | 实际锚 | 后果 |
|---|---|---|---|---|
| 1.0.14 | `28800`(=UTC+8) | 北京 0 点 | 北京 16:00 | 边界整体错开 8h(没暴露:当时没人核对) |
| 1.0.24 | `0`("对齐 day_id") | 北京 0 点(以为 TZ 生效) | 北京 08:00 | **线上事故**:MiniMax 15:00 重置的额度被锁到 18:00,反向 13:00 又提前放闸吃 429 反复重标(单账号一天 156 次耗尽标记) |
1.0.44 把整条边界计算与 `resets` 路由语义一起删除。退避封顶 30min 意味着:
**厂商任意时刻恢复,最迟 ~30min 内被发现**;代价被严格封顶——
每账号每个退避周期最多牺牲 1 个无绑定请求(拿到的是上游真实错误,网关不发明状态码)。
- 首轮退避可调:`ipass_probe_min <秒>`(http 级指令,缺省 60;测试夹具压到 1s 保回归确定性)。
生产 `conf/nginx.conf` **刻意不写**,理由同 `ipass_stats_persist`:回滚旧镜像不受影响。
- 429(限速)与额度耗尽共用同一标记入口,但 60s 首轮退避让「限速误伤」一分钟内自愈,
不再有「一次 429 锁到下个边界」的放大。
---
@@ -121,8 +150,8 @@ MiniMax 的 5 小时额度从当天 0 点起每 5h 清一次,但 `24 = 5×4 +
|---|---|---|
| `up:<slot>` | `base \n <naccounts>` | 上游基址 + 账号数 |
| `upa:<slot>:<idx>` | `auth \n <resets csv>` | 单账号 auth + 重置周期 |
| `uac:<slot>:<idx>` | `exhausted_until` | 冷却截止(TTL = until,自然到期即视为恢复) |
| `ukb:<downstream_key>` | `acct_idx` | 粘性绑定(TTL = max resets) |
| `uac:<slot>:<idx>` | `<backoff>:<next_probe>:<hard_cap>` | 冷却时间线(TTL=硬顶;探测 2xx 删键即回队;见 §五。旧单段 `<until>` 值视作「立即可探测」,升级自然换代) |
| `ukb:<downstream_key>` | `acct_idx` | 粘性绑定(TTL = 7 天常量 `AFFINITY_TTL_DEFAULT`) |
| `upe:<slot>` | `status_csv \n markers_json` | 上游级耗尽检测配置 |
| `uda:<slot>:<idx>:<day>` | `requests:tin:tout`(`DayBucket`) | 账号级负载日桶(TTL 90 天) |
| `uex:<slot>:<idx>:<day>` | `requests`(=耗尽次数) | 账号级额度耗尽次数日桶(TTL 90 天) |
@@ -176,7 +205,9 @@ log : read_llm_acct(r) 取本次选中账号(NOCACHEABLE,与 access 同
## 八、管理台
- `www/assets/upstreams.js` 编辑卡支持**多账号行**:每行 auth(掩码回显)、note、resets(逗号分隔周期)。
- `www/assets/upstreams.js` 编辑卡支持**多账号行**:每行 auth(掩码回显)+ note
(1.0.44 起 resets 输入已移除——它不再参与路由,别再让用户猜厂商窗口口径)。
- `冷却中` 徽章带 tooltip:下次探测时刻与硬顶时刻(`view()` 新字段 `probe_next` / `cool_hard_cap`)。
- 列表「密钥 / 负载」列展示账号数、冷却/耗尽状态与**各 Key 今日负载 + 比例条 + 14 天迷你趋势**(见 §七)。
- 保存接口 `POST /api/admin/upstreams/save` 接受 `accounts`(JSON 数组);
auth 留空=保留原值(编辑时不用每次重填真 Key)。
@@ -185,10 +216,14 @@ log : read_llm_acct(r) 取本次选中账号(NOCACHEABLE,与 access 同
## 九、验证
- **本机回归**:`tests/llm/e2e.sh` 多账号组(粘性 + 耗尽自动切换 + 靶机真收 Key + 账号级负载分布),
全量 `bash tests/run.sh all` 期望**全绿**(写这段时是 279 条;条数随迭代增长,
当前见 `CLAUDE.md`「本机验证夹具」一节)。
假上游 `upstream.py` 支持 `UPSTREAM_FAIL_AUTH` 环境变量模拟「账号额度耗尽」。
- **本机回归**:`tests/llm/e2e.sh` 多账号组(粘性 + 耗尽自动切换 + 靶机真收 Key + 账号级负载分布)
与**探测恢复闭环组**(`ipass_probe_min 1` 压秒;剧本:首标冷却 → 到期探测 → 2xx 回队 →
绑定流量不被劫持 → 无绑定被劫持吃真实 401 → 退避翻倍后仍持续探测 → view 投影核对),
全量 `bash tests/run.sh all` 期望**全绿**(1.0.44 时点 370 条 = 网关 108 + LLM 262;
条数随迭代增长,当前见 `CLAUDE.md`「本机验证夹具」一节)。
- 假上游 `upstream.py` 三档故障注入:`UPSTREAM_FAIL_AUTH`(按 auth 子串永远耗尽)、
`UPSTREAM_FAIL_FIRST_AUTH`(**每个 auth 只失败第一次**——验证探测成功回队)、
`UPSTREAM_FAIL_ALWAYS_AUTH`(子串命中即永远失败——验证退避持续与代价封顶)。
- **真 MiniMax 双 Key 实测**:key1 稳定 200 + 粘性 `acct=0`;key1 失效 → 自动切 key2(`acct=1`,200)。
真 Key 仅存临时目录、测完即删,不入库。
- **前端渲染**:以真实 `admin.css` + 真实 `upstreams.js` 渲染路径做无头浏览器断言——
+6 -2
View File
@@ -530,8 +530,11 @@ LLM 代理读 `Authorization: Bearer`。重置 Key 会同时影响两个入口
}
```
- `resets` 是该账号的**额度重置周期(秒)**数组;冷却边界**锚定当天 0 点**(MiniMax 的
5 小时窗口在 20:00–24:00 只有 4 小时、随天重置,不能按 `now + 5h` 滚动)
- `resets` 为**历史字段**(1.0.44 起不再参与路由,管理台已移除该输入):冷却与恢复改为
**指数退避 + 真实请求探测闭环**——耗尽账号到期后放一个**无绑定**真实请求过去探测,
2xx 立即回队、仍耗尽退避翻倍(60s→2m→…→30min 封顶),硬顶到期无条件回队自愈。
全链路不再需要知道厂商的重置窗口口径(旧的天锚定边界计算因两次算错锚点被整体删除,
见 `docs/llm/MULTI_ACCOUNT_ROUTING.md` §五)
- `accounts[].auth` 是完整的 `Authorization` 头值(如 `Bearer sk-…`)。**只填裸 key 也行**——
读出时 `normalize_auth` 自动补 `Bearer `,免去用户照着 placeholder 填了裸 key 而回 1004
(详见 `docs/llm/MULTI_ACCOUNT_ROUTING.md` §10)
@@ -814,6 +817,7 @@ DRY_RUN=1 bash deploy/release.sh 1.0.3 # 只构建不推送
| `ipass-1.0.20` | **apix 透传模式 passthrough —— 通用内部 REST 出口**。vendor 模式假设单一供应商收口 + 网关拼体,OCR / 文生图 / TTS 这类多端点多 body 的内部服务接不进来。passthrough 走独立 `/apixp/` location(不施加 vendor 强约束,方法/请求体/Content-Type 原样透传,含 multipart),上游路径 = base + `/apixp/<slug>` 之后的 URI 尾部(含 query 由模块拼),Key 可空(内部服务免鉴权)。模型加 `mode` 字段(默认 vendor,旧数据零迁移);shm payload 4 字段 `base\nkey\nasset_id\nmode`;handler 校验「路径前缀 vs mode」一致(vendor slug 走 `/apixp/` → 404,反之亦然);探测按 mode 分流(vendor POST 预估 / passthrough GET 打上游根);鉴权仍走同一把 `sk_` + 配额 + 用量统计(slot 前缀 `api/<slug>`,passthrough 同样计)。真源 `docs/apix/PASSTHROUGH_MODE.md`。回归 327 条全绿(网关 102 + LLM 225,§11.6 新增 35 条)。commit `4533db8`,digest `ff34f7ef…`。 |
| `ipass-1.0.21` | **fix(apix): passthrough 新建可空 Key**。1.0.20 现场踩坑:`upsert` 统一要求「基址与密钥」,但 passthrough 设计是 Key 可空(handler 已放行),管理台提交 passthrough + 空 Key 直接 400。修:vendor 必须 base + key 都填;passthrough 仅 base 必填,key 可空。补 2 条断言防回归。commit `d05ebfb`,digest `f1087cf2…`。 |
| `ipass-1.0.22` | **feat(apix): `usage_hint` 字段 —— 让用户 AI 自己知道怎么调**。`/api/v1/me` 把账号能力目录下发给用户 AI 后,AI 必须能自己拼出调用语法(路径尾部 / Content-Type / 字段名 / Swagger)。`desc` 是中文给运维看的,`params` 只对 vendor 有意义,对 passthrough 是空数组——AI 拿到后不知怎么调。加 `usage_hint` 字段:管理员按 OpenAPI 风格填自由文本(截断 1KB),由 `/api/v1/me` 原样透传给用户 AI。**不进 shm**(热路径只查 base/key/asset_id/mode,进 shm 占带宽)。真源 `docs/apix/PASSTHROUGH_MODE.md` §3「`/api/v1/me` 用法」。commit `26a0f2f`,digest `8bb81353…`。 |
| `ipass-1.0.44` | **上游账号冷却改为「指数退避 + 真实请求探测」闭环**。旧口径按账号 `resets` 算天锚定重置边界,锚点算错过两次(1.0.14 / 1.0.24),造成「厂商 15:00 重置、网关锁到 18:00」——天锚定计算整体删除,`resets` 只存不路由。新口径:`uac:` = `<backoff>:<next_probe>:<hard_cap>`,到期放**一个无绑定**真实请求过去探测,2xx 即 `clear_cool` 回队、仍耗尽则退避翻倍(首轮 `ipass_probe_min`,默认 60s,30min 封顶无条件回队自愈)。`pick_account` 自此**必须保持纯决策**(四个 `$llm_*` 变量各求值一次),副作用只放 log 阶段。附带修复:探测窗口判定改**严格小于**(秒级时钟下 `>=` 会让刚标记的账号在下一请求就被当探测目标,1s 短退避时实际只等了 0.05s,冷却形同虚设)。真源 `docs/llm/MULTI_ACCOUNT_ROUTING.md`。回归 370 条全绿(网关 108 + LLM 262,新增「探测恢复闭环」剧本)。 |
---
+6 -1
View File
@@ -204,7 +204,12 @@ fn h_admin_upstream_test(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
return http::fail(r, HTTPStatus::NOT_FOUND, &format!("上游 {slot} 不存在"));
}
let uri = format!("/_upstream_test/{slot}/chat/completions");
// 与真实 OpenAI SDK 同形(必带 /v1)。1.0.42 曾改成裸 /chat/completions 绕智谱
// NPE——那是 join_target 剥冗余 /v1 落地(1.0.41)之前的坑位,且把**无路径 base**
// 的 openai/deepseek 探测打去了 /chat/completions(真端点 404,回归组11 抓到)。
// 1.0.43 用最小 dummy 体解决 NPE 后,这里恢复 /v1:base 带路径的厂商由
// join_target 剥除(llm.rs 单测钉死),不带路径的原样保留。
let uri = format!("/_upstream_test/{slot}/v1/chat/completions");
util::log_notice(&format!("[api] 测试 LLM 上游 {slot}"));
// ⚠️ nginx 的 internal_redirect 只**浅拷贝 ngx_str_t 结构体**(data 指针 + len),
+26 -28
View File
@@ -96,17 +96,22 @@ pub const KEY_UH_PREFIX: &[u8] = b"uh:";
pub const KEY_UPA_PREFIX: &[u8] = b"upa:";
/// 键前缀:上游账号「额度耗尽」冷却(**运行时状态**,非配置)。
/// 键 = `uac:<slot>:<idx>`,value = `<exhausted_until>`(绝对秒)。
/// 键 = `uac:<slot>:<idx>`,value = `<backoff>:<next_probe_at>:<hard_cap>`(绝对/相对秒)。
///
/// 写入时 `expires_at` 直接设为 `exhausted_until`——共享内存到期即视为不再冷却,
/// 「额度恢复」是天然发生的,无需额外清扫。log 阶段在检测到耗尽时写;
/// 热路径 `pick_account` 用 `get_live` 判定「该账号当前是否在冷却」。
/// 探测恢复闭环(1.0.44):冷却不再是「猜厂商重置点」,而是**指数退避 + 真实请求探测**——
/// * `backoff`:本轮退避长度(首标 = `ipass_probe_min`,每次探测后翻倍,封顶 `ACCT_COOL_HARD_CAP`);
/// * `next_probe_at`:到点后允许一个**无绑定/绑定失效**的真实请求把它当探测路由过去
/// (`pick_account` 选中即 re-arm,窗口不重复开);
/// * `hard_cap`:键 TTL。到期未验证成功 = 无条件回队,若仍耗尽会被真实流量再标——自愈。
///
/// 探测 2xx → log 阶段 `clear_cool` 删键回队。旧格式单段 `<until>` 值解析失败会被视作
/// 「立即到期可探测」,升级后 ~30 分钟内自然换代。
pub const KEY_UAC_PREFIX: &[u8] = b"uac:";
/// 键前缀:用户 key → 上游账号 粘性绑定。键 = `ukb:<downstream_key>`,
/// value = `<acct_idx>`(usize 字符串)。
///
/// 带 TTL(取该账号最长重置周期,或兜底 7 天),**尽力粘性**:重启后丢失、重新绑定,
/// 带 TTL(`AFFINITY_TTL_DEFAULT`,7 天),**尽力粘性**:重启后丢失、重新绑定,
/// 符合「尽可能同一用户 key 用同一上游 key」的语义。只有真正选了账号且拿到下行 key
/// 时才写;内部测试 location(无下行 key)不写,避免污染绑定表。
pub const KEY_UKB_PREFIX: &[u8] = b"ukb:";
@@ -123,33 +128,26 @@ pub const KEY_UPE_PREFIX: &[u8] = b"upe:";
/// 视为机器/链路问题、**不**算额度耗尽(否则单台抖动会把整池账号都冷却掉)。
pub const EXHAUST_STATUS_DEFAULT: &[i64] = &[402, 429, 403];
/// 账号冷却默认下限(秒):`resets` 全空时仍给一个兜底冷却,避免单账号被瞬间连续打死。
/// 实际冷却 = `min(resets)`,`resets` 空则用此值(4 小时,对齐 MiniMax「每 4 小时清零」口径)。
pub const ACCT_COOLDOWN_DEFAULT: i64 = 4 * 3600;
/// 首轮探测退避的默认值(秒)。可被 `ipass_probe_min <秒>` 指令覆盖(见 gateway 模块壳)。
///
/// 冷却生命周期 = 指数退避:首轮 `probe_min`,每次探测后翻倍,封顶 `ACCT_COOL_HARD_CAP`。
/// 60s 起步对「限速 429(≠额度耗尽)」足够友好;对真·额度耗尽也只是多牺牲几个探测请求。
pub const PROBE_MIN_DEFAULT: i64 = 60;
/// 退避翻倍与冷却硬顶(秒,30 分钟)。
///
/// 语义是**退避/存在期**,不是「恢复时刻」——恢复由探测闭环判定(2xx 即 `clear_cool`),
/// 硬顶到期只表示「放弃未验证的持续锁定,账号回队,若仍耗尽会被真实流量再标」(自愈)。
///
/// 旧口径是「天锚定重置边界」(`cool_until_until`):它把厂商窗口算错过两次(1.0.14 的
/// 28800、1.0.24 的 0——后者误以为容器 TZ 会影响纯 epoch 算术,边界错开 8h,
/// 造成「MiniMax 15:00 重置、网关锁到 18:00」的线上事故),1.0.44 起整个删除,
/// `resets` 配置不再参与路由。**不要再往回加边界计算。**
pub const ACCT_COOL_HARD_CAP: i64 = 30 * 60;
/// 粘性绑定 TTL 兜底(秒):账号 `resets` 全空时绑定的最长保留时长(7 天)。
pub const AFFINITY_TTL_DEFAULT: i64 = 7 * 86400;
/// 「额度重置窗口」锚定的天偏移(秒):决定「天 0 点」按哪个时区算。
///
/// MiniMax 等国内厂商的免费额度按**北京时间**清零,故默认 `28800`(= UTC+8);
/// 因此 5 小时窗口是「北京时间当天 0 点起每 5 小时」,一天 24h 不能被 5 整除,
/// 末段窗口(20:00–24:00)只有 4 小时、随「天」一起重置(见 `upstreams::cool_until_until`)。
///
/// 1.0.24:容器 Dockerfile 已设 `TZ=Asia/Shanghai`,`day_id`/`fmt_time` 直接走
/// 本地时间 0:00 切日,**不再需要手工补 8h**。此值改成 `0` 与 `util::day_id`
/// 对齐(之前 28800 是因为容器 TZ=UTC + day_id 用 localtime_r 错位到 UTC 日界,
/// 现在两处口径一致都用上海 0:00)。
///
/// 副作用:线上 `uda:` / `uex:` 等冷却类键是按 epoch 算的(不走 day_id),
/// 不受影响。**真正受影响的是 `ud:`/`udu:`/`uds:` 趋势日桶的 `tm_yday`**——
///
/// 同一天 UTC 算 vs 上海算差 ±1(跨 UTC 16:00 / Shanghai 0:00 边界时),
/// 因此发版后 14 天趋势按新 key 重算,旧 14 天逐步过期(滚动窗口允许丢)。
///
/// 其他时区的厂商改这里(如 UTC 设 `0`)。
pub const RESET_DAY_OFFSET_SEC: i64 = 0;
// ===========================================================================
// 趋势
// ===========================================================================
+13 -5
View File
@@ -231,22 +231,30 @@ impl HttpRequestHandler for LlmHealthHandler {
// 账号级负载:每次真实转发都记到选中的上游账号(负载分布 / 问题发现)。
// 只在这里记一次(read_llm_acct 触发一次 pick_account),绝不放在
// pick_account 里——否则 $llm_target/$llm_auth/$llm_acct 三变量各触发一次
// 会把同一请求记三遍。
// pick_account 里——否则 $llm_target/$llm_host/$llm_auth/$llm_acct
// 四个变量各触发一次,会把同一请求记好几遍。
if let Some(idx) = read_llm_acct(r) {
upstreams::bump_acct_load(&slot, idx, now);
// 额度耗尽检测:状态码命中 或 响应体命中标记 → 标记该账号冷却 + 耗尽计数 +1。
// 状态码来自 `$upstream_status`,标记来自 body filter 的 `take_exhausted`
// (流式也能扫到)。
//
// 探测闭环(1.0.44)的两半边都在这里合流(log 阶段每请求只跑一次,
// 这是副作用只能放这的原因——pick 会被四个变量求值多次):
// * 耗尽信号(状态码或 body marker)→ mark_exhausted:新账号开冷却;
// 冷却中且窗口已到期(= 探测失败)→ re-arm 翻倍关窗;未到期
// (best-effort 撞墙)→ 时间线不动;
// * 2xx 且无耗尽信号 → clear_cool:冷却中的账号被探测/转发验证恢复,
// 立即清键回队(健康账号无键,remove 返回 false、静默)。
let (status_list, _) = upstreams::read_upe(&slot);
let status_exhausted = status_list.iter().any(|&s| s == code);
let body_exhausted = usage_filter::take_exhausted(r);
if status_exhausted || body_exhausted {
if let Some((_, resets)) = upstreams::read_upa(&slot, idx) {
upstreams::mark_exhausted(&slot, idx, &resets, now);
}
upstreams::mark_exhausted(&slot, idx, now);
upstreams::bump_acct_exhaust(&slot, idx, now);
} else if (200..300).contains(&code) {
upstreams::clear_cool(&slot, idx);
}
}
}
+1 -1
View File
@@ -385,7 +385,7 @@ pub extern "C" fn var_get(
let anthropic = is_anthropic(r);
let key = auth::downstream_key(r);
let now = util::now();
// 选账号:粘性绑定 + 跳过冷却中账号,返回 (下标, auth, base)
// 选账号:粘性优先 → 到期探测 → FNV 冷分散 → 全冷却 best-effort(见 pick_account)
let (idx, auth, base) =
upstreams::pick_account(&slot, anthropic, key.as_deref(), now)?;
let target = join_target(&base, &upstream_uri(r, anthropic), anthropic);
+4 -4
View File
@@ -23,10 +23,10 @@ pub struct UpstreamAccount {
/// 备注(区分多账号用,如 `minimax-周额度` / `minimax-4h额度`)
#[serde(default)]
pub note: String,
/// 该账号额度重置周期(秒)。如 MiniMax = `[604800, 14400]`(每周 + 每 4 小时)。
///
/// 空 = 不配置重置窗口:额度耗尽后给一个兜底冷却(见 `config::ACCT_COOLDOWN_DEFAULT`),
/// 仍参与轮换,避免单账号被瞬间连续打死。
/// **历史字段(1.0.44 起不参与路由)**:原为「额度重置周期(秒)」,供
/// `cool_until_until` 天锚定边界计算——该计算两次算错锚点(见 config.rs 旧注释),
/// 已由「指数退避 + 真实请求探测」闭环取代。字段仍随 JSON 读写(存量兼容、
/// view 回显),但填什么都不再影响冷却与路由;管理台表单已移除该输入。
#[serde(default)]
pub resets: Vec<i64>,
}
+228 -103
View File
@@ -13,12 +13,14 @@
//!
//! `data/llm-upstreams.json` 含上游真实 API Key,**敏感级别等同 `users.json`**。
use core::sync::atomic::{AtomicI64, Ordering};
use serde_json::{Value, json};
use crate::config::{
ACCT_COOLDOWN_DEFAULT, ACCT_TREND_DAYS, AFFINITY_TTL_DEFAULT, EXHAUST_STATUS_DEFAULT,
ACCT_COOL_HARD_CAP, ACCT_TREND_DAYS, AFFINITY_TTL_DEFAULT, EXHAUST_STATUS_DEFAULT,
KEY_UAC_PREFIX, KEY_UDAY_ACCT_PREFIX, KEY_UEX_PREFIX, KEY_UH_PREFIX, KEY_UKB_PREFIX,
KEY_UPA_PREFIX, KEY_UPE_PREFIX, KEY_UP_PREFIX, MODEL_NAME_MAX_LEN, RESET_DAY_OFFSET_SEC,
KEY_UPA_PREFIX, KEY_UPE_PREFIX, KEY_UP_PREFIX, MODEL_NAME_MAX_LEN, PROBE_MIN_DEFAULT,
TREND_DAYS_MAX, TREND_KEEP_SECS, UPSTREAM_BASE_MAX_LEN, UPSTREAM_MODELS_MAX,
UPSTREAM_SLOT_MAX_LEN,
};
@@ -352,74 +354,144 @@ pub fn read_upe(slot: &str) -> (Vec<i64>, Vec<String>) {
(status, markers)
}
/// 某账号当前是否在「额度耗尽」冷却中(冷却键带 TTL,到期自动不再冷却)。
pub fn is_cooled(slot: &str, i: usize, now: i64) -> bool {
state::get_live(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes(), now).is_some()
// ===========================================================================
// 额度耗尽冷却:指数退避 + 真实请求探测(1.0.44 探测闭环)
//
// 旧口径(已删除,勿回加):按账号 `resets` 配置算「下一个天锚定重置边界」再锁到点。
// 该边界计算 1.0.14 / 1.0.24 两次锚点算错(纯 epoch 算术不看容器 TZ),
// 造成「MiniMax 15:00 重置、网关锁到 18:00」的线上事故。新口径不猜厂商窗口:
// 冷却键带退避时间表,到期后**一个**真实请求被路由过去当探测,
// 2xx 即清键回队、失败则退避翻倍——`resets` 配置自此只存储、不参与路由。
// ===========================================================================
/// `ipass_probe_min` 指令的运行期值(秒)。配置阶段由 gateway 写入,worker 只读。
static PROBE_MIN_SEC: AtomicI64 = AtomicI64::new(PROBE_MIN_DEFAULT);
/// 供 gateway 模块壳在配置阶段回填首轮退避(非法值忽略,保持默认)。
pub fn set_probe_min(secs: i64) {
if secs > 0 {
PROBE_MIN_SEC.store(secs, Ordering::Relaxed);
}
}
/// 标记某账号额度耗尽,进入冷却直到「下一个重置边界」。
fn probe_min() -> i64 {
PROBE_MIN_SEC.load(Ordering::Relaxed).max(1)
}
/// 冷却键的内存表示:value = `<backoff>:<next_probe_at>:<hard_cap>`。
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Cool {
/// 本轮退避长度(秒)
backoff: i64,
/// 到点后允许一个真实请求把它当探测路由过去
next_probe: i64,
/// 键 TTL;到期 = 放弃未验证的持续锁定,账号无条件回队(自愈)
hard_cap: i64,
}
/// 解析 `uac` payload。旧格式单段 `<until>` 或损坏值 → 视作「立即可探测」,
/// 升级过渡期最多多牺牲一次探测即被新格式覆盖,不需要迁移脚本。
fn parse_cool(payload: &str, exp: i64) -> Cool {
let mut it = payload.split(':');
match (
it.next().and_then(|s| s.trim().parse::<i64>().ok()),
it.next().and_then(|s| s.trim().parse::<i64>().ok()),
it.next().and_then(|s| s.trim().parse::<i64>().ok()),
) {
(Some(b), Some(np), Some(hc)) if b > 0 => Cool {
backoff: b,
next_probe: np,
hard_cap: hc,
},
_ => Cool {
backoff: probe_min(),
next_probe: 0,
hard_cap: exp,
},
}
}
/// 退避推进:翻倍封顶硬顶(纯算术,单测钉死)。
fn next_backoff(backoff: i64) -> i64 {
backoff.saturating_mul(2).min(ACCT_COOL_HARD_CAP)
}
/// 读某账号冷却状态;不在冷却(无键/过期/损坏到无法定 TTL)返回 None。
fn read_cool(slot: &str, i: usize, now: i64) -> Option<Cool> {
let (payload, exp) = state::get(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes())?;
if exp <= 0 || exp <= now {
return None;
}
Some(parse_cool(&payload, exp))
}
/// 某账号当前是否在「额度耗尽」冷却中(含探测窗口——是否放行由 `pick_account` 细分)。
pub fn is_cooled(slot: &str, i: usize, now: i64) -> bool {
read_cool(slot, i, now).is_some()
}
/// 标记某账号额度耗尽,进入冷却(首轮回避 = `probe_min`,硬顶 = `ACCT_COOL_HARD_CAP`)。
///
/// 重置窗口**锚定到「天」边界**(不是从 `now` 起的滚动窗口):MiniMax 这类厂商的
/// 5 小时额度是「从当天 0 点起每 5 小时」清零,而一天 24 小时不能被 5 整除
/// (24 = 5×4 + 4),所以最后一段窗口(20:00–24:00)只有 4 小时,到点随「天」一起重置。
/// 因此冷却边界 = 当天 0 点 + ceil(已过秒数 / 窗口) × 窗口,且**不超过「下一天 0 点」**
/// (否则会跨到次日 01:00 之类,与厂商口径不符)。多窗口取最早边界(先到先恢复)。
/// `resets` 全空 → 兜底 `ACCT_COOLDOWN_DEFAULT`(滚动 4 小时,非天锚定)。
///
/// 写入 `expires_at = until`,共享内存自然到期即视为恢复——无需额外清扫。
pub fn mark_exhausted(slot: &str, i: usize, resets: &[i64], now: i64) {
let until = if resets.is_empty() {
now + ACCT_COOLDOWN_DEFAULT
} else {
cool_until_until(resets, now)
/// 冷却中的账号再被标记 = **探测窗口已到期还失败**,做 re-arm(退避翻倍、关窗);
/// 未到期(best-effort 撞墙)则时间线原样——没消耗探测就不推进窗口。
/// 判定放在这里(而非 pick)是因为 `$llm_target/$llm_host/$llm_auth/$llm_acct`
/// 会让 pick 每请求被求值多次,任何副作用都必须由只跑一次的 log 阶段承担。
pub fn mark_exhausted(slot: &str, i: usize, now: i64) {
if let Some(c) = read_cool(slot, i, now) {
// 严格大于:与 `pick_account` 的探测判定同一口径(见那里的时间粒度说明)。
if now > c.next_probe {
re_arm_cool(slot, i, now, c);
}
return;
}
let backoff = probe_min();
let cool = Cool {
backoff,
next_probe: now + backoff,
hard_cap: now + ACCT_COOL_HARD_CAP,
};
if !state::put(
KEY_UAC_PREFIX,
format!("{slot}:{i}").as_bytes(),
until.to_string().as_bytes(),
until,
format!("{}:{}:{}", cool.backoff, cool.next_probe, cool.hard_cap).as_bytes(),
cool.hard_cap,
) {
util::log_err(&format!(
"[upstreams] 账号冷却写共享内存失败 slot={slot}#{i} —— 该账号不会被自动跳过"
));
} else {
util::log_warn(&format!(
"[upstreams] slot={slot} 账号#{i} 额度耗尽,冷却至 {}(约 {}s 后)",
util::fmt_time(until),
until.saturating_sub(now)
"[upstreams] slot={slot} 账号#{i} 额度耗尽,进入冷却:{}s 后由真实请求探测(硬顶 {})",
backoff,
util::fmt_time(cool.hard_cap)
));
}
}
/// 计算「额度耗尽后冷却到哪个时刻」(天锚定,末窗封顶到次日 0 点)。
///
/// 见 `mark_exhausted` 注释:窗口从「天 0 点」(按 `RESET_DAY_OFFSET_SEC` 偏移,
/// 默认北京时间)起算,一天内的末段窗口因不能被整除而随「天」重置。
fn cool_until_until(resets: &[i64], now: i64) -> i64 {
const DAY: i64 = 86400;
let off = RESET_DAY_OFFSET_SEC;
// 最近一个「天 0 点」:t ≤ now 且 (t - off) 是 DAY 的整数倍
let k = (now - off).div_euclid(DAY);
let day0 = off + k * DAY;
let elapsed = now - day0;
let mut best = i64::MAX;
for &w in resets {
if w <= 0 {
continue;
}
// 下一个整周期边界;末段窗口封顶到「下一天 0 点」(与厂商天重置对齐)
let boundary = (day0 + (elapsed / w + 1) * w).min(day0 + DAY);
best = best.min(boundary);
/// 探测失败后的 re-arm(log 阶段单点调用):退避翻倍、`next_probe` 推后关窗。
/// 跨 worker 同时各探测一次最多多牺牲 1 个请求,与 `usage::bump_window` 同级近似,
/// 不为此把写锁放进热路径。
fn re_arm_cool(slot: &str, i: usize, now: i64, c: Cool) {
let nb = next_backoff(c.backoff);
if !state::put(
KEY_UAC_PREFIX,
format!("{slot}:{i}").as_bytes(),
format!("{}:{}:{}", nb, now + nb, c.hard_cap).as_bytes(),
c.hard_cap,
) {
util::log_err(&format!(
"[upstreams] 冷却 re-arm 写共享内存失败 slot={slot}#{i} —— 探测窗口可能重复开启"
));
}
best
}
/// 粘性绑定 TTL:取该账号最长重置周期,空则兜底 7 天。
fn affinity_ttl(resets: &[i64]) -> i64 {
if resets.is_empty() {
AFFINITY_TTL_DEFAULT
} else {
*resets.iter().max().unwrap()
/// 探测/转发成功(log 阶段 2xx 且无耗尽信号)→ 清除冷却,账号立即回队。
/// 键不存在时 `remove` 返回 false、静默——健康账号的每个 2xx 都会走到这里。
pub fn clear_cool(slot: &str, i: usize) {
if state::remove(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes()) {
util::log_notice(&format!(
"[upstreams] slot={slot} 账号#{i} 探测恢复,冷却解除(自动回队)"
));
}
}
@@ -455,21 +527,26 @@ fn cold_index(key: Option<&str>, n: usize) -> usize {
(r % n as u64) as usize
}
/// 选上游账号:实现「用户 key → 上游账号」粘性 + 跳过冷却中账号 + 全冷却 best-effort。
/// 选上游账号:粘性优先 + 探测闭环(指数退避、真实请求探测)+ 全冷却 best-effort。
///
/// 返回 `(选中账号下标, 该账号 auth, 上游 base)`。选不到返回 `None`(上游不可用)。
/// 返回 `(选中账号下标, 该账号 auth, 上游 base)`。选不到返回 `None`(上游无账号)。
///
/// 决策顺序:
/// 1. 枚举该 slot 全部账号,区分「可用」(未冷却)与「冷却中」(带 `exhausted_until`);
/// 2. 有可用账号:
/// * 已粘性绑定 → 用绑定的那个(若该账号已不可用则按下流 key 重新分散);
/// * 未绑定 → 按下流 key 的 FNV-1a 哈希**分散**选一个(`cold_index`):
/// 把不同用户铺到不同上游账号,避免全部压在 `account#0` 触发 MiniMax 这类厂商的
/// 「agent 并发上限」;同时同一 key 哈希固定 → 永远落同一账号(粘性前提),
/// 于是同一用户的请求始终由同一上游账号处理,**prompt / token 缓存得以命中**;
/// 3. 全部冷却 → 挑 `exhausted_until` 最早的一个 best-effort 继续转发
/// (让上游回真实错误,而不是网关发明一个 5xx;冷却到期后会自动恢复);
/// 4. 真正选了账号且拿到下行 key 时,写 `ukb:` 粘性绑定(变化才写,避免每请求写)。
/// 探测候选 = 冷却账号中**已完整经过一个退避**(`next_probe < now`,严格)者里最早到期的一个。
///
/// 1. **绑定账号可用 → 直接用它**:粘性与 prompt 缓存亲和高于探测,绑定流量
/// **永不被劫持当探测**(否则长会话隔一会儿就被拉去烧一个请求、缓存前缀也白丢);
/// 2. 有探测候选 → 本请求路由过去——哪怕池里有健康账号。这是唯一的恢复通道,
/// 必须持续验证;代价最坏 = 每个退避周期牺牲 1 个无绑定真实请求(拿到的是上游
/// 真实错误,非网关发明)。**本函数必须保持纯决策**:四个 `$llm_*` 变量会把
/// 它求值多次,re-arm 写在 `mark_exhausted`(log 阶段单点)——放这里会三次
/// 翻倍退避、还会让同一请求的 target/auth 落不同账号(1.0.44 开发中踩过);
/// 3. 无到期探测、有可用账号 → FNV-1a 冷分散(绑定目标已被删/冷却也走这支,
/// 与未绑定一样重新分散,不退化成永远 acct0);
/// 4. 全冷却且无到期 → best-effort 挑 `next_probe` 最近的一个转发
/// (让上游回真实错误;**不 re-arm**——不是探测就不该推进别人的窗口)。
///
/// 真正选了账号且拿到下行 key 时,写 `ukb:` 粘性绑定(变化才写,避免每请求写;
/// TTL = `AFFINITY_TTL_DEFAULT`,探测成功后绑定自然稳定在恢复的账号上)。
///
/// ⚠️ 只读 `up:` / `upa:` / `uac:` / `ukb:`,**不回源读文件**;未命中即视为不可用。
pub fn pick_account(
@@ -483,47 +560,47 @@ pub fn pick_account(
return None;
}
let mut avail: Vec<(usize, String, Vec<i64>)> = Vec::new();
let mut cooled: Vec<(usize, String, i64, Vec<i64>)> = Vec::new();
let mut avail: Vec<(usize, String)> = Vec::new();
let mut cooled: Vec<(usize, String, Cool)> = Vec::new();
for i in 0..n {
let (auth, resets) = read_upa(slot, i)?;
if is_cooled(slot, i, now) {
let eu = state::get(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes())
.and_then(|(v, _)| v.trim().parse::<i64>().ok())
.unwrap_or(0);
cooled.push((i, auth, eu, resets));
} else {
avail.push((i, auth, resets));
// resets 只存不路由(探测闭环接管恢复判定,配置错不再伤路由)
let (auth, _resets) = read_upa(slot, i)?;
match read_cool(slot, i, now) {
Some(c) => cooled.push((i, auth, c)),
None => avail.push((i, auth)),
}
}
let chosen: (usize, String, Vec<i64>) = if !avail.is_empty() {
// 粘性绑定优先
let bound = key.and_then(|k| {
state::get(KEY_UKB_PREFIX, k.as_bytes())
.and_then(|(v, _)| v.trim().parse::<usize>().ok())
});
if let Some(b) = bound {
if let Some(a) = avail.iter().find(|(i, _, _)| *i == b) {
(a.0, a.1.clone(), a.2.clone())
} else {
// 绑定的账号已被删/减:按下流 key 重新分散(不退化成永远 acct0)
let a = &avail[cold_index(key, avail.len())];
(a.0, a.1.clone(), a.2.clone())
}
} else {
// 无绑定:按下流 key 哈希分散选一个(均匀铺开 + 粘性前提)
let a = &avail[cold_index(key, avail.len())];
(a.0, a.1.clone(), a.2.clone())
}
let bound = key.and_then(|k| {
state::get(KEY_UKB_PREFIX, k.as_bytes())
.and_then(|(v, _)| v.trim().parse::<usize>().ok())
});
let bound_ok = bound
.and_then(|b| avail.iter().find(|(i, _)| *i == b))
.map(|(i, a)| (*i, a.clone()));
let chosen: (usize, String) = if let Some(a) = bound_ok {
a
} else if let Some((i, a, _)) = cooled
.iter()
// ⚠️ 严格小于(不是 `<=`):时间源是**秒**,若 `now == next_probe` 就放行,
// 实际等待可能只有 0.05s(标记于 45.95s → next_probe=46 → 46.05s 即"到期"),
// 短退避下等于「刚冷却完就被立刻探测」,冷却形同虚设(1.0.44 回归暴露)。
// 严格小于保证**实际等待 ≥ 一个完整退避**(∈ (backoff, backoff+1] 秒)。
// `mark_exhausted` 的 re-arm 判定必须用同一口径,否则会 re-arm 一个没被探测的窗口。
.filter(|(_, _, c)| c.next_probe < now)
.min_by_key(|(_, _, c)| c.next_probe)
{
// 无绑定/绑定失效 → 本请求当探测。绑定目标恰好冷却到期时也会被选中:
// 探测成功用户直接回到原账号,是最顺路的恢复。
(*i, a.clone())
} else if !avail.is_empty() {
// 未绑定:按哈希分散(均匀铺开 + 粘性前提);绑定失效:同理重新分散
let a = &avail[cold_index(key, avail.len())];
(a.0, a.1.clone())
} else if !cooled.is_empty() {
// 全冷却:挑最快恢复的一个
let c = cooled
.into_iter()
.min_by_key(|(_, _, eu, _)| *eu)
.map(|(i, auth, _, resets)| (i, auth, resets))
.unwrap();
(c.0, c.1, c.2)
// 全冷却、无到期:best-effort 挑最快要探测的那个(不 re-arm)
cooled.iter().min_by_key(|(_, _, c)| c.next_probe).map(|(i, a, _)| (*i, a.clone())).unwrap()
} else {
return None;
};
@@ -531,13 +608,12 @@ pub fn pick_account(
// 写粘性绑定(仅当下行 key 存在且绑定变化)
if let Some(k) = key {
let cur = state::get(KEY_UKB_PREFIX, k.as_bytes()).map(|(v, _)| v.trim().to_owned());
if cur.as_deref() != Some(&chosen.0.to_string()) {
let ttl = affinity_ttl(&chosen.2);
if cur.as_deref() != Some(chosen.0.to_string().as_str()) {
state::put(
KEY_UKB_PREFIX,
k.as_bytes(),
chosen.0.to_string().as_bytes(),
now + ttl,
now + AFFINITY_TTL_DEFAULT,
);
}
}
@@ -919,6 +995,8 @@ pub fn view(slot: &str, up: &Upstream, port: &str) -> Value {
.enumerate()
.map(|(i, a)| {
let (lr, lin, lout, lex) = read_acct_load(slot, i, now);
// 探测闭环时间线:UI 徽章 tooltip 展示「HH:MM 探测 / HH:MM 硬顶」
let cool = read_cool(slot, i, now);
json!({
"idx": i,
"auth_set": !a.auth.is_empty(),
@@ -926,7 +1004,9 @@ pub fn view(slot: &str, up: &Upstream, port: &str) -> Value {
"note": a.note,
"resets": a.resets,
"resets_text": resets_text(&a.resets),
"cooled": is_cooled(slot, i, now),
"cooled": cool.is_some(),
"probe_next": cool.map(|c| c.next_probe),
"cool_hard_cap": cool.map(|c| c.hard_cap),
"load": {
"requests": lr,
"tokens_in": lin,
@@ -1032,3 +1112,48 @@ pub fn health(slot: &str) -> Option<(bool, i64, i64)> {
.unwrap_or(0);
Some((ok, code, ts))
}
// ===========================================================================
// 单元测试(纯算术,不依赖 nginx 运行时)
// ===========================================================================
#[cfg(test)]
mod tests {
use super::{Cool, next_backoff, parse_cool};
use crate::config::ACCT_COOL_HARD_CAP;
#[test]
fn parse_cool_roundtrip() {
let c = parse_cool("60:1000:1800", 1800);
assert_eq!(
c,
Cool {
backoff: 60,
next_probe: 1000,
hard_cap: 1800
}
);
}
#[test]
fn parse_cool_legacy_single_value_is_probe_due_now() {
// 1.0.44 前的旧格式 `<until>`(无冒号)→ 视作「立即可探测」、硬顶沿用键 TTL,
// 升级过渡期由下一次 pick 自动 re-arm 成新格式。
let c = parse_cool("1789599600", 1789599600);
assert_eq!(c.next_probe, 0);
assert_eq!(c.hard_cap, 1789599600);
// 垃圾值同理:宁可多探一次,不可把账号永久锁死
let g = parse_cool("not-a-number", 99);
assert_eq!(g.next_probe, 0);
assert_eq!(g.hard_cap, 99);
}
#[test]
fn backoff_doubles_capped_at_hard_cap() {
assert_eq!(next_backoff(60), 120);
assert_eq!(next_backoff(120), 240);
assert_eq!(next_backoff(ACCT_COOL_HARD_CAP / 2), ACCT_COOL_HARD_CAP);
// 饱和乘:病态大值不许回绕成小退避
assert_eq!(next_backoff(i64::MAX), ACCT_COOL_HARD_CAP);
}
}
+40 -1
View File
@@ -373,7 +373,7 @@ impl HttpModule for Module {
}
}
static mut NGX_HTTP_IPASS_COMMANDS: [ngx_command_t; 9] = [
static mut NGX_HTTP_IPASS_COMMANDS: [ngx_command_t; 10] = [
ngx_command_t {
name: ngx_string!("ipass_state"),
type_: (NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE2) as ngx_uint_t,
@@ -406,6 +406,14 @@ static mut NGX_HTTP_IPASS_COMMANDS: [ngx_command_t; 9] = [
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t {
name: ngx_string!("ipass_probe_min"),
type_: (NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE1) as ngx_uint_t,
set: Some(set_probe_min),
conf: NGX_HTTP_MAIN_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t {
name: ngx_string!("ipass_proxy"),
type_: (NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1) as ngx_uint_t,
@@ -710,6 +718,37 @@ extern "C" fn set_stats_persist(
NGX_CONF_OK
}
/// `ipass_probe_min <秒>`:额度耗尽探测闭环的**首轮**退避(默认 60 秒)。
///
/// 冷却账号第一次可被真实请求探测的等待时间;之后每次探测失败翻倍、封顶 30 分钟
/// (见 `upstreams` 模块「冷却」段与 config::ACCT_COOL_HARD_CAP)。
/// 生产 `conf/nginx.conf` **刻意不写**这条指令——与 `ipass_stats_persist` 同理,
/// 回滚到不含该指令的旧镜像时不会 unknown directive 起不来;测试夹具用 `1` 压秒。
extern "C" fn set_probe_min(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
_conf: *mut c_void,
) -> *mut c_char {
// SAFETY: 配置回调必然拿到有效的 cf
let cf_ref = unsafe { cf.as_mut().unwrap() };
let args: &mut [ngx_str_t] = unsafe { (*cf_ref.args).as_slice_mut() };
let Ok(raw) = core::str::from_utf8(args[1].as_bytes()) else {
ngx_conf_log_error!(NGX_LOG_EMERG, cf_ref, "ipass_probe_min: 不是合法 UTF-8");
return NGX_CONF_ERROR;
};
let Ok(secs) = raw.trim().parse::<i64>() else {
ngx_conf_log_error!(NGX_LOG_EMERG, cf_ref, "ipass_probe_min: 需要正整数秒");
return NGX_CONF_ERROR;
};
if secs <= 0 {
ngx_conf_log_error!(NGX_LOG_EMERG, cf_ref, "ipass_probe_min: 秒数必须为正");
return NGX_CONF_ERROR;
}
plugin_llm::upstreams::set_probe_min(secs);
NGX_CONF_OK
}
/// 供测试与诊断使用:`NgxStr` 类型在模块里被多处引用,确保编译期链接到正确的符号
#[allow(dead_code)]
fn _type_witness(_: &NgxStr, _: &NgxString<SlabPool>) {}
+5 -3
View File
@@ -198,7 +198,9 @@ ck " 上游列表回显模型名" yes \
"$(curl -s -b "$JAR" $ADMIN/api/admin/upstreams | grep -q deepseek-reasoner && echo yes || echo no)"
# base_url 必须带「调用方正在用的端口」:88 部署下裸域名会指向别处(实测出口设备抢答),
# 而放在 443 反代后面时又不该带端口 —— 所以它只能跟随请求 Host,不能写死。
ck "★base_url 带调用方端口(不是裸域名)" "https://lm.mayishangshu.cn:${ADMIN##*:}/deepseek/v1" "$(echo "$UP" | jqv data.base_url)"
# 1.0.40 起出口是**纯 slot**(不带 /v1、不带上游 base 路径):厂商版本段存在 base 里、
# join_target 拼接时归一(客户端带不带 /v1 都对)。旧断言的 `/deepseek/v1` 是 1.0.37 口径。
ck "★base_url 带调用方端口(不是裸域名)" "https://lm.mayishangshu.cn:${ADMIN##*:}/deepseek" "$(echo "$UP" | jqv data.base_url)"
# 与 auth/note 同款语义:省略 models = 保持原清单
BODY=$(jbody slot deepseek base https://api.deepseek.com/v1)
@@ -221,8 +223,8 @@ ck "无 Key 查可用模型 → 401" 401 "$(code $ADMIN/api/v1/models)"
ck "alice 查可用模型 → 200" 200 "$(code -H "X-API-Key: $ALICE_KEY" $ADMIN/api/v1/models)"
ck " 含 deepseek-chat" yes \
"$(curl -s -H "X-API-Key: $ALICE_KEY" $ADMIN/api/v1/models | grep -q deepseek-chat && echo yes || echo no)"
ck " 带 OpenAI 口径的 base_url" yes \
"$(curl -s -H "X-API-Key: $ALICE_KEY" $ADMIN/api/v1/models | grep -Eq 'lm\.mayishangshu\.cn(:[0-9]+)?/deepseek/v1' && echo yes || echo no)"
ck " 带 base_url(lm 域名 + 端口 + 纯 slot 出口,1.0.40 口径)" yes \
"$(curl -s -H "X-API-Key: $ALICE_KEY" $ADMIN/api/v1/models | grep -Eq '"base_url":"https://lm\.mayishangshu\.cn(:[0-9]+)?/deepseek"' && echo yes || echo no)"
ck "无 Key 查用量 → 401" 401 "$(code $ADMIN/api/v1/usage)"
ck "alice 查用量 → 200" 200 "$(code -H "X-API-Key: $ALICE_KEY" $ADMIN/api/v1/usage)"
ck " 没调用过 → 累计 0" 0 "$(curl -s -H "X-API-Key: $ALICE_KEY" $ADMIN/api/v1/usage | jqv data.total)"
+61
View File
@@ -179,6 +179,11 @@ echo
echo "【6】★ 限流与每日配额(carol rpm=2、dave daily=2,见 fixtures/users.json)"
CAROL_KEY=sk_carol_cccccccccccccccccccccccccccccccccccccccccccccc
DAVE_KEY=sk_dave_dddddddddddddddddddddddddddddddddddddddddddddddd
# 探测闭环组专用(合成数据)。probe1 的 FNV64(key)%2=0 → 冷分配必落 probe 槽 #0;
# probe2/3 只在探测分支(先于哈希)被使用,落点不依赖哈希。
PROBE1_KEY=sk_probe_one_00000000000000000000000000000000
PROBE2_KEY=sk_probe_two_00000000000000000000000000000001
PROBE3_KEY=sk_probe_three_0000000000000000000000000000000
cpost() { code -H "Authorization: Bearer $1" -X POST "$GW/other/v1/chat/completions" -H 'Content-Type: application/json' -d "$BODY"; }
ck "carol 第 1 发 → 200" 200 "$(cpost "$CAROL_KEY")"
ck "carol 第 2 发 → 200" 200 "$(cpost "$CAROL_KEY")"
@@ -778,6 +783,62 @@ ck "multi 冷却期间保持 acct=1(不回退坏账号)" 1 "$(echo "$M3" | a
M4=$(mh multi multi-model)
ck "multi 切换后下游 Key 真换成 acct-good" "Bearer acct-good" "$(up_hdr Authorization)"
echo "【探测恢复闭环】退避冷却 + 真实请求探测 + 绑定流量保护"
# fixture `probe`:#0=probe-flip(每账号只失败第一次)、#1=probe-dead(永远耗尽)。
# conf 里 ipass_probe_min 1 → 首轮退避 1s,翻倍 2s;冷却硬顶 30min。
# 剧本逐拍(时间锚 = 各次标记后的 next_probe):
ph() { curl -s -D - -o /dev/null -X POST "$GW/probe/v1/chat/completions" \
-H "Authorization: Bearer $1" -H 'Content-Type: application/json' \
-d '{"model":"probe-model","messages":[{"role":"user","content":"hi"}],"max_tokens":8}' \
| grep -iE '^HTTP/|^X-Upstream-Acct' | tr -d '\r'; }
p_code() { echo "$1" | awk '/^HTTP/{print $2}'; }
p_acct() { echo "$1" | awk '/X-Upstream-Acct/{print $2}'; }
P1=$(ph "$PROBE1_KEY")
ck "probe 冷分配落 #0(FNV 钉死)且首触 401" 0 "$(p_acct "$P1")"
ck "probe #0 首触 401 → 进冷却" 401 "$(p_code "$P1")"
P2=$(ph "$PROBE1_KEY")
ck "probe 绑定 #0 冷却中 → 退到 #1(也 401,被标记)" 401 "$(p_code "$P2")"
ck "probe 第二落点 #1" 1 "$(p_acct "$P2")"
sleep 2.0 # 首轮退避 1s 到期(#0/#1 标记时刻差 <0.5s,2s 留足余量;#0 的 next_probe 更早)
P3=$(ph "$PROBE1_KEY")
ck "★probe 全冷却下最早到期的 #0 被真实请求探测 → 200 回队" 200 "$(p_code "$P3")"
ck "★probe 探测落在 #0" 0 "$(p_acct "$P3")"
P4=$(ph "$PROBE1_KEY")
ck "★probe 绑定已复活的 #0 → 不被 #1 探测劫持(绑定流量保护)" 0 "$(p_acct "$P4")"
ck "probe 绑定保护请求正常 200" 200 "$(p_code "$P4")"
P5=$(ph "$PROBE2_KEY")
ck "★probe 无绑定流量被劫持去探测已到期 #1 → 吃真实 401(代价被退避封顶)" 401 "$(p_code "$P5")"
ck "probe 劫持落在 #1" 1 "$(p_acct "$P5")"
P6=$(ph "$PROBE2_KEY")
ck "probe 探测失败窗口即关闭(退避翻倍 2s)→ 回健康 #0" 0 "$(p_acct "$P6")"
sleep 3.0 # #1 第二轮退避 2s 到期(同样留余量)
P7=$(ph "$PROBE3_KEY")
ck "★probe #1 再次到期仍被探测(指数退避、不撒手)" 401 "$(p_code "$P7")"
ck "probe 第二轮探测仍落 #1" 1 "$(p_acct "$P7")"
UPS2=$(curl -s -b "$JAR" $API/api/admin/upstreams)
acct_view() { # $1=快照变量名内容 $2=slot $3=idx $4=路径 → 原始值(bool 小写)
printf '%s' "$1" | "$PY" -c '
import sys, json
slot, idx, path = sys.argv[2], int(sys.argv[3]), sys.argv[4]
d = json.loads(sys.argv[1])
items = d["data"]["items"] if isinstance(d.get("data"), dict) else (d.get("data") or [])
for u in items:
if u.get("slot") == slot:
for a in u.get("accounts", []):
if a.get("idx") == idx:
cur = a
for k in path.split("."):
cur = cur.get(k) if isinstance(cur, dict) else None
print(str(cur).lower()); sys.exit(0)
print("missing")
' "$1" "$2" "$3" "$4"; }
ck "★probe 投影:#0 冷却已解除(自动回队)" false "$(acct_view "$UPS2" probe 0 cooled)"
ck "★probe 投影:#1 仍在冷却(退避持续)" true "$(acct_view "$UPS2" probe 1 cooled)"
ck "probe #0 至少记 1 次耗尽" yes "$([ "$(acct_view "$UPS2" probe 0 load.exhausts)" -ge 1 ] && echo yes || echo no)"
ck "probe #1 至少记 3 次耗尽(标记+两轮探测)" yes "$([ "$(acct_view "$UPS2" probe 1 load.exhausts)" -ge 3 ] && echo yes || echo no)"
# ---- auth 规范化(normalize_auth)----
# fixture `normalize` 账号 auth 写成裸 key(`sk-NORM-NO-SCHEME`,无 `Bearer `),
# 期望:转发时网关自动补 `Bearer `,靶机实收完整头值(不会因缺 scheme 触发 1004)。
+13
View File
@@ -56,6 +56,19 @@
"note": "两账号均好,验证同一下游 key 粘性绑定到首个账号",
"created_at": 1757500000
},
"probe": {
"base": "http://127.0.0.1:18999",
"models": ["probe-model"],
"enabled": true,
"accounts": [
{"auth": "Bearer probe-flip", "note": "flip:首探 401、之后恢复(验证探测成功回队)", "resets": []},
{"auth": "Bearer probe-dead", "note": "dead:永远耗尽(验证退避持续冷却、劫持代价封顶)", "resets": []}
],
"exhaust_status": [401],
"exhaust_markers": ["\"status_code\":1004"],
"note": "探测恢复闭环:标记冷却 → next_probe 到期 → 无绑定/绑定失效的真实请求当探测 → 2xx 自动回队、失败退避翻倍",
"created_at": 1757500000
},
"normalize": {
"base": "http://127.0.0.1:18999",
"models": ["normalize-model"],
+30
View File
@@ -55,5 +55,35 @@
"llm_daily": 2,
"temp_grant_until": 0,
"created_at": 1757500000
},
"probe1": {
"username": "probe1",
"role": "user",
"salt": "0a0b0c0d0e0f10111213141516171819",
"pwd_hash": "00",
"api_key": "sk_probe_one_00000000000000000000000000000000",
"allowed_models": [],
"temp_grant_until": 0,
"created_at": 1757500000
},
"probe2": {
"username": "probe2",
"role": "user",
"salt": "1a1b1c1d1e1f20212223242526272829",
"pwd_hash": "00",
"api_key": "sk_probe_two_00000000000000000000000000000001",
"allowed_models": [],
"temp_grant_until": 0,
"created_at": 1757500000
},
"probe3": {
"username": "probe3",
"role": "user",
"salt": "2a2b2c2d2e2f30313233343536373839",
"pwd_hash": "00",
"api_key": "sk_probe_three_0000000000000000000000000000000",
"allowed_models": [],
"temp_grant_until": 0,
"created_at": 1757500000
}
}
+4
View File
@@ -36,6 +36,10 @@ http {
# 见 plugin-llm/src/stats_persist.rs 模块注释。
ipass_stats_persist 1;
# 探测闭环首轮退避压到 1 秒(生产默认 60s)——同理生产 conf/nginx.conf
# **刻意不写**这条指令,保证回滚到旧镜像不受 unknown directive 影响。
ipass_probe_min 1;
# 可选 HTTPS:run.sh 会在 @RUN@/tls/ 放渲染好的 443 server + 自签证书;
# 文件不存在时此 include 空匹配,不影响启动
include @RUN@/tls/*.conf;
+18 -1
View File
@@ -11,6 +11,7 @@
import json
import os
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
@@ -19,6 +20,13 @@ PORT = int(os.environ.get("UPSTREAM_PORT", "18999"))
# 故障注入(多账号路由测试):收到的 Authorization 含此子串时模拟「上游账号额度耗尽」,
# 回 401 + 响应体标记(与 MiniMax 的 status_code:1004 同构),验证网关自动切换。
FAIL_AUTH = os.environ.get("UPSTREAM_FAIL_AUTH", "")
# 探测闭环测试:FAIL_FIRST 对某 auth **只失败第一次**(之后正常)——用来验证
# 「冷却 → 退避到期 → 真实请求探测成功 → 自动回队」;FAIL_ALWAYS 永远失败——
# 验证「探测失败退避翻倍、冷却期持续跳过、代价被封顶」。
FAIL_FIRST_AUTH = os.environ.get("UPSTREAM_FAIL_FIRST_AUTH", "")
FAIL_ALWAYS_AUTH = os.environ.get("UPSTREAM_FAIL_ALWAYS_AUTH", "")
_first_seen: set = set()
_first_lock = threading.Lock()
class H(BaseHTTPRequestHandler):
@@ -67,7 +75,16 @@ class H(BaseHTTPRequestHandler):
# 故障注入(多账号路由测试):收到的 Authorization 含 UPSTREAM_FAIL_AUTH 子串时,
# 模拟「上游账号额度耗尽」——回 401 + 响应体标记(与 MiniMax 的 status_code:1004 同构),
# 验证网关「状态码 + body marker 双重检测 → 标记冷却 → 下次自动切到下一个账号」。
if FAIL_AUTH and FAIL_AUTH in self.headers.get("Authorization", "-"):
auth_hdr = self.headers.get("Authorization", "-")
exhaust_hit = bool(FAIL_AUTH) and FAIL_AUTH in auth_hdr
if not exhaust_hit and FAIL_ALWAYS_AUTH and FAIL_ALWAYS_AUTH in auth_hdr:
exhaust_hit = True
if not exhaust_hit and FAIL_FIRST_AUTH and FAIL_FIRST_AUTH in auth_hdr:
with _first_lock:
if auth_hdr not in _first_seen:
_first_seen.add(auth_hdr)
exhaust_hit = True
if exhaust_hit:
payload = json.dumps(
{"base_resp": {"status_code": 1004, "status_msg": "exhausted"}}
).encode()
+2 -1
View File
@@ -168,7 +168,8 @@ except Exception:
sys.exit(1)' && sleep 0.2 || break
done
UPSTREAM_LOG="$RUN/upstream.log" UPSTREAM_PORT=18999 UPSTREAM_FAIL_AUTH="acct-bad" "$PY" "$HERE/llm/upstream.py" \
UPSTREAM_LOG="$RUN/upstream.log" UPSTREAM_PORT=18999 UPSTREAM_FAIL_AUTH="acct-bad" \
UPSTREAM_FAIL_FIRST_AUTH="probe-flip" UPSTREAM_FAIL_ALWAYS_AUTH="probe-dead" "$PY" "$HERE/llm/upstream.py" \
>"$RUN/logs/upstream.out" 2>&1 &
up_pid=$!
+1 -1
View File
@@ -189,7 +189,7 @@ button.host-copy:hover{text-decoration:underline solid}
.acct-row{border:1px solid var(--border);border-radius:8px;padding:10px 12px;background:var(--bg);
display:flex;flex-direction:column;gap:8px}
.acct-head{display:flex;align-items:center;gap:8px;flex-wrap:wrap}
.acct-row .acct-auth,.acct-row .acct-note,.acct-row .acct-resets{width:100%}
.acct-row .acct-auth,.acct-row .acct-note{width:100%}
.acct-row .acct-del{margin-left:auto}
.acct-empty{font-size:12.5px;padding:6px 0}
+25 -13
View File
@@ -33,30 +33,43 @@
/// 由 base_url(协议中立,端口跟随当前访问管理台所用的 Host)推导两种协议的完整 API 地址。
/// base 写了路径(钉死粒度)时不重复追加对应后缀
function apiUrls(up) {
// **1.0.37 简化**:直接用后端 view_all 返回的 base_url / anthropic_base_url
// ——后端已经按「OpenAI SDK 不拼 /v1 → 必带 /v1」「Anthropic SDK 拼 /v1 → 不带 /v1」
// 的语义算好。前端不再做正则拼接(之前拼出过 `…/v1/anthropic` 错 URL)。
// **1.0.40 口径**:直接用后端 view 返回的 base_url / anthropic_base_url——
// 网关出口是**纯 slot**(`/<slot>` 与 `/<slot>/anthropic`,都不带 /v1);
// 厂商版本段存在上游 base 里,转发时 join_target 归一,客户端 SDK 带不带 /v1 都对。
// 前端不做任何拼接(历史版本正则拼出过 `…/v1/anthropic` 错 URL)。
return {
openai: up.base_url || "",
anthropic: up.anthropic_base_url || ""
};
}
/// epoch 秒 → HH:MM(浏览器本地时区;面板读者与网关同区)
function hhmm(ts) {
if (!ts) return "";
var d = new Date(ts * 1000);
function p(n) { return (n < 10 ? "0" : "") + n; }
return p(d.getHours()) + ":" + p(d.getMinutes());
}
/// 单账号行 HTML(编辑态用,i 为序号;a 为已有账号视图,可能来自后端 view())
function acctRowHtml(a, i) {
a = a || {};
var masked = a.auth_mask
? "<code class='mono'>" + IP.esc(a.auth_mask) + "</code><span class='muted'>(留空=保留原值)</span>"
: "<span class='muted'>新账号</span>";
// 1.0.44 探测闭环:冷却不再是「锁到某个边界」,而是到期放一个真实请求去探测,
// 2xx 自动回队、失败退避翻倍。tooltip 把时间线摊开,别再让人猜厂商重置点。
var coolTip = a.cooled
? "额度耗尽冷却中:约 " + hhmm(a.probe_next) + " 由下一个无绑定真实请求探测恢复;最迟 " + hhmm(a.cool_hard_cap) + " 无条件回队(退避指数增长,封顶 30 分钟一探)"
: "";
return "<div class='acct-row' data-idx='" + i + "'>" +
"<div class='acct-head'>" +
"<span class='badge b-gray'>#" + i + "</span>" + masked +
(a.cooled ? "<span class='badge b-err'>冷却中</span>" : "") +
(a.cooled ? "<span class='badge b-err' title='" + IP.esc(coolTip) + "'>冷却中</span>" : "") +
"<button type='button' class='btn-sm btn-danger acct-del'>删除</button>" +
"</div>" +
"<input class='field-mono acct-auth' placeholder='Bearer sk-...(编辑时留空=保留原值;只填裸 key 也会自动补 Bearer)' autocomplete='off'>" +
"<input class='acct-note' placeholder='备注,如 minimax-周额度' value='" + IP.esc(a.note || "") + "'>" +
"<input class='acct-resets' placeholder='重置周期(秒),逗号分隔,如 604800,14400' value='" + IP.esc((a.resets || []).join(",")) + "'>" +
"</div>";
}
@@ -129,15 +142,11 @@
e.preventDefault();
var accounts = [];
list.querySelectorAll(".acct-row").forEach(function (row) {
var resetsRaw = row.querySelector(".acct-resets").value.trim();
var resets = resetsRaw
? resetsRaw.split(",").map(function (s) { return parseInt(s.trim(), 10); })
.filter(function (n) { return !isNaN(n) && n > 0; })
: [];
// 1.0.44 起不再提交 resets(重置周期):恢复判定改为「指数退避 + 真实请求
// 探测」闭环,不再要求用户懂厂商窗口口径。存量数据里该字段仍保留、只不路由。
accounts.push({
auth: row.querySelector(".acct-auth").value.trim(),
note: row.querySelector(".acct-note").value.trim(),
resets: resets
note: row.querySelector(".acct-note").value.trim()
});
});
var payload = {
@@ -194,9 +203,12 @@
? " <span class='badge b-err' title='今日额度耗尽并被冷却的次数'>耗尽" + load.exhausts + "</span>"
: "";
var series = (trend[i] && trend[i].requests) || [];
var coolBadge = a.cooled
? " <span class='badge b-err' title='额度耗尽冷却中:约 " + IP.esc(hhmm(a.probe_next)) + " 由下一个无绑定真实请求探测恢复;最迟 " + IP.esc(hhmm(a.cool_hard_cap)) + " 无条件回队'>冷却</span>"
: "";
return "<div class='acct-load'>" +
"<code class='mono'>" + IP.esc(m) + "</code>" +
(a.cooled ? " <span class='badge b-err'>冷却</span>" : "") + exBadge +
coolBadge + exBadge +
"<div class='load-line'>今日 " + load.requests + " 请求 · 入 " + load.tokens_in + " / 出 " + load.tokens_out + " tok</div>" +
"<div class='load-bar'><span style='width:" + pct + "%'></span></div>" +
"<div class='spark'>" + spark(series, trendLabels) + "</div>" +