Files
ipass__ipass/rust/crates/plugin-llm/src/upstreams.rs
T
admin f34ba3d198 fix(llm): auth 规范化兜住「只填裸 key」+ 排障子命令 (1.0.15)
线上 minimax 2 把 Key 点「测试」红字:1004 Please carry the API secret key
—— 根因是表单 placeholder 写 sk-...,用户照着填了**裸 key**(无 Bearer ),
而 accounts[].auth 语义是「完整 Authorization 头值」,转发时原样发就 1004。
agent.sh upstreams 一打就看出对照组:deepseek=Bearer s...d425(正常),
minimax=sk-cp-...(**无 Bearer **)——光看截图红字只会猜「额度用完」。

plugin-llm
- upstreams::normalize_auth:trim 后含空白→已完整;否则补「Bearer 」。
  **双处应用**:upsert 写入(下次保存自愈) + read_upa 读出(让线上坏数据
  立即可用,无需用户重填——存量 10 把 Key 根本不可能通知用户重填)。
- 兼容 Basic / 自定义 scheme / 前后空格 / 内部含空格共 6 个边界,
  干跑 + e2e 2 条新断言全过(裸 key 200 + 靶机实收 Bearer sk-NORM-NO-SCHEME)。

前端
- placeholder 改为「Bearer sk-…(... 留空=保留原值;只填裸 key 也会自动补 Bearer)」
  ——placeholder 写「前缀」会诱导漏填必要部分,写「字面值」才能正确引导。
- 多账号小节加说明文字(只填裸 key 也会自动补 Bearer)。

deploy/agent.sh
- 新增 upstreams(逐账号掩码/冷却/今日负载;掩码为空显式标 **空** —— 这条
  是发现「只填裸 key」类问题的关键指示器,旧镜像的回显脱敏后看不出问题)
- 新增 upstream-test <slot>(调测试接口并打印厂商真实 status_code + body),
  避免再靠「管理台截图 OCR」排障。

回归 281 全绿(网关 102 + LLM 179);专章 docs/llm/MULTI_ACCOUNT_ROUTING.md §10
记录现象/规则/兼容表/自检工具。
2026-09-14 14:21:48 +08:00

