//! 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 `,都不可能含换行。 pub const PAYLOAD_SEP: char = '\n'; // =========================================================================== // 校验 // =========================================================================== /// slot:小写字母/数字开头,其后可含短横线、下划线,总长 ≤ 32。 /// /// 允许下划线(`azure_openai` 这类厂牌写法很常见),这点比子域名规则宽。 pub fn validate_slot(raw: &str) -> Result { 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, String> { let mut out: Vec = 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 { 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:` payload:`base \n <账号数>`。 fn up_payload(base: &str, n: usize) -> String { format!("{base}\n{n}") } /// `upa::` payload:`auth \n `(resets 空则第二段为空)。 fn upa_payload(auth: &str, resets: &[i64]) -> String { let csv = resets .iter() .map(|x| x.to_string()) .collect::>() .join(","); format!("{auth}\n{csv}") } /// 把一条上游配置同步进共享内存。**所有写操作之后必须调用它**。 /// /// 关闭(`enabled=false`)时是**删除**整个 slot 的键(up/upa/uac/upe),而不是 /// 写入空值——热路径「查不到 = 不可用」,停用即刻生效且不留残留。 /// /// 多账号布局(见 `config` 的键前缀注释): /// * `up:` = `base \n <账号数>` /// * `upa::` = `auth \n `(每个账号一条) /// * `upe:` = ` \n `(上游级耗尽探测配置) /// * `uac::`(冷却运行时态)**不在此清除**——保留到自然到期, /// 这样「正在冷却的账号」不会因为一次普通的 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:` = ` \n `。 fn write_upe(slot: &str, up: &Upstream) { let status = up .effective_exhaust_status() .iter() .map(|x| x.to_string()) .collect::>() .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:`:`(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::().unwrap_or(0); Some((base.to_owned(), n)) } /// 读 `upa::`:`(auth, resets)`。 pub fn read_upa(slot: &str, i: usize) -> Option<(String, Vec)> { 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::().ok()) .collect() }; Some((auth.to_owned(), resets)) } /// 读 `upe:`:`(status 列表, markers 列表)`。 pub fn read_upe(slot: &str) -> (Vec, Vec) { 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::().ok()) .collect() }; let markers = serde_json::from_str::>(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)> = Vec::new(); let mut cooled: Vec<(usize, String, i64, Vec)> = 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::().ok()) .unwrap_or(0); cooled.push((i, auth, eu, resets)); } else { avail.push((i, auth, resets)); } } let chosen: (usize, String, Vec) = if !avail.is_empty() { // 粘性绑定优先 let bound = key.and_then(|k| { state::get(KEY_UKB_PREFIX, k.as_bytes()) .and_then(|(v, _)| v.trim().parse::().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: 同构) // =========================================================================== /// 账号级日桶键 = `::<日窗id>` fn acct_day_key(slot: &str, idx: usize, day: i64) -> String { format!("{slot}:{idx}:{day}") } /// 记一次转发落到 `#`(请求数 +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 { 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 { let days = days_req.clamp(1, TREND_DAYS_MAX); let stamps: Vec = (0..days).rev().map(|i| now - i * 86400).collect(); let ids: Vec = stamps.iter().map(|t| util::day_id(*t)).collect(); let mut out = Vec::with_capacity(n); for idx in 0..n { let req: Vec = ids .iter() .map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).requests) .collect(); let tin: Vec = ids .iter() .map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).tin) .collect(); let tout: Vec = ids .iter() .map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).tout) .collect(); let ex: Vec = 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 { 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>, auth_raw: Option<&String>, accounts: Option>, exhaust_status: Option>, exhaust_markers: Option>, enabled: bool, note: Option<&String>, ) -> Result { 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 = 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(); } } a }) .collect(); (merged, String::new()) } None => ( Vec::new(), match auth_raw { Some(a) => util::trim(a).to_owned(), 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 { 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 = 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::>() .join(", ") } pub fn view_all(list: &[(String, Upstream)], port: &str) -> Vec { 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::().ok()) .unwrap_or(0); let ts = it .next() .and_then(|s| s.trim().parse::().ok()) .unwrap_or(0); Some((ok, code, ts)) }