feat(llm): 上游多账号路由 + 账号级负载统计 (1.0.14)
一个 slot 挂多把上游账号 Key,解决厂商「单账号额度/并发受限」与 「同一用户缓存命中」两个矛盾诉求。 多账号路由 (plugin-llm) - models: Upstream.accounts[] (auth/note/resets) + 上游级 exhaust_status/exhaust_markers;顶层 auth 保留兼容(accounts 为空时合成单账号) - upstreams::pick_account:粘性绑定 ukb:<key> 优先 → 无绑定时 FNV-1a(下游 Key) % 可用数 冷分散 → 绑定账号冷却则重新分散 → 全冷却取最早恢复 * 分散避开厂商单账号 agent 并发上限;落点固定保住 prompt/token 缓存 - cool_until_until 天锚定冷却:boundary = day0 + ceil(已过/窗口)*窗口, 封顶次日 0 点(MiniMax 5h 窗口、24=5*4+4 → 末段 20:00-24:00 只有 4h 随天重置) - 耗尽双检测 (log 阶段):$upstream_status 命中 exhaust_status,或 usage_filter 流式扫到 marker → $llm_acct 定位本次账号 → 写冷却 uac: - shm: up:/upa:/uac:/ukb:/upe: 五类前缀;$llm_acct 变量 (NOCACHEABLE) 账号级负载统计(问题发现与跟踪) - 新增 uda:<slot>:<idx>:<day>(请求/token)与 uex:(耗尽次数) 日桶, 复用内核 usage::bump_day —— 无数据库、无新进程(项目红线) - 计数点只在 log 阶段一次;pick_account 会被 $llm_target/$llm_auth/$llm_acct 三个变量各触发一次,放进那里会三倍计数 - view() 投影带每账号 load 与 account_trend + trend_labels(日期由后端算) - 管理台「上游」页密钥列:各 Key 今日请求/token/耗尽 + 负载比例条 + 14 天迷你趋势(自绘 SVG,零第三方依赖)+ 冷却/耗尽徽标 + 上游合计 测试与验证 - 回归 279 条全绿(网关 102 + LLM 177),新增 6 条多账号/负载断言 - 假上游新增 UPSTREAM_FAIL_AUTH 模拟账号额度耗尽;靶机验证 Key 真被替换 - 前端以真实 admin.css + upstreams.js 渲染路径做无头浏览器断言: 比例条与负载成比例(412 vs 96 → 100%/23%)、每账号 14 条块、 悬停峰值日期与数据逐位吻合、单账号/无账号兜底正常、无横向溢出、零 JS 错误 文档 - 新增 docs/llm/MULTI_ACCOUNT_ROUTING.md(数据模型/路由/冷却数学/shm 布局/负载统计) - readme §11 数据模型 + §15 上游配置 + §15 用量统计 + §12.6 tag 表 + §16 变更记录 - 修正 docs/llm/*.md 中插件化前的过时路径(rust/src/* → crates/plugin-llm/src/*)
This commit is contained in:
1 parent
db99ce1521
commit
bfa3cf8ff8
21 files changed
+1506
-85
No files matched your search
@@ -79,6 +79,32 @@ fn h_admin_upstream_save(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
|
||||
// 分隔符同时接受换行/逗号/顿号/分号——粘一份厂商文档里的模型列表是常见操作。
|
||||
let models = p.get("models").map(|raw| parse_model_list(raw));
|
||||
|
||||
// 多账号:前端把 `accounts` 作为 JSON 数组串传上来(每个 {auth, note, resets})。
|
||||
// 缺省/空 = 沿用旧逻辑(用 `auth` 维护单账号)。
|
||||
let accounts = p
|
||||
.get("accounts")
|
||||
.and_then(|s| {
|
||||
let s = s.trim();
|
||||
if s.is_empty() {
|
||||
None
|
||||
} else {
|
||||
serde_json::from_str::<Vec<crate::models::UpstreamAccount>>(s).ok()
|
||||
}
|
||||
});
|
||||
|
||||
// 上游级「额度耗尽」探测配置(JSON 数组;也兼容逗号串)
|
||||
let exhaust_status = parse_int_list(p.get("exhaust_status"));
|
||||
let exhaust_markers = p
|
||||
.get("exhaust_markers")
|
||||
.and_then(|s| {
|
||||
let s = s.trim();
|
||||
if s.is_empty() {
|
||||
None
|
||||
} else {
|
||||
serde_json::from_str::<Vec<String>>(s).ok()
|
||||
}
|
||||
});
|
||||
|
||||
let slot_raw = p.get("slot").map(String::as_str).unwrap_or("");
|
||||
|
||||
match upstreams::upsert(
|
||||
@@ -86,6 +112,9 @@ fn h_admin_upstream_save(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
|
||||
p.get("base").map(String::as_str).unwrap_or(""),
|
||||
models,
|
||||
p.get("auth"),
|
||||
accounts,
|
||||
exhaust_status,
|
||||
exhaust_markers,
|
||||
enabled,
|
||||
p.get("note"),
|
||||
) {
|
||||
@@ -93,7 +122,8 @@ fn h_admin_upstream_save(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
|
||||
// 用校验后的 slot 回显;直接拿原始入参会把大小写差异带进响应
|
||||
let slot = upstreams::validate_slot(slot_raw).unwrap_or_default();
|
||||
util::log_notice(&format!(
|
||||
"[api] 保存 LLM 上游 {slot} enabled={enabled} models={}",
|
||||
"[api] 保存 LLM 上游 {slot} enabled={enabled} accounts={} models={}",
|
||||
up.effective_accounts().len(),
|
||||
up.models.len()
|
||||
));
|
||||
// base_url 带「调用方正在用的端口」:见 upstreams::base_url 的说明
|
||||
@@ -103,6 +133,23 @@ fn h_admin_upstream_save(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
|
||||
}
|
||||
}
|
||||
|
||||
/// 解析整数列表:优先 JSON 数组,回退逗号分隔串。
|
||||
fn parse_int_list(raw: Option<&String>) -> Option<Vec<i64>> {
|
||||
let s = raw?;
|
||||
let s = s.trim();
|
||||
if s.is_empty() {
|
||||
return None;
|
||||
}
|
||||
if let Ok(v) = serde_json::from_str::<Vec<i64>>(s) {
|
||||
return Some(v);
|
||||
}
|
||||
Some(
|
||||
s.split(',')
|
||||
.filter_map(|x| x.trim().parse::<i64>().ok())
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
|
||||
/// 把管理台/接口传入的模型列表串拆成模型名数组。
|
||||
///
|
||||
/// 允许的写法(混用也认):`a,b` / `a、b` / `a;b` / 一行一个。
|
||||
|
||||
@@ -44,6 +44,20 @@ pub const KEY_UDAY_USER_PREFIX: &[u8] = b"udu:";
|
||||
/// (apix 的 slug 带 `api/` 前缀共用这片键空间,见 core config 的 APIX_STATS_PREFIX)
|
||||
pub const KEY_UDAY_SLOT_PREFIX: &[u8] = b"uds:";
|
||||
|
||||
/// 键前缀:上游**账号级**日桶(负载分布)。键 = `uda:<slot>:<idx>:<日窗id>`,
|
||||
/// value = DayBucket(requests = 转发到该账号的请求数,tin/tout = 该账号 token 消耗)。
|
||||
/// 与 `uds:`(slot 级)同构、多一维账号下标——「各上游 Key 负载」就靠它,
|
||||
/// 无需数据库(项目红线)。TTL 90 天自然淘汰。
|
||||
pub const KEY_UDAY_ACCT_PREFIX: &[u8] = b"uda:";
|
||||
|
||||
/// 键前缀:上游账号**额度耗尽次数**日桶。键 = `uex:<slot>:<idx>:<日窗id>`,
|
||||
/// value = DayBucket(requests = 该账号被判定额度耗尽并冷却的次数)。
|
||||
/// 仅作问题发现指标、不参与路由——哪把 Key 频繁撞额度一眼可见。TTL 90 天。
|
||||
pub const KEY_UEX_PREFIX: &[u8] = b"uex:";
|
||||
|
||||
/// 管理台账号级负载迷你趋势的展示天数(与项目 `uds:` 趋势的默认 14 天一致)。
|
||||
pub const ACCT_TREND_DAYS: i64 = 14;
|
||||
|
||||
/// 键前缀:LLM **上游健康缓存**。键 = `uh:<slot>`,
|
||||
/// value = `<1|0> \n <上游状态码> \n <记录时刻>`。
|
||||
///
|
||||
@@ -54,6 +68,61 @@ pub const KEY_UDAY_SLOT_PREFIX: &[u8] = b"uds:";
|
||||
/// 最多容忍客户端中途断连导致的误标(下一次真实转发即纠正)。
|
||||
pub const KEY_UH_PREFIX: &[u8] = b"uh:";
|
||||
|
||||
// ===========================================================================
|
||||
// 多账号路由(一个 slot 挂多个上游账号,粘性绑定 + 额度耗尽自动切换)
|
||||
// ===========================================================================
|
||||
|
||||
/// 键前缀:上游账号静态配置。键 = `upa:<slot>:<idx>`,
|
||||
/// value = `<auth> \n <resets csv>`(`resets` 为空则第二段为空)。
|
||||
///
|
||||
/// `auth` 是完整 Authorization 头值;`resets` 是该账号额度重置周期(秒,逗号分隔)。
|
||||
/// 与 `up:` 拆开存,是因为账号是热路径要枚举的对象、而 `up:` 只存 base + 账号数,
|
||||
/// 避免一次大 payload 反序列化;账号数记在 `up:<slot>` 第二段,热路径据此循环读取。
|
||||
pub const KEY_UPA_PREFIX: &[u8] = b"upa:";
|
||||
|
||||
/// 键前缀:上游账号「额度耗尽」冷却(**运行时状态**,非配置)。
|
||||
/// 键 = `uac:<slot>:<idx>`,value = `<exhausted_until>`(绝对秒)。
|
||||
///
|
||||
/// 写入时 `expires_at` 直接设为 `exhausted_until`——共享内存到期即视为不再冷却,
|
||||
/// 「额度恢复」是天然发生的,无需额外清扫。log 阶段在检测到耗尽时写;
|
||||
/// 热路径 `pick_account` 用 `get_live` 判定「该账号当前是否在冷却」。
|
||||
pub const KEY_UAC_PREFIX: &[u8] = b"uac:";
|
||||
|
||||
/// 键前缀:用户 key → 上游账号 粘性绑定。键 = `ukb:<downstream_key>`,
|
||||
/// value = `<acct_idx>`(usize 字符串)。
|
||||
///
|
||||
/// 带 TTL(取该账号最长重置周期,或兜底 7 天),**尽力粘性**:重启后丢失、重新绑定,
|
||||
/// 符合「尽可能同一用户 key 用同一上游 key」的语义。只有真正选了账号且拿到下行 key
|
||||
/// 时才写;内部测试 location(无下行 key)不写,避免污染绑定表。
|
||||
pub const KEY_UKB_PREFIX: &[u8] = b"ukb:";
|
||||
|
||||
/// 键前缀:上游级「额度耗尽」探测配置。键 = `upe:<slot>`,
|
||||
/// value = `<status csv> \n <markers json>`(`markers` 是 JSON 字符串数组)。
|
||||
///
|
||||
/// slot 级(同一厂商所有账号共享错误形态),由 `sync_shm` 写、body filter 与 log 阶段读。
|
||||
pub const KEY_UPE_PREFIX: &[u8] = b"upe:";
|
||||
|
||||
/// 默认「额度耗尽」HTTP 状态码(命中即判该账号额度耗尽并冷却)。
|
||||
///
|
||||
/// 402/429/403 是主流厂商表达「配额/额度/权限不足」的常态;5xx 与连接失败(502/504)
|
||||
/// 视为机器/链路问题、**不**算额度耗尽(否则单台抖动会把整池账号都冷却掉)。
|
||||
pub const EXHAUST_STATUS_DEFAULT: &[i64] = &[402, 429, 403];
|
||||
|
||||
/// 账号冷却默认下限(秒):`resets` 全空时仍给一个兜底冷却,避免单账号被瞬间连续打死。
|
||||
/// 实际冷却 = `min(resets)`,`resets` 空则用此值(4 小时,对齐 MiniMax「每 4 小时清零」口径)。
|
||||
pub const ACCT_COOLDOWN_DEFAULT: i64 = 4 * 3600;
|
||||
|
||||
/// 粘性绑定 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`)。
|
||||
/// 其他时区的厂商改这里(如 UTC 设 `0`)。
|
||||
pub const RESET_DAY_OFFSET_SEC: i64 = 28800;
|
||||
|
||||
// ===========================================================================
|
||||
// 趋势
|
||||
// ===========================================================================
|
||||
|
||||
@@ -131,20 +131,34 @@ impl HttpRequestHandler for LlmHandler {
|
||||
/// `$upstream_status` 的变量索引,postconfiguration 时解析一次(log 阶段复用)。
|
||||
static UPSTREAM_STATUS_IDX: AtomicIsize = AtomicIsize::new(-1);
|
||||
|
||||
/// postconfiguration:预取 `$upstream_status` 变量索引(upstream 模块的
|
||||
/// preconfiguration 已注册该内建变量,此阶段取 index 一定成功)。
|
||||
/// `$llm_acct` 的变量索引(本插件注册),log 阶段读它拿到「本次请求打到的上游账号下标」,
|
||||
/// 用于额度耗尽时精确标记那一个账号进入冷却。postconfiguration 时解析一次。
|
||||
static LLM_ACCT_IDX: AtomicIsize = AtomicIsize::new(-1);
|
||||
|
||||
/// postconfiguration:预取 `$upstream_status` 与 `$llm_acct` 变量索引。
|
||||
/// 失败返回 false,gateway 会 EMERG 退出。
|
||||
pub fn prefetch_upstream_status_index(cf: *mut ngx_conf_t) -> bool {
|
||||
let mut name = ngx_str_t {
|
||||
let mut status_name = ngx_str_t {
|
||||
len: "upstream_status".len() as usize,
|
||||
data: b"upstream_status\0".as_ptr() as *mut u8,
|
||||
};
|
||||
// SAFETY: cf 由 nginx 传入且有效;name 指向栈上合法 ngx_str_t
|
||||
let idx = unsafe { ngx_http_get_variable_index(cf, &mut name) };
|
||||
if idx == -1 {
|
||||
let sidx = unsafe { ngx_http_get_variable_index(cf, &mut status_name) };
|
||||
if sidx == -1 {
|
||||
return false;
|
||||
}
|
||||
UPSTREAM_STATUS_IDX.store(idx as isize, Ordering::Relaxed);
|
||||
UPSTREAM_STATUS_IDX.store(sidx as isize, Ordering::Relaxed);
|
||||
|
||||
let mut acct_name = ngx_str_t {
|
||||
len: "llm_acct".len() as usize,
|
||||
data: b"llm_acct\0".as_ptr() as *mut u8,
|
||||
};
|
||||
// SAFETY: 同上;本插件已在 preconfiguration 用 add_var 注册过 llm_acct
|
||||
let aidx = unsafe { ngx_http_get_variable_index(cf, &mut acct_name) };
|
||||
if aidx == -1 {
|
||||
return false;
|
||||
}
|
||||
LLM_ACCT_IDX.store(aidx as isize, Ordering::Relaxed);
|
||||
true
|
||||
}
|
||||
|
||||
@@ -210,15 +224,60 @@ impl HttpRequestHandler for LlmHealthHandler {
|
||||
}
|
||||
|
||||
if let Some(slot) = llm::slot_of(r) {
|
||||
let now = util::now();
|
||||
// 上游回了头 = 它活着:2xx~4xx 都算正常(4xx 是它对我们请求的意见,
|
||||
// 不是机器死了);5xx / 连接失败(502) / 等头超时(504) 才算失效
|
||||
upstreams::mark_health(&slot, (200..500).contains(&code), code);
|
||||
|
||||
// 账号级负载:每次真实转发都记到选中的上游账号(负载分布 / 问题发现)。
|
||||
// 只在这里记一次(read_llm_acct 触发一次 pick_account),绝不放在
|
||||
// pick_account 里——否则 $llm_target/$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`
|
||||
// (流式也能扫到)。
|
||||
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::bump_acct_exhaust(&slot, idx, now);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Status::NGX_DECLINED
|
||||
}
|
||||
}
|
||||
|
||||
/// 从 `$llm_acct` 索引读本次请求选中的上游账号下标(NOCACHEABLE,读时重算,确定一致)。
|
||||
///
|
||||
/// 读不到(未求值/解析失败)返回 None——不标记,避免误伤。
|
||||
fn read_llm_acct(r: *mut ngx_http_request_t) -> Option<usize> {
|
||||
let idx = LLM_ACCT_IDX.load(Ordering::Relaxed);
|
||||
if idx < 0 {
|
||||
return None;
|
||||
}
|
||||
// SAFETY: 索引在 postconfiguration 已解析;变量为 NOCACHEABLE,读即触发 get_handler
|
||||
unsafe {
|
||||
let v = ngx_http_get_indexed_variable(r, idx as ngx_uint_t);
|
||||
if v.is_null() || (*v).not_found() != 0 || (*v).data.is_null() {
|
||||
return None;
|
||||
}
|
||||
let s = core::str::from_utf8(core::slice::from_raw_parts(
|
||||
(*v).data,
|
||||
(*v).len() as usize,
|
||||
))
|
||||
.ok()?;
|
||||
s.trim().parse::<usize>().ok()
|
||||
}
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// log 阶段:对话审计 + token 入账
|
||||
// ===========================================================================
|
||||
@@ -254,6 +313,11 @@ impl HttpRequestHandler for AuditHandler {
|
||||
if let Some(name) = user.as_deref() {
|
||||
stats::add_tokens(name, &slot, tin, tout, util::now());
|
||||
}
|
||||
// 账号级 token 负载(与账号级请求数同一个日桶维度 uda:)
|
||||
let now = util::now();
|
||||
if let Some(idx) = read_llm_acct(r) {
|
||||
upstreams::add_acct_tokens(&slot, idx, tin as i64, tout as i64, now);
|
||||
}
|
||||
}
|
||||
|
||||
// SAFETY: 同上;capture 内部任何失败只记日志,绝不 panic
|
||||
|
||||
@@ -39,7 +39,7 @@ use serde_json::json;
|
||||
|
||||
use crate::config;
|
||||
use crate::upstreams;
|
||||
use ipass_core::{http, state, util};
|
||||
use ipass_core::{auth, http, state, util};
|
||||
|
||||
// ===========================================================================
|
||||
// 变量分派标记
|
||||
@@ -54,12 +54,15 @@ pub const VAR_TARGET: usize = 1;
|
||||
pub const VAR_HOST: usize = 2;
|
||||
/// `$llm_auth`:上游 Authorization 头值
|
||||
pub const VAR_AUTH: usize = 3;
|
||||
/// `$llm_acct`:本次请求选中的上游账号下标(多账号路由用;log 阶段据此标记耗尽)。
|
||||
/// 由 `pick_account` 在变量求值时计算(与 `$llm_auth` 同源,保证一致)。
|
||||
pub const VAR_ACCT: usize = 4;
|
||||
|
||||
// ===========================================================================
|
||||
// preconfiguration:注册变量
|
||||
// ===========================================================================
|
||||
|
||||
/// 注册 LLM 三件套只读变量(gateway preconfiguration 经插件循环调用)。
|
||||
/// 注册 LLM 四件套只读变量(gateway preconfiguration 经插件循环调用)。
|
||||
///
|
||||
/// 名字里的 `llm_` 前缀不要省:nginx 变量名全局唯一,
|
||||
/// 将来接入别的模块时才不会撞名。
|
||||
@@ -70,10 +73,12 @@ pub unsafe fn preconfig(cf: *mut ngx_conf_t) -> bool {
|
||||
let mut target = ngx_string!("llm_target");
|
||||
let mut host = ngx_string!("llm_host");
|
||||
let mut auth_var = ngx_string!("llm_auth");
|
||||
let mut acct_var = ngx_string!("llm_acct");
|
||||
unsafe {
|
||||
add_var(cf, &raw mut target, VAR_TARGET)
|
||||
&& add_var(cf, &raw mut host, VAR_HOST)
|
||||
&& add_var(cf, &raw mut auth_var, VAR_AUTH)
|
||||
&& add_var(cf, &raw mut acct_var, VAR_ACCT)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -308,11 +313,14 @@ unsafe fn set_value(
|
||||
Status::NGX_OK.into()
|
||||
}
|
||||
|
||||
/// 三个 LLM 变量共用一个 get_handler,靠 `var.data` 分派(值由 `preconfiguration` 写入)。
|
||||
/// 四个 LLM 变量共用一个 get_handler,靠 `var.data` 分派(值由 `preconfiguration` 写入)。
|
||||
///
|
||||
/// 共用的代价是每个变量各查一次共享内存:一次读锁 + 一次 BTreeMap 查找 +
|
||||
/// 一次小分配,量级在微秒以内,相对一次 LLM 推理完全可忽略;
|
||||
/// 换来的是不必维护三份几乎相同的代码。
|
||||
/// 共用代价:每个变量各调一次 `pick_account`(一次读锁 + 几次 BTreeMap 查找 + 一次
|
||||
/// 小分配,微秒级),相对一次 LLM 推理完全可忽略;换来不必维护四份相近代码。
|
||||
///
|
||||
/// `$llm_acct` 的求值会顺带把「用户 key → 账号」粘性绑定写进共享内存
|
||||
/// (仅当下行 key 存在且绑定变化),是幂等副作用。log 阶段读取 `$llm_acct` 即得到
|
||||
/// 本次请求实际打到的账号下标(用于额度耗尽时精确标记那一个账号)。
|
||||
pub extern "C" fn var_get(
|
||||
r: *mut ngx_http_request_t,
|
||||
v: *mut ngx_http_variable_value_t,
|
||||
@@ -320,21 +328,29 @@ pub extern "C" fn var_get(
|
||||
) -> ngx_int_t {
|
||||
// SAFETY: r/v 由 nginx 传入且有效;slot_of/upstream_uri 只读请求结构
|
||||
unsafe {
|
||||
let resolved = (|| -> Option<String> {
|
||||
let resolved = (|| -> Option<(String, String, String, usize)> {
|
||||
let slot = slot_of(r)?;
|
||||
// up:<slot> payload = `base \n auth`(见 upstreams::split_payload)
|
||||
let (payload, _) = state::get(config::KEY_UP_PREFIX, slot.as_bytes())?;
|
||||
let (base, auth) = upstreams::split_payload(&payload);
|
||||
Some(match data {
|
||||
VAR_TARGET => join_target(base, &upstream_uri(r)),
|
||||
VAR_HOST => host_of(base).to_owned(),
|
||||
VAR_AUTH => auth.to_owned(),
|
||||
_ => return None,
|
||||
})
|
||||
let key = auth::downstream_key(r);
|
||||
let now = util::now();
|
||||
// 选账号:粘性绑定 + 跳过冷却中账号,返回 (下标, auth, base)
|
||||
let (idx, auth, base) = upstreams::pick_account(&slot, key.as_deref(), now)?;
|
||||
let target = join_target(&base, &upstream_uri(r));
|
||||
let host = host_of(&base).to_owned();
|
||||
Some((target, host, auth, idx))
|
||||
})();
|
||||
|
||||
match resolved {
|
||||
Some(value) => set_value(r, v, &value),
|
||||
Some((target, host, auth, idx)) => {
|
||||
// 四个分支各取一个字段(只有命中分支的 String 被移动出去)
|
||||
let value = match data {
|
||||
VAR_TARGET => target,
|
||||
VAR_HOST => host,
|
||||
VAR_AUTH => auth,
|
||||
VAR_ACCT => idx.to_string(),
|
||||
_ => return Status::NGX_ERROR.into(),
|
||||
};
|
||||
set_value(r, v, &value)
|
||||
}
|
||||
None => {
|
||||
(*v).set_not_found(1);
|
||||
(*v).set_valid(0);
|
||||
|
||||
@@ -3,15 +3,39 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use crate::config::EXHAUST_STATUS_DEFAULT;
|
||||
|
||||
/// 上游表:`slot` 就是 LLM 客户端 URL 的第一段路径:`/openai/v1/chat/completions`
|
||||
/// 里的 `openai`。**刻意不按 body 里的 `model` 字段路由**——请求体要到
|
||||
/// content 阶段才读得到,而 access 阶段(转发决策点)读不到,
|
||||
/// 按 model 分流就得放弃 `proxy_pass` 自己实现 upstream,代价差一个数量级。
|
||||
pub type UpstreamTable = BTreeMap<String, Upstream>;
|
||||
|
||||
/// 单个上游账号:一把上游真 Key + 它的额度重置周期。
|
||||
///
|
||||
/// 一个 `slot`(一家厂商)可挂多个账号——不同账号通常是同一厂商的多把免费/付费 Key,
|
||||
/// 各自有独立的周期性额度。网关按「用户 key → 上游账号」做粘性路由,账号额度耗尽时
|
||||
/// 自动切到同厂商下一个可用账号(见 `upstreams::pick_account` 与 `handlers` 的耗尽标记)。
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct UpstreamAccount {
|
||||
/// 完整的 Authorization 头值,如 `Bearer sk-xxx`
|
||||
pub auth: String,
|
||||
/// 备注(区分多账号用,如 `minimax-周额度` / `minimax-4h额度`)
|
||||
#[serde(default)]
|
||||
pub note: String,
|
||||
/// 该账号额度重置周期(秒)。如 MiniMax = `[604800, 14400]`(每周 + 每 4 小时)。
|
||||
///
|
||||
/// 空 = 不配置重置窗口:额度耗尽后给一个兜底冷却(见 `config::ACCT_COOLDOWN_DEFAULT`),
|
||||
/// 仍参与轮换,避免单账号被瞬间连续打死。
|
||||
#[serde(default)]
|
||||
pub resets: Vec<i64>,
|
||||
}
|
||||
|
||||
/// 单个 LLM 上游。
|
||||
///
|
||||
/// 字段名与旧版 `data/llm-upstreams.json` **逐字对应**,以便新版直接接管旧数据文件。
|
||||
/// 旧文件只有顶层 `auth`(单账号),新版通过 `effective_accounts()` 自动合成单账号,
|
||||
/// 因此存量数据零改动即可继续工作。
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct Upstream {
|
||||
/// 上游基址,含 scheme,如 `https://api.openai.com`(可带端口)
|
||||
@@ -24,10 +48,6 @@ pub struct Upstream {
|
||||
/// 留空表示"清单未知"——模型发现接口就不列该上游的模型,但转发照常可用。
|
||||
#[serde(default)]
|
||||
pub models: Vec<String>,
|
||||
/// 完整的 Authorization 头值,如 `Bearer sk-xxx`。
|
||||
/// 留空表示不透传鉴权头(本地免鉴权后端,如 vLLM / Ollama)
|
||||
#[serde(default)]
|
||||
pub auth: String,
|
||||
/// 关闭后该 slot 立即停止转发(保留配置便于恢复)
|
||||
#[serde(default = "default_true")]
|
||||
pub enabled: bool,
|
||||
@@ -35,8 +55,55 @@ pub struct Upstream {
|
||||
pub note: String,
|
||||
#[serde(default)]
|
||||
pub created_at: i64,
|
||||
/// 多账号列表。空时由 legacy `auth` 合成单账号(向后兼容旧数据)。
|
||||
#[serde(default)]
|
||||
pub accounts: Vec<UpstreamAccount>,
|
||||
/// 上游级「额度耗尽」探测配置(同一厂商所有账号共享错误形态)。
|
||||
///
|
||||
/// 命中下列任一即判该账号额度耗尽、进入冷却:上游返回这些 HTTP 状态码,
|
||||
/// **或** 响应体(流式也能扫,见 `usage_filter`)含任一 `exhaust_markers` 子串。
|
||||
/// 空 = 用 `config::EXHAUST_STATUS_DEFAULT`(默认 `[402, 429, 403]`)。
|
||||
#[serde(default)]
|
||||
pub exhaust_status: Vec<i64>,
|
||||
/// 响应体「额度耗尽」标记子串(大小写敏感,逐字节匹配)。
|
||||
/// 例:MiniMax 余额不足可配 `"status_code":1004` 或 `余额不足`。
|
||||
#[serde(default)]
|
||||
pub exhaust_markers: Vec<String>,
|
||||
/// 兼容旧版单 key 数据:旧 `auth` 字段。
|
||||
/// `accounts` 非空时忽略;`accounts` 空且 `auth` 非空 → 合成单账号(resets 空 = 不自动切换)。
|
||||
#[serde(default)]
|
||||
pub auth: String,
|
||||
}
|
||||
|
||||
fn default_true() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
impl Upstream {
|
||||
/// 实际生效的账号列表。
|
||||
///
|
||||
/// `accounts` 非空 → 用它;否则 `auth` 非空 → 合成单账号(resets 空,等同无限额度,
|
||||
/// 不会因「耗尽」被冷却,单账号时自然也不存在可切换对象)。两者皆空 → 空表(上游不可用)。
|
||||
pub fn effective_accounts(&self) -> Vec<UpstreamAccount> {
|
||||
if !self.accounts.is_empty() {
|
||||
self.accounts.clone()
|
||||
} else if !self.auth.is_empty() {
|
||||
vec![UpstreamAccount {
|
||||
auth: self.auth.clone(),
|
||||
note: String::new(),
|
||||
resets: Vec::new(),
|
||||
}]
|
||||
} else {
|
||||
Vec::new()
|
||||
}
|
||||
}
|
||||
|
||||
/// 生效的「额度耗尽」状态码清单(空 → 默认 `[402, 429, 403]`)。
|
||||
pub fn effective_exhaust_status(&self) -> Vec<i64> {
|
||||
if self.exhaust_status.is_empty() {
|
||||
EXHAUST_STATUS_DEFAULT.to_vec()
|
||||
} else {
|
||||
self.exhaust_status.clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -16,13 +16,16 @@
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use crate::config::{
|
||||
KEY_UH_PREFIX, KEY_UP_PREFIX, MODEL_NAME_MAX_LEN, UPSTREAM_BASE_MAX_LEN,
|
||||
UPSTREAM_MODELS_MAX, UPSTREAM_SLOT_MAX_LEN,
|
||||
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;
|
||||
use crate::models::{Upstream, UpstreamAccount};
|
||||
use crate::store;
|
||||
use ipass_core::config::LLM_PUBLIC_HOST;
|
||||
use ipass_core::{state, util};
|
||||
use ipass_core::{state, usage, util};
|
||||
|
||||
/// 共享内存 payload 的内部分隔符:base 与 auth 之间。
|
||||
///
|
||||
@@ -117,40 +120,135 @@ pub fn validate_base(raw: &str) -> Result<String, String> {
|
||||
// 共享内存同步(写穿 / 装载)
|
||||
// ===========================================================================
|
||||
|
||||
/// 一个 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`)时是**删除**而不是写入空值——热路径
|
||||
/// 「查不到 = 不可用」,这样停用即刻生效,且不留残留条目。
|
||||
/// 关闭(`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 {
|
||||
if !state::put(KEY_UP_PREFIX, slot.as_bytes(), payload_of(up).as_bytes(), 0) {
|
||||
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} —— 该上游会 404(共享内存可能已满)"
|
||||
"[upstreams] 上游账号写共享内存失败 slot={slot}#{i} —— 该账号会 404"
|
||||
));
|
||||
}
|
||||
} else {
|
||||
state::remove(KEY_UP_PREFIX, slot.as_bytes());
|
||||
}
|
||||
// 清掉被删/被减的账号下标(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());
|
||||
}
|
||||
}
|
||||
|
||||
fn payload_of(up: &Upstream) -> String {
|
||||
format!("{}{}{}", up.base, PAYLOAD_SEP, up.auth)
|
||||
/// 删除一个 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:` 前缀,不会误伤转发映射与管理会话。
|
||||
/// 清 `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 {
|
||||
expected += 1;
|
||||
if !up.enabled {
|
||||
continue;
|
||||
}
|
||||
if up.enabled && state::put(KEY_UP_PREFIX, slot.as_bytes(), payload_of(&up).as_bytes(), 0) {
|
||||
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!(
|
||||
@@ -160,16 +258,324 @@ pub fn reload_shm() -> usize {
|
||||
loaded
|
||||
}
|
||||
|
||||
/// 拆 payload:`base \n auth` → `(base, auth)`。
|
||||
/// 读 `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))
|
||||
}
|
||||
|
||||
/// 读 `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((auth.to_owned(), 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()
|
||||
}
|
||||
|
||||
/// 标记某账号额度耗尽,进入冷却直到「下一个重置边界」。
|
||||
///
|
||||
/// 无分隔符时视为「只有 base、无鉴权头」——兼容手工编辑文件时漏写分隔的情况。
|
||||
pub fn split_payload(payload: &str) -> (&str, &str) {
|
||||
match payload.split_once(PAYLOAD_SEP) {
|
||||
Some((b, a)) => (b, a),
|
||||
None => (payload, ""),
|
||||
/// 重置窗口**锚定到「天」边界**(不是从 `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
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// 查询
|
||||
// ===========================================================================
|
||||
@@ -256,14 +662,23 @@ pub fn models_flat(allowed: &[String]) -> Vec<(String, String)> {
|
||||
|
||||
/// 新增或覆盖一个上游。
|
||||
///
|
||||
/// `auth = None` 表示**保持原值**(表单只改 base 时不必回填密钥);
|
||||
/// `Some("")` 表示显式清空。`models = None` 同款语义(保持原清单)。
|
||||
/// `enabled = false` 会立刻从共享内存移除。
|
||||
/// 参数语义(兼容旧调用方,同时支持多账号):
|
||||
/// * `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> {
|
||||
@@ -279,10 +694,37 @@ pub fn upsert(
|
||||
// 先克隆出来:下面 insert 需要可变借用,不能与这里的不可变借用并存
|
||||
let existing = table.get(&key).cloned();
|
||||
|
||||
let auth = match auth_raw {
|
||||
Some(a) => util::trim(a).to_owned(),
|
||||
None => existing.as_ref().map(|e| e.auth.clone()).unwrap_or_default(),
|
||||
// 多账号:整体替换(清掉顶层 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();
|
||||
}
|
||||
}
|
||||
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(),
|
||||
@@ -291,13 +733,37 @@ pub fn upsert(
|
||||
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, auth, enabled, note, created_at };
|
||||
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)
|
||||
})?;
|
||||
@@ -330,11 +796,42 @@ pub fn remove(slot_raw: &str) -> Result<String, String> {
|
||||
///
|
||||
/// **绝不回显完整 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,
|
||||
@@ -342,10 +839,15 @@ pub fn view(slot: &str, up: &Upstream, port: &str) -> Value {
|
||||
"anthropic_base_url": anthropic_base_url(slot, up, port),
|
||||
"models": up.models,
|
||||
"model_count": up.models.len(),
|
||||
"auth_set": !up.auth.is_empty(),
|
||||
"auth_mask": if up.auth.is_empty() { "-".to_owned() } else { util::mask_key(&up.auth) },
|
||||
"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,
|
||||
@@ -355,6 +857,31 @@ pub fn view(slot: &str, up: &Upstream, port: &str) -> Value {
|
||||
})
|
||||
}
|
||||
|
||||
/// 把重置周期数组渲染成人类可读文本,如 `[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()
|
||||
}
|
||||
|
||||
@@ -41,6 +41,9 @@ use ngx::ffi::{ngx_chain_t, ngx_http_request_t, ngx_int_t};
|
||||
use ipass_core::loc::{self, Switch};
|
||||
use ipass_core::plugin;
|
||||
|
||||
use crate::llm;
|
||||
use crate::upstreams;
|
||||
|
||||
/// 尾部窗口容量:SSE 最终 usage 块 / 非 stream JSON 的尾部都远小于此。
|
||||
const TAIL_CAP: usize = 32 * 1024;
|
||||
|
||||
@@ -146,12 +149,25 @@ fn last_u64(hay: &[u8], keys: &[&[u8]]) -> Option<u64> {
|
||||
// per-request 扫描窗口(挂在模块 ctx 上,请求池分配、随请求回收)
|
||||
// ===========================================================================
|
||||
|
||||
/// 内联缓存「额度耗尽」探测配置的上限(避免每 chunk 查 shm,且不引入堆分配/泄漏)。
|
||||
/// marker 最长 128 字节、最多 4 个,超出部分截断/忽略(v1 够用,详见 `take_exhausted`)。
|
||||
const MAX_MARKERS: usize = 4;
|
||||
const MARKER_CAP: usize = 128;
|
||||
|
||||
#[repr(C)]
|
||||
struct ScanCtx {
|
||||
tail: [u8; TAIL_CAP],
|
||||
len: usize,
|
||||
tin: u64,
|
||||
tout: u64,
|
||||
/// 响应体命中「额度耗尽」标记(流式也能扫到,log 阶段据此标记账号冷却)
|
||||
exhausted: bool,
|
||||
/// 内联缓存的耗尽探测配置(首次扫描时从 `upe:<slot>` 读入,随请求池整体回收)
|
||||
status: [i64; 8],
|
||||
status_n: usize,
|
||||
markers: [[u8; MARKER_CAP]; MAX_MARKERS],
|
||||
marker_len: [usize; MAX_MARKERS],
|
||||
marker_n: usize,
|
||||
}
|
||||
|
||||
impl ScanCtx {
|
||||
@@ -243,8 +259,28 @@ unsafe fn scan(r: *mut ngx_http_request_t, in_: *mut ngx_chain_t) {
|
||||
}
|
||||
*slot = p;
|
||||
ctx = p;
|
||||
// 首次扫描:从 `upe:<slot>` 读入耗尽探测配置(状态码 + 响应体标记)
|
||||
let c = &mut *ctx;
|
||||
if let Some(s) = llm::slot_of(r) {
|
||||
let (status, markers) = upstreams::read_upe(&s);
|
||||
let n = status.len().min(c.status.len());
|
||||
c.status[..n].copy_from_slice(&status[..n]);
|
||||
c.status_n = n;
|
||||
let m = markers.len().min(MAX_MARKERS);
|
||||
for i in 0..m {
|
||||
let bytes = markers[i].as_bytes();
|
||||
let cap = bytes.len().min(MARKER_CAP);
|
||||
if cap > 0 {
|
||||
c.markers[i][..cap].copy_from_slice(&bytes[..cap]);
|
||||
c.marker_len[i] = cap;
|
||||
}
|
||||
}
|
||||
c.marker_n = m;
|
||||
}
|
||||
}
|
||||
|
||||
// ctx 此刻一定非 null 且指向有效内存;用 &mut 引用操作,避免裸指针隐式自动取引用报错
|
||||
let c = &mut *ctx;
|
||||
let mut cl = in_;
|
||||
while !cl.is_null() {
|
||||
let buf = (*cl).buf;
|
||||
@@ -256,10 +292,26 @@ unsafe fn scan(r: *mut ngx_http_request_t, in_: *mut ngx_chain_t) {
|
||||
if !pos.is_null() && !last.is_null() && last > pos {
|
||||
// SAFETY: 内存 buf 的 pos..last 由 nginx 保证有效
|
||||
let data = slice::from_raw_parts(pos, last as usize - pos as usize);
|
||||
(*ctx).append(data);
|
||||
c.append(data);
|
||||
// 扫「额度耗尽」标记(逐字节子串匹配,流式响应也能命中)
|
||||
if !c.exhausted && c.marker_n > 0 {
|
||||
for i in 0..c.marker_n {
|
||||
let ml = c.marker_len[i];
|
||||
if ml == 0 {
|
||||
continue;
|
||||
}
|
||||
let needle = &c.markers[i][..ml];
|
||||
if data.len() >= needle.len()
|
||||
&& data.windows(needle.len()).any(|w| w == needle)
|
||||
{
|
||||
c.exhausted = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (*buf).last_buf() != 0 {
|
||||
(*ctx).finish();
|
||||
c.finish();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -282,3 +334,25 @@ pub fn take(r: *mut ngx_http_request_t) -> (u64, u64) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// log 阶段读取本请求响应体是否命中「额度耗尽」标记。
|
||||
///
|
||||
/// 与 [`take`] 同生命周期:ctx 随请求池回收,无需清理钩子。
|
||||
/// 仅 LLM location 的 body filter 会置位;其它请求恒为 false(靠状态码判定兜底)。
|
||||
pub fn take_exhausted(r: *mut ngx_http_request_t) -> bool {
|
||||
if r.is_null() {
|
||||
return false;
|
||||
}
|
||||
unsafe {
|
||||
let slot = ctx_slot(r);
|
||||
if slot.is_null() {
|
||||
return false;
|
||||
}
|
||||
let c = *slot;
|
||||
if c.is_null() {
|
||||
false
|
||||
} else {
|
||||
(*c).exhausted
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user