952 lines
38 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! LLM 上游配置与共享内存同步。
//!
//! 这是「转发映射」机制在 LLM 侧的翻版:`domains.rs` 管
//! `子域名 → 后端`,本模块管 `路径前缀(slot) → 上游(基址 + 密钥)`。
//! 两者都**写穿共享内存**,理由相同——热路径未命中即失败,不回源读文件。
//!
//! ## 为什么按 URL 前缀分上游,而不是按请求体里的 `model`
//!
//! 转发决策点在 access 阶段,而请求体要到 content 阶段才读得到
//! (见 `http::collect_body` 的调用前提)。按 `model` 字段分流就必须放弃
//! `proxy_pass`、自己实现 upstream 转发,代码量与出错面差一个数量级。
//! 代价只是客户端 base_url 需要带上 slot 段,可接受。
//!
//! `data/llm-upstreams.json` 含上游真实 API Key,**敏感级别等同 `users.json`**。
use serde_json::{Value, json};
use crate::config::{
ACCT_COOLDOWN_DEFAULT, 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,
TREND_DAYS_MAX, TREND_KEEP_SECS, UPSTREAM_BASE_MAX_LEN, UPSTREAM_MODELS_MAX,
UPSTREAM_SLOT_MAX_LEN,
};
use crate::models::{Upstream, UpstreamAccount};
use crate::store;
use ipass_core::config::LLM_PUBLIC_HOST;
use ipass_core::{state, usage, util};
/// 共享内存 payload 的内部分隔符:base 与 auth 之间。
///
/// 与 `config::VAL_SEP`(0x1f,负责切 payload / expires_at)是两层不同的
/// 分隔,不能混用。base 是 URL、auth 是 `Bearer <token>`,都不可能含换行。
pub const PAYLOAD_SEP: char = '\n';
// ===========================================================================
// 校验
// ===========================================================================
/// slot:小写字母/数字开头,其后可含短横线、下划线,总长 ≤ 32。
///
/// 允许下划线(`azure_openai` 这类厂牌写法很常见),这点比子域名规则宽。
pub fn validate_slot(raw: &str) -> Result<String, String> {
let s = util::trim(raw).to_ascii_lowercase();
if s.is_empty() {
return Err("缺少 slot 参数".to_owned());
}
if s.len() > UPSTREAM_SLOT_MAX_LEN {
return Err(format!("slot 长度不能超过 {UPSTREAM_SLOT_MAX_LEN} 个字符"));
}
let bytes = s.as_bytes();
let head_ok = matches!(bytes[0], b'a'..=b'z' | b'0'..=b'9');
let tail_ok = bytes[1..].iter().all(|&b| matches!(b, b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_'));
if !head_ok || !tail_ok {
return Err("slot 只能是小写字母、数字、短横线或下划线,且不能以符号开头".to_owned());
}
Ok(s)
}
/// 模型名清单:去空白、去空项、去重、限长。
///
/// 刻意**允许** `/` `.` `:` 等字符——`Qwen/Qwen2.5-7B`(HF 风格)、
/// `llama3:8b`(Ollama 标签)都是合法模型名。只挡空白与控制字符,
/// 因为模型名要出现在 URL/JSON/HTML 里,空白只会带来歧义。
fn check_models(raw: &[String]) -> Result<Vec<String>, String> {
let mut out: Vec<String> = Vec::new();
for item in raw {
let m = util::trim(item);
if m.is_empty() {
continue;
}
if m.chars().count() > MODEL_NAME_MAX_LEN {
return Err(format!("模型名「{m}」超过 {MODEL_NAME_MAX_LEN} 个字符"));
}
if m.chars().any(char::is_whitespace) || m.chars().any(char::is_control) {
return Err(format!("模型名「{m}」不能包含空格或控制字符"));
}
if !out.iter().any(|x| x == m) {
out.push(m.to_owned());
}
}
if out.len() > UPSTREAM_MODELS_MAX {
return Err(format!("单个上游最多登记 {UPSTREAM_MODELS_MAX} 个模型"));
}
Ok(out)
}
/// 上游基址:必须显式带 `http://` 或 `https://`。
///
/// 比子域名的 `backend`(纯 host:port)宽——LLM 上游常挂在网关路径下
/// (如 `https://gw.corp.com/llm`),所以要允许尾随路径。
pub fn validate_base(raw: &str) -> Result<String, String> {
let s = util::trim(raw).trim_end_matches('/').to_owned();
if s.is_empty() {
return Err("缺少 base 参数".to_owned());
}
if s.len() > UPSTREAM_BASE_MAX_LEN {
return Err(format!("base 长度不能超过 {UPSTREAM_BASE_MAX_LEN} 个字符"));
}
let rest = if let Some(r) = s.strip_prefix("https://") {
r
} else if let Some(r) = s.strip_prefix("http://") {
r
} else {
return Err("base 必须以 http:// 或 https:// 开头,例如 https://api.openai.com".to_owned());
};
if rest.is_empty() {
return Err("base 缺少主机名".to_owned());
}
if rest.chars().any(char::is_whitespace) || rest.contains('@') {
return Err("base 不允许包含空格或用户信息(user@host)".to_owned());
}
if rest.split('/').next().unwrap_or("").is_empty() {
return Err("base 缺少主机名".to_owned());
}
Ok(s)
}
// ===========================================================================
// 共享内存同步(写穿 / 装载)
// ===========================================================================
/// 一个 slot 最多支持的账号下标(清理残留旧账号下标时遍历的上界)。
/// 实际部署不会接近这个数;超出部分不被支持(管理台会拦)。
const ACCOUNT_INDEX_MAX: usize = 64;
/// `up:<slot>` payload:`base \n <账号数>`。
fn up_payload(base: &str, n: usize) -> String {
format!("{base}\n{n}")
}
/// `upa:<slot>:<idx>` payload:`auth \n <resets csv>`(resets 空则第二段为空)。
fn upa_payload(auth: &str, resets: &[i64]) -> String {
let csv = resets
.iter()
.map(|x| x.to_string())
.collect::<Vec<_>>()
.join(",");
format!("{auth}\n{csv}")
}
/// 把一条上游配置同步进共享内存。**所有写操作之后必须调用它**。
///
/// 关闭(`enabled=false`)时是**删除**整个 slot 的键(up/upa/uac/upe),而不是
/// 写入空值——热路径「查不到 = 不可用」,停用即刻生效且不留残留。
///
/// 多账号布局(见 `config` 的键前缀注释):
/// * `up:<slot>` = `base \n <账号数>`
/// * `upa:<slot>:<i>` = `auth \n <resets csv>`(每个账号一条)
/// * `upe:<slot>` = `<status csv> \n <markers json>`(上游级耗尽探测配置)
/// * `uac:<slot>:<i>`(冷却运行时态)**不在此清除**——保留到自然到期,
/// 这样「正在冷却的账号」不会因为一次普通的 upsert(比如改备注)而莫名复活。
pub fn sync_shm(slot: &str, up: &Upstream) {
if !up.enabled {
remove_slot_shm(slot);
return;
}
let accts = up.effective_accounts();
if !state::put(
KEY_UP_PREFIX,
slot.as_bytes(),
up_payload(&up.base, accts.len()).as_bytes(),
0,
) {
util::log_err(&format!(
"[upstreams] 上游 base 写共享内存失败 slot={slot} —— 该上游会 404(共享内存可能已满)"
));
}
write_upe(slot, up);
for (i, a) in accts.iter().enumerate() {
let ak = format!("{slot}:{i}");
if !state::put(
KEY_UPA_PREFIX,
ak.as_bytes(),
upa_payload(&a.auth, &a.resets).as_bytes(),
0,
) {
util::log_err(&format!(
"[upstreams] 上游账号写共享内存失败 slot={slot}#{i} —— 该账号会 404"
));
}
}
// 清掉被删/被减的账号下标(i >= 现账号数),避免旧 upa/uac 残留被误读
for i in accts.len()..ACCOUNT_INDEX_MAX {
state::remove(KEY_UPA_PREFIX, format!("{slot}:{i}").as_bytes());
state::remove(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes());
}
}
/// 删除一个 slot 在共享内存里的全部键(up / upe / upa* / uac*)。
pub fn remove_slot_shm(slot: &str) {
state::remove(KEY_UP_PREFIX, slot.as_bytes());
state::remove(KEY_UPE_PREFIX, slot.as_bytes());
for i in 0..ACCOUNT_INDEX_MAX {
state::remove(KEY_UPA_PREFIX, format!("{slot}:{i}").as_bytes());
state::remove(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes());
}
}
/// 写上游级「额度耗尽」探测配置:`upe:<slot>` = `<status csv> \n <markers json>`。
fn write_upe(slot: &str, up: &Upstream) {
let status = up
.effective_exhaust_status()
.iter()
.map(|x| x.to_string())
.collect::<Vec<_>>()
.join(",");
let markers = serde_json::to_string(&up.exhaust_markers).unwrap_or_else(|_| "[]".to_owned());
let payload = format!("{status}\n{markers}");
if !state::put(KEY_UPE_PREFIX, slot.as_bytes(), payload.as_bytes(), 0) {
util::log_err(&format!("[upstreams] 上游耗尽配置写共享内存失败 slot={slot}"));
}
}
/// 全量重载上游表(启动装载 / 批量变更后)。返回装载条数。
///
/// 清 `up:` / `upa:` / `uac:` / `upe:` 四类前缀(**不**清 `ukb:` 粘性绑定——
/// 重启后重新绑定本就是预期语义)。
pub fn reload_shm() -> usize {
state::clear_prefix(KEY_UP_PREFIX);
state::clear_prefix(KEY_UPA_PREFIX);
state::clear_prefix(KEY_UAC_PREFIX);
state::clear_prefix(KEY_UPE_PREFIX);
let mut expected = 0;
let mut loaded = 0;
for (slot, up) in store::read_upstreams() {
if !up.enabled {
continue;
}
expected += 1;
let accts = up.effective_accounts();
if state::put(
KEY_UP_PREFIX,
slot.as_bytes(),
up_payload(&up.base, accts.len()).as_bytes(),
0,
) {
loaded += 1;
}
write_upe(&slot, &up);
for (i, a) in accts.iter().enumerate() {
let ak = format!("{slot}:{i}");
state::put(
KEY_UPA_PREFIX,
ak.as_bytes(),
upa_payload(&a.auth, &a.resets).as_bytes(),
0,
);
}
}
if loaded != expected {
util::log_err(&format!(
"[upstreams] 上游装载不全:{loaded}/{expected} —— 有上游会 404"
));
}
loaded
}
/// 读 `up:<slot>`:`(base, 账号数)`。
pub fn read_up(slot: &str) -> Option<(String, usize)> {
let (payload, _) = state::get(KEY_UP_PREFIX, slot.as_bytes())?;
let (base, nstr) = payload.split_once('\n').unwrap_or((&payload, "0"));
let n = nstr.trim().parse::<usize>().unwrap_or(0);
Some((base.to_owned(), n))
}
/// 规范化账号 Authorization 头值:缺 scheme 时自动补 `Bearer `。
///
/// 用途:**兜住「只填了裸 key 没填 `Bearer `」这种历史坏数据**。表单 placeholder
/// 写的是 `sk-...`,用户照着填 → 之前保存的就是 `sk-cp-...` 这种裸 key,
/// 上游(MiniMax)只认 `Bearer <key>`,于是回 1004。
///
/// 规则:
/// * 空 → 原样返回("未配 Key"是合法状态,不是数据错);
/// * 含空格 → 原样返回(已是完整头值,如 `Bearer xxx` / `Basic xxx`,别动);
/// * 不含空格 → 补 `Bearer ` 前缀。
///
/// 同时也在 `upsert` 里应用:下次保存时旧数据自动归正,无需用户手动重填。
pub fn normalize_auth(auth: &str) -> String {
let t = auth.trim();
if t.is_empty() {
return String::new();
}
if t.contains(char::is_whitespace) {
return t.to_owned();
}
format!("Bearer {}", t)
}
/// 读 `upa:<slot>:<i>`:`(auth, resets)`。
pub fn read_upa(slot: &str, i: usize) -> Option<(String, Vec<i64>)> {
let (payload, _) = state::get(KEY_UPA_PREFIX, format!("{slot}:{i}").as_bytes())?;
let (auth, rest) = payload.split_once('\n').unwrap_or((&payload, ""));
let resets = if rest.trim().is_empty() {
Vec::new()
} else {
rest.split(',')
.filter_map(|s| s.trim().parse::<i64>().ok())
.collect()
};
Some((normalize_auth(auth), resets))
}
/// 读 `upe:<slot>`:`(status 列表, markers 列表)`。
pub fn read_upe(slot: &str) -> (Vec<i64>, Vec<String>) {
let (payload, _) = match state::get(KEY_UPE_PREFIX, slot.as_bytes()) {
Some(p) => p,
None => return (EXHAUST_STATUS_DEFAULT.to_vec(), Vec::new()),
};
let (status_str, markers_str) = payload.split_once('\n').unwrap_or((&payload, "[]"));
let status = if status_str.trim().is_empty() {
EXHAUST_STATUS_DEFAULT.to_vec()
} else {
status_str
.split(',')
.filter_map(|s| s.trim().parse::<i64>().ok())
.collect()
};
let markers = serde_json::from_str::<Vec<String>>(markers_str.trim())
.unwrap_or_else(|_| Vec::new());
(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()
}
/// 标记某账号额度耗尽,进入冷却直到「下一个重置边界」。
///
/// 重置窗口**锚定到「天」边界**(不是从 `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)
};
if !state::put(
KEY_UAC_PREFIX,
format!("{slot}:{i}").as_bytes(),
until.to_string().as_bytes(),
until,
) {
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)
));
}
}
/// 计算「额度耗尽后冷却到哪个时刻」(天锚定,末窗封顶到次日 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);
}
best
}
/// 粘性绑定 TTL:取该账号最长重置周期,空则兜底 7 天。
fn affinity_ttl(resets: &[i64]) -> i64 {
if resets.is_empty() {
AFFINITY_TTL_DEFAULT
} else {
*resets.iter().max().unwrap()
}
}
/// 冷分配(无粘性绑定时)按下流 key 选一个「可用」账号下标。
///
/// 用 **FNV-1a 哈希(key) % n** 做确定性分散——同时满足了两件事:
/// * **均匀铺开**:不同下游 key 哈希值不同 → 落到不同上游账号,避免所有请求都压在
/// `account#0` 触发 MiniMax 这类厂商的「agent 并发上限」;
/// * **分配后保持**:同一 key 哈希值固定 → 永远落到同一账号(粘性绑定的前提),
/// 于是同一用户的请求始终由同一个上游账号处理,**prompt / token 缓存得以命中**
/// (否则同一会话的请求被轮到不同账号,缓存前缀对不上 → 命中率暴跌、等于白缓存)。
///
/// 下流 key 不存在(内部「测试」按钮 location 不带 Bearer)→ 退化为 nginx 自带伪随机
/// `ngx_random()`,仅用于分散探测/压测流量,不要求粘性。
fn cold_index(key: Option<&str>, n: usize) -> usize {
if n == 0 {
return 0;
}
let r = match key {
Some(k) => {
// FNV-1a 64:快、无依赖、同 key 同值(偏移 0xcbf29ce484232325 / 素数 0x100000001b3)。
// 选它是因为确定性可复现——本机回归能用同一段哈希精确预测首次落点,
// 既验证「分散」又验证「分配后保持」而不依赖全局随机源。
let mut h: u64 = 0xcbf2_9ce4_8423_2325;
for &b in k.as_bytes() {
h ^= b as u64;
h = h.wrapping_mul(0x100_0000_01b3);
}
h
}
None => nginx_sys::ngx_random() as u64,
};
(r % n as u64) as usize
}
/// 选上游账号:实现「用户 key → 上游账号」粘性 + 跳过冷却中账号 + 全冷却 best-effort。
///
/// 返回 `(选中账号下标, 该账号 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:` 粘性绑定(变化才写,避免每请求写)。
///
/// ⚠️ 只读 `up:` / `upa:` / `uac:` / `ukb:`,**不回源读文件**;未命中即视为不可用。
pub fn pick_account(
slot: &str,
key: Option<&str>,
now: i64,
) -> Option<(usize, String, String)> {
let (base, n) = read_up(slot)?;
if n == 0 {
return None;
}
let mut avail: Vec<(usize, String, Vec<i64>)> = Vec::new();
let mut cooled: Vec<(usize, String, i64, Vec<i64>)> = 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));
}
}
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())
}
} 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)
} else {
return None;
};
// 写粘性绑定(仅当下行 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);
state::put(
KEY_UKB_PREFIX,
k.as_bytes(),
chosen.0.to_string().as_bytes(),
now + ttl,
);
}
}
Some((chosen.0, chosen.1, base))
}
// ===========================================================================
// 账号级负载统计(shm 日桶,无数据库;与 uds:/udu: 同构)
// ===========================================================================
/// 账号级日桶键 = `<slot>:<idx>:<日窗id>`
fn acct_day_key(slot: &str, idx: usize, day: i64) -> String {
format!("{slot}:{idx}:{day}")
}
/// 记一次转发落到 `<slot>#<idx>`(请求数 +1)。log 阶段每真实转发调用一次。
///
/// ⚠️ 只在这里记——`pick_account` 会被 `$llm_target/$llm_auth/$llm_acct` 三个变量
/// 各触发一次,若在里面记会三倍计数;log 阶段经 `read_llm_acct` 取一次下标即可。
pub fn bump_acct_load(slot: &str, idx: usize, now: i64) {
let d = usage::DayBucket { requests: 1, ..Default::default() };
usage::bump_day(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, util::day_id(now)), &d, TREND_KEEP_SECS);
}
/// 账号级 token 负载(来源:body filter 从上游响应抓到的 usage)。log 阶段入账。
pub fn add_acct_tokens(slot: &str, idx: usize, tin: i64, tout: i64, now: i64) {
let d = usage::DayBucket { tin, tout, ..Default::default() };
usage::bump_day(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, util::day_id(now)), &d, TREND_KEEP_SECS);
}
/// 账号级额度耗尽次数 +1(仅指标,不参与路由)。
pub fn bump_acct_exhaust(slot: &str, idx: usize, now: i64) {
let d = usage::DayBucket { requests: 1, ..Default::default() };
usage::bump_day(KEY_UEX_PREFIX, &acct_day_key(slot, idx, util::day_id(now)), &d, TREND_KEEP_SECS);
}
/// 读某账号今日负载:`(requests, tin, tout, exhausts)`。
pub fn read_acct_load(slot: &str, idx: usize, now: i64) -> (i64, i64, i64, i64) {
let day = util::day_id(now);
let b = usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, day));
let e = usage::day_bucket(KEY_UEX_PREFIX, &acct_day_key(slot, idx, day));
(b.requests, b.tin, b.tout, e.requests)
}
/// 最近 `days` 天的日期标签(`MM-DD`),与 [`account_trend`] 的序列**逐位对齐**。
///
/// 由后端算而不是前端 `Date` 推导:日窗口径(`util::day_id` 的本地自然日)
/// 只应有一处定义,前端各算一份迟早会在跨时区/跨零点时对不上。
pub fn trend_labels(now: i64, days_req: i64) -> Vec<String> {
let days = days_req.clamp(1, TREND_DAYS_MAX);
(0..days).rev().map(|i| util::fmt_day(now - i * 86400)).collect()
}
/// 某 slot 各账号最近 `days` 天的负载序列(图表数据源,默认 14 天)。
///
/// 每个账号一条:`requests / in / out / exhausts` 四个等长数组,键精确取、
/// 不随历史增长。前端用 `requests` 画迷你趋势,一眼看出「哪把 Key 哪天扛了多少」。
pub fn account_trend(slot: &str, n: usize, now: i64, days_req: i64) -> Vec<Value> {
let days = days_req.clamp(1, TREND_DAYS_MAX);
let stamps: Vec<i64> = (0..days).rev().map(|i| now - i * 86400).collect();
let ids: Vec<i64> = stamps.iter().map(|t| util::day_id(*t)).collect();
let mut out = Vec::with_capacity(n);
for idx in 0..n {
let req: Vec<i64> = ids
.iter()
.map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).requests)
.collect();
let tin: Vec<i64> = ids
.iter()
.map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).tin)
.collect();
let tout: Vec<i64> = ids
.iter()
.map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).tout)
.collect();
let ex: Vec<i64> = ids
.iter()
.map(|d| usage::day_bucket(KEY_UEX_PREFIX, &acct_day_key(slot, idx, *d)).requests)
.collect();
out.push(json!({
"idx": idx,
"requests": req,
"in": tin,
"out": tout,
"exhausts": ex,
}));
}
out
}
// ===========================================================================
// 查询
// ===========================================================================
/// 全部上游,按 slot 升序
pub fn all() -> Vec<(String, Upstream)> {
store::read_upstreams().into_iter().collect()
}
pub fn get(slot: &str) -> Option<Upstream> {
store::read_upstreams().remove(slot)
}
/// 某账号**可用**的上游(已启用,且在白名单内;`allowed` 为空 = 不限)。
///
/// 账号态接口与模型发现都用它,避免"能看见但不能用"或反之的两套判定。
pub fn available(allowed: &[String]) -> Vec<(String, Upstream)> {
all()
.into_iter()
.filter(|(slot, up)| {
up.enabled && (allowed.is_empty() || allowed.iter().any(|s| s == slot))
})
.collect()
}
/// 客户端应当使用的 base_url。
///
/// 规则:**把上游 base 的 scheme+host 换成网关域名,路径原样保留**——
/// 这样它才真的能和厂商文档里的 base_url 逐个字符替换:
///
/// ```text
/// https://api.deepseek.com/v1 → https://lm.mayishangshu.cn:88/deepseek/v1
/// https://api.openai.com → https://lm.mayishangshu.cn:88/openai
/// ```
///
/// `port` 由调用方从请求 Host 头取(`http::host_port`),**不要写死**:
/// 部署在 88 时客户端必须带 `:88` 才连得到,而放在 443 反代后面时又必须不带端口。
/// 写死任何一种,都会在另一种部署里给出一个「看着对、实际打不通」的地址。
///
/// 反过来(不管上游 base 的路径、一律拼 `/v1`)会让「base 自带 /v1」的上游
/// 变成 `/v1/v1/chat/completions` → 上游 404,且客户端拿到的是空响应体,
/// 排查起来完全看不出是网关拼错了。**实测踩过,别再改回去。**
pub fn base_url(slot: &str, up: &Upstream, port: &str) -> String {
let rest = up.base.split("://").nth(1).unwrap_or("");
let path = match rest.find('/') {
Some(i) => &rest[i..],
None => "",
};
format!("https://{LLM_PUBLIC_HOST}{port}/{slot}{path}")
}
/// Anthropic 客户端(Claude Code / Claude SDK)应当使用的 `ANTHROPIC_BASE_URL`。
///
/// 协议段由**客户端**负责表达(网关不猜协议),但这段路径是网关替客户端拼好的,
/// 所以要处理重合:上游 `base` 若已钉在 `…/anthropic`(协议钉死型记录),其
/// `base_url` 末尾已经带 `/anthropic`,再无脑追加会得到 `…/anthropic/anthropic`。
pub fn anthropic_base_url(slot: &str, up: &Upstream, port: &str) -> String {
let b = base_url(slot, up, port);
if b.ends_with("/anthropic") {
b
} else {
format!("{b}/anthropic")
}
}
/// 模型发现:把可用上游挂载的模型摊平成 `(模型名, slot)` 列表。
///
/// 没登记 `models` 的上游不产出任何条目(清单未知 ≠ 有 0 个模型),
/// 但它的转发能力不受影响——模型发现只是"告诉你有什么",
/// 不是"允许你用什么"。
pub fn models_flat(allowed: &[String]) -> Vec<(String, String)> {
let mut out = Vec::new();
for (slot, up) in available(allowed) {
for model in &up.models {
out.push((model.clone(), slot.clone()));
}
}
out
}
// ===========================================================================
// 写入
// ===========================================================================
/// 新增或覆盖一个上游。
///
/// 参数语义(兼容旧调用方,同时支持多账号):
/// * `models = None` / `auth_raw = None` / `note = None` 都表示**保持原值**;
/// `Some("")` 表示显式清空。
/// * `accounts = Some(..)` 表示用多账号列表**整体替换**(此时顶层 `auth` 不再生效,
/// 写入时被清为 `""`,避免 `auth` 与 `accounts[0]` 重复);`None` 表示沿用旧逻辑
/// —— 用 `auth_raw` 维护单账号(legacy `auth` 字段)。
/// * `exhaust_status` / `exhaust_markers` 同理:`Some` 覆盖,`None` 保持原值。
///
/// `enabled = false` 会立刻从共享内存摘除。
pub fn upsert(
slot_raw: &str,
base_raw: &str,
models: Option<Vec<String>>,
auth_raw: Option<&String>,
accounts: Option<Vec<UpstreamAccount>>,
exhaust_status: Option<Vec<i64>>,
exhaust_markers: Option<Vec<String>>,
enabled: bool,
note: Option<&String>,
) -> Result<Upstream, String> {
let slot = validate_slot(slot_raw)?;
let base = validate_base(base_raw)?;
let models = match models {
Some(list) => Some(check_models(&list)?),
None => None,
};
let key = slot.clone();
let up = store::update_upstreams(move |table| {
// 先克隆出来:下面 insert 需要可变借用,不能与这里的不可变借用并存
let existing = table.get(&key).cloned();
// 多账号:整体替换(清掉顶层 auth,避免重复);否则走 legacy 单 auth
let (accounts, legacy_auth) = match accounts {
Some(list) => {
let existing_accounts = existing
.as_ref()
.map(|e| e.effective_accounts())
.unwrap_or_default();
// 账号 auth 留空 = 保留该下标原账号的密钥(编辑时前端只发掩码外的空串)
let merged: Vec<UpstreamAccount> = list
.into_iter()
.enumerate()
.map(|(i, mut a)| {
if a.auth.trim().is_empty() {
if let Some(old) = existing_accounts.get(i) {
a.auth = old.auth.clone();
}
} else {
// 缺 scheme 自动补 `Bearer `(兜住「只填裸 key」的历史坏数据)
a.auth = normalize_auth(&a.auth);
}
a
})
.collect();
(merged, String::new())
}
None => (
Vec::new(),
match auth_raw {
Some(a) => normalize_auth(a),
None => existing.as_ref().map(|e| e.auth.clone()).unwrap_or_default(),
},
),
};
let note = match note {
Some(n) => util::trim(n).to_owned(),
None => existing.as_ref().map(|e| e.note.clone()).unwrap_or_default(),
};
let models = match models {
Some(m) => m,
None => existing.as_ref().map(|e| e.models.clone()).unwrap_or_default(),
};
let exhaust_status = match exhaust_status {
Some(s) => s,
None => existing
.as_ref()
.map(|e| e.exhaust_status.clone())
.unwrap_or_default(),
};
let exhaust_markers = match exhaust_markers {
Some(m) => m,
None => existing
.as_ref()
.map(|e| e.exhaust_markers.clone())
.unwrap_or_default(),
};
let created_at = existing
.as_ref()
.map(|e| e.created_at)
.filter(|&t| t > 0)
.unwrap_or_else(util::now);
let item = Upstream {
base,
models,
enabled,
note,
created_at,
accounts,
exhaust_status,
exhaust_markers,
auth: legacy_auth,
};
table.insert(key.clone(), item.clone());
Ok(item)
})?;
sync_shm(&slot, &up);
Ok(up)
}
/// 删除上游,并立刻从共享内存摘掉
pub fn remove(slot_raw: &str) -> Result<String, String> {
let slot = validate_slot(slot_raw)?;
let key = slot.clone();
store::update_upstreams(move |table| {
if table.remove(&key).is_none() {
return Err(format!("上游 {key} 不存在"));
}
Ok(())
})?;
state::remove(KEY_UP_PREFIX, slot.as_bytes());
Ok(slot)
}
// ===========================================================================
// 对外投影
// ===========================================================================
/// 转成管理台可见的字段。
///
/// **绝不回显完整 auth**——管理台页面会被截图、被浏览器插件读取,
/// 回显上游真 Key 等于把公司所有厂商密钥摆在一个 HTML 里。
///
/// 多账号:列出每个账号的掩码 auth / 备注 / 重置周期 / 当前是否冷却,
/// 便于运维直观看到「哪把 Key 在额度耗尽冷却中」。
pub fn view(slot: &str, up: &Upstream, port: &str) -> Value {
let (status, code, checked_at) = match health(slot) {
Some((ok, c, ts)) => (if ok { "ok" } else { "failed" }, c, ts),
None => ("unknown", 0, 0),
};
let now = util::now();
let accounts: Vec<Value> = up
.effective_accounts()
.into_iter()
.enumerate()
.map(|(i, a)| {
let (lr, lin, lout, lex) = read_acct_load(slot, i, now);
json!({
"idx": i,
"auth_set": !a.auth.is_empty(),
"auth_mask": if a.auth.is_empty() { "-".to_owned() } else { util::mask_key(&a.auth) },
"note": a.note,
"resets": a.resets,
"resets_text": resets_text(&a.resets),
"cooled": is_cooled(slot, i, now),
"load": {
"requests": lr,
"tokens_in": lin,
"tokens_out": lout,
"exhausts": lex,
},
})
})
.collect();
let has_auth = accounts.iter().any(|a| a["auth_set"] == Value::Bool(true));
// 各账号最近 14 天负载序列(图表数据源):用于管理台展示「哪把 Key 哪天扛了多少」
let acct_trend = account_trend(slot, accounts.len(), now, ACCT_TREND_DAYS);
let labels = trend_labels(now, ACCT_TREND_DAYS);
json!({
"slot": slot,
"base": up.base,
"base_url": base_url(slot, up, port),
"anthropic_base_url": anthropic_base_url(slot, up, port),
"models": up.models,
"model_count": up.models.len(),
"account_count": accounts.len(),
"auth_set": has_auth,
"enabled": up.enabled,
"note": up.note,
"exhaust_status": up.effective_exhaust_status(),
"exhaust_markers": up.exhaust_markers,
"accounts": accounts,
"account_trend": acct_trend,
"trend_labels": labels,
"created_at": up.created_at,
"created_at_text": util::fmt_time(up.created_at),
"status": status,
"status_code": if code > 0 { json!(code) } else { Value::Null },
"checked_at": checked_at,
"checked_at_text": if checked_at > 0 { util::fmt_time(checked_at) } else { String::new() },
})
}
/// 把重置周期数组渲染成人类可读文本,如 `[604800, 14400]` → "每周, 每4小时"。
fn resets_text(resets: &[i64]) -> String {
const H1: i64 = 3600;
const H2: i64 = 2 * 3600;
const H4: i64 = 4 * 3600;
const H6: i64 = 6 * 3600;
const H12: i64 = 12 * 3600;
const D1: i64 = 86400;
const W1: i64 = 7 * 86400;
resets
.iter()
.map(|&s| match s {
H1 => "每1小时".to_owned(),
H2 => "每2小时".to_owned(),
H4 => "每4小时".to_owned(),
H6 => "每6小时".to_owned(),
H12 => "每12小时".to_owned(),
D1 => "每天".to_owned(),
W1 => "每周".to_owned(),
_ => format!("每{}秒", s),
})
.collect::<Vec<_>>()
.join(", ")
}
pub fn view_all(list: &[(String, Upstream)], port: &str) -> Vec<Value> {
list.iter().map(|(slot, up)| view(slot, up, port)).collect()
}
// ===========================================================================
// 上游健康缓存(uh:)
// ===========================================================================
/// 记录一次上游真实响应结果。**只读端不会用它做任何决策**——转发路径
/// 从不查这份缓存,所以误标最多影响展示,不会误杀请求。
///
/// 写失败必须出声(热路径无回源兜底是转发侧的事,这里出声是为了
/// 别让「列表永远显示未探测」这种静默怪象无人解释)。
pub fn mark_health(slot: &str, ok: bool, code: i64) {
let ts = util::now();
let payload = format!("{}\n{}\n{}", if ok { 1 } else { 0 }, code, ts);
if !state::put(
KEY_UH_PREFIX,
slot.as_bytes(),
payload.as_bytes(),
ts + 30 * 86400,
) {
util::log_err(&format!("[upstreams] 健康状态写共享内存失败 slot={slot}"));
}
}
/// 读健康缓存:`Some((是否正常, 上游状态码, 记录时刻))`,没探测过 = `None`。
pub fn health(slot: &str) -> Option<(bool, i64, i64)> {
let (payload, _) = state::get(KEY_UH_PREFIX, slot.as_bytes())?;
let mut it = payload.split('\n');
let ok = it.next().unwrap_or("0").trim() == "1";
let code = it
.next()
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(0);
let ts = it
.next()
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(0);
Some((ok, code, ts))
}