功能(本轮 5 项需求的落地):
- 上游可挂多模型:llm-upstreams.json 每上游新增 models 清单(仅用于模型发现,不参与路由)
- 模型发现:GET /v1/models(OpenAI {object:list} 形状,网关本地应答)+ /api/v1/models + /api/v1/upstreams
- 用量统计:/api/admin/usage(管理台「用量统计」Tab)+ /api/v1/usage + /me 的 llm_usage 摘要
口径:只统计真正转发出去的请求,401/403/404/429 不计;与配额计数 st: 刻意分开
- 账号展示名 display_name(纯展示,不进 ukey:)
- 修复 /v1 版本段重复拼接(llm::join_target)→ 上游 base 自带 /v1 时不再 404 空体
- 修复删账号未清用量键(stats::forget)
部署脚本 deploy/update-ipass.sh:
- 拉镜像 → tar 备份数据 → 删旧容器 → 按旧容器复刻端口/挂载/网络起新容器 → 自检
- 参数从 docker inspect 静态配置读取(docker port 对停止态容器返回空,会让端口静默回落)
- 端口按 host:container 去重(inspect 同一映射含 IPv4/IPv6 两项,重复 -p 会 address already in use)
- --bg 用 setsid/start_new_session 真正脱离会话(仅 nohup & 会被父进程组连带杀掉)
- 旧镜像自动打 rollback-<时间> 标签,收尾打印回滚命令
回归:bash tests/run.sh all → 网关 78 + LLM 75 = 153 条断言全绿。
文档:readme §12.4 / §15 / §16、CLAUDE.md 常用操作 + 排障速查已同步。
363 lines
14 KiB
Rust
363 lines
14 KiB
Rust
//! 共享内存状态层。
|
||
//!
|
||
//! 这是「配置放内存」的落点,替代旧版的 `lua_shared_dict proxy_cache /
|
||
//! admin_sessions / lua_locks` 三个字典。全部派生状态集中在一张
|
||
//! `RbTreeMap` 里,用键前缀区分用途:
|
||
//!
|
||
//! ```text
|
||
//! sub:<subdomain> → <backend> \x1f <expires_at> 转发映射
|
||
//! sess:<token> → <username> \x1f <expires_at> 管理会话
|
||
//! fail:<ip> → <count> \x1f <expires_at> 登录失败计数
|
||
//! ```
|
||
//!
|
||
//! ## 为什么过期时间写在 value 里,而不是靠字典的 TTL
|
||
//!
|
||
//! 旧版 `lua_shared_dict` 自带 `set(key, val, ttl)` 自动回收;`RbTreeMap`
|
||
//! 是纯数据结构,没有 TTL。因此把到期时刻编码进 value,读取时判断——
|
||
//! 语义上反而更精确(到期即失效,不受回收延迟影响)。
|
||
//!
|
||
//! ## 为什么锁必须放进共享内存
|
||
//!
|
||
//! nginx 是多进程模型。`RwLock` 若放在普通静态变量里,每个 worker 会持有
|
||
//! 各自的副本,跨进程互斥完全失效。锁与表都必须在 `ngx_shared_memory_add`
|
||
//! 创建的 slab 池里分配。
|
||
|
||
use core::ptr;
|
||
use core::sync::atomic::{AtomicPtr, Ordering};
|
||
|
||
use ngx::collections::RbTreeMap;
|
||
use ngx::core::{NgxStr, NgxString, SlabPool, Status};
|
||
use ngx::ffi::ngx_shm_zone_t;
|
||
use ngx::sync::{RwLock, RwLockWriteGuard};
|
||
|
||
use crate::config::{KEY_BUF_LEN, KEY_UP_PREFIX, KEY_UKEY_PREFIX, VAL_SEP};
|
||
|
||
/// 子域名 → 后端、token → 用户名等全部映射的底层容器
|
||
pub type ShmMap = RbTreeMap<NgxString<SlabPool>, NgxString<SlabPool>, SlabPool>;
|
||
|
||
/// 共享内存根对象:一张表 + 一把文件写锁。
|
||
///
|
||
/// 文件写锁**独立于表的读写锁**:文件 I/O 期间若持有表的写锁,
|
||
/// 会把所有转发请求(需要读锁)一起卡住。分开后,域名的热路径只受
|
||
/// 自身短临界区影响。
|
||
pub struct ShmRoot {
|
||
pub map: RwLock<ShmMap>,
|
||
/// 保护 `store` 的「读-改-写」与落盘,跨 worker 互斥
|
||
pub file_lock: RwLock<()>,
|
||
}
|
||
|
||
/// 由 `ipass_state <zone> <size>` 注册的共享内存区
|
||
static STATE_ZONE: AtomicPtr<ngx_shm_zone_t> = AtomicPtr::new(ptr::null_mut());
|
||
|
||
pub fn set_zone(zone: *mut ngx_shm_zone_t) {
|
||
STATE_ZONE.store(zone, Ordering::SeqCst);
|
||
}
|
||
|
||
/// 在 slab 池上构造 `ShmRoot` 并挂到 `shpool->data`;重复调用直接复用。
|
||
fn init_root(zone: &mut ngx_shm_zone_t) -> Result<&'static ShmRoot, Status> {
|
||
// SAFETY: zone 由 ngx_shared_memory_add 注册,init 回调已使其 shm 可用
|
||
let mut alloc = unsafe { SlabPool::from_shm_zone(zone) }.ok_or(Status::NGX_ERROR)?;
|
||
|
||
if alloc.as_mut().data.is_null() {
|
||
let map = ShmMap::try_new_in(alloc.clone()).map_err(|_| Status::NGX_ERROR)?;
|
||
let root = ShmRoot { map: RwLock::new(map), file_lock: RwLock::new(()) };
|
||
// 整块放进共享内存:两个锁与表必须对所有 worker 是同一份
|
||
let placed = ngx::allocator::allocate(root, &alloc).map_err(|_| Status::NGX_ERROR)?;
|
||
alloc.as_mut().data = placed.as_ptr().cast();
|
||
}
|
||
|
||
// SAFETY: data 非空即指向一个已初始化、且存活于共享内存的 ShmRoot
|
||
unsafe { alloc.as_ref().data.cast::<ShmRoot>().as_ref().ok_or(Status::NGX_ERROR) }
|
||
}
|
||
|
||
/// 取共享内存根对象;zone 未注册时返回 None
|
||
pub fn root() -> Option<&'static ShmRoot> {
|
||
let zone = STATE_ZONE.load(Ordering::SeqCst);
|
||
if zone.is_null() {
|
||
return None;
|
||
}
|
||
// SAFETY: 非空即代表 zone 已注册
|
||
init_root(unsafe { &mut *zone }).ok()
|
||
}
|
||
|
||
/// 取 slab 分配器(构造共享内存字符串用)
|
||
pub fn alloc() -> Option<SlabPool> {
|
||
let zone = STATE_ZONE.load(Ordering::SeqCst);
|
||
if zone.is_null() {
|
||
return None;
|
||
}
|
||
// SAFETY: 同上
|
||
unsafe { SlabPool::from_shm_zone(&mut *zone) }
|
||
}
|
||
|
||
/// 初始化回调:由 nginx 在 fork 之前调用一次
|
||
pub fn init_zone(zone: *mut ngx_shm_zone_t) -> Status {
|
||
// SAFETY: nginx 传入的 zone 有效
|
||
match init_root(unsafe { &mut *zone }) {
|
||
Ok(_) => Status::NGX_OK,
|
||
Err(e) => e,
|
||
}
|
||
}
|
||
|
||
/// 取全局文件写锁。所有「读文件 → 改 → 写文件」必须包在这里面。
|
||
///
|
||
/// nginx 侧只有一个写锁、且都是低频管理操作,串行化代价可忽略;
|
||
/// 而它换来的是多 worker 下不会出现「两边同时改、后写的覆盖前写的」。
|
||
pub fn file_lock() -> Option<RwLockWriteGuard<'static, ()>> {
|
||
root().map(|r| r.file_lock.write())
|
||
}
|
||
|
||
// ===========================================================================
|
||
// 键构造
|
||
// ===========================================================================
|
||
|
||
/// 在栈上拼 `prefix + name`,避免热路径为键做堆分配。
|
||
fn key_buf(prefix: &[u8], name: &[u8]) -> Option<([u8; KEY_BUF_LEN], usize)> {
|
||
let n = prefix.len() + name.len();
|
||
if n > KEY_BUF_LEN {
|
||
return None;
|
||
}
|
||
let mut buf = [0u8; KEY_BUF_LEN];
|
||
buf[..prefix.len()].copy_from_slice(prefix);
|
||
buf[prefix.len()..n].copy_from_slice(name);
|
||
Some((buf, n))
|
||
}
|
||
|
||
/// 拆 value:`<payload> \x1f <expires_at>`
|
||
fn split_value(bytes: &[u8]) -> Option<(&[u8], i64)> {
|
||
let sep = bytes.iter().position(|&b| b == VAL_SEP)?;
|
||
let payload = &bytes[..sep];
|
||
let exp = core::str::from_utf8(&bytes[sep + 1..]).ok()?.parse::<i64>().ok()?;
|
||
Some((payload, exp))
|
||
}
|
||
|
||
// ===========================================================================
|
||
// 读写原语
|
||
// ===========================================================================
|
||
|
||
/// 查表。返回 `(payload, expires_at)`;键不存在或值损坏时返回 None。
|
||
///
|
||
/// **转发热路径唯一入口**——只读共享内存,未命中不产生任何 I/O。
|
||
pub fn get(prefix: &[u8], name: &[u8]) -> Option<(String, i64)> {
|
||
let (buf, n) = key_buf(prefix, name)?;
|
||
let root = root()?;
|
||
let guard = root.map.read();
|
||
let value = guard.get(NgxStr::from_bytes(&buf[..n]))?;
|
||
let (payload, exp) = split_value(value.as_bytes())?;
|
||
// 复制成 owned:guard 释放后共享内存可能被并发写覆盖,
|
||
// 直接返回引用会悬垂。一次小字符串分配远小于转发本身的代价。
|
||
Some((String::from_utf8_lossy(payload).into_owned(), exp))
|
||
}
|
||
|
||
/// 查表并校验未过期
|
||
pub fn get_live(prefix: &[u8], name: &[u8], now: i64) -> Option<String> {
|
||
let (payload, exp) = get(prefix, name)?;
|
||
if exp > 0 && exp <= now {
|
||
return None;
|
||
}
|
||
Some(payload)
|
||
}
|
||
|
||
/// 写入(先删后插,语义为覆盖)。返回 false 表示共享内存不足或 zone 未就绪。
|
||
pub fn put(prefix: &[u8], name: &[u8], payload: &[u8], expires_at: i64) -> bool {
|
||
let (Some(root), Some(a)) = (root(), alloc()) else {
|
||
return false;
|
||
};
|
||
|
||
let mut value = Vec::with_capacity(payload.len() + 24);
|
||
value.extend_from_slice(payload);
|
||
value.push(VAL_SEP);
|
||
value.extend_from_slice(expires_at.to_string().as_bytes());
|
||
|
||
let mut key = Vec::with_capacity(prefix.len() + name.len());
|
||
key.extend_from_slice(prefix);
|
||
key.extend_from_slice(name);
|
||
|
||
let (Ok(nk), Ok(nv)) = (
|
||
NgxString::try_from_bytes_in(&key, a.clone()),
|
||
NgxString::try_from_bytes_in(&value, a),
|
||
) else {
|
||
return false;
|
||
};
|
||
|
||
let mut guard = root.map.write();
|
||
// 先删后插:try_insert 对已存在的键可能直接失败,而这里的语义是覆盖
|
||
let _ = guard.remove(NgxStr::from_bytes(&key));
|
||
guard.try_insert(nk, nv).is_ok()
|
||
}
|
||
|
||
/// 删除一个键。返回它此前是否存在。
|
||
pub fn remove(prefix: &[u8], name: &[u8]) -> bool {
|
||
let Some(root) = root() else {
|
||
return false;
|
||
};
|
||
let mut key = Vec::with_capacity(prefix.len() + name.len());
|
||
key.extend_from_slice(prefix);
|
||
key.extend_from_slice(name);
|
||
root.map.write().remove(NgxStr::from_bytes(&key)).is_some()
|
||
}
|
||
|
||
/// 当前条目数(管理端观测用;当前无调用方,保留为诊断接口)
|
||
#[allow(dead_code)]
|
||
pub fn len() -> usize {
|
||
root().map(|r| r.map.read().iter().count()).unwrap_or(0)
|
||
}
|
||
|
||
/// 只清掉某一前缀下的所有键。
|
||
///
|
||
/// 重载转发映射时用——**不能**用 `clear()`,那会把正在登录的管理员会话一起清掉。
|
||
pub fn clear_prefix(prefix: &[u8]) {
|
||
let Some(root) = root() else {
|
||
return;
|
||
};
|
||
let mut guard = root.map.write();
|
||
// 先收集待删键:迭代器借用了 guard,不能边遍历边删
|
||
let victims: Vec<Vec<u8>> =
|
||
guard.iter().filter(|p| p.0.as_bytes().starts_with(prefix)).map(|p| p.0.as_bytes().to_vec()).collect();
|
||
for v in victims {
|
||
guard.remove(NgxStr::from_bytes(&v));
|
||
}
|
||
}
|
||
|
||
/// 遍历某前缀下的全部条目,返回 `(去掉前缀的键名, payload)`。
|
||
///
|
||
/// 这是**低频读**接口(管理台聚合用量统计),不是热路径——每次都会克隆一份
|
||
/// 字符串出来,别拿它做每请求调用。`expires_at` 刻意不返回:统计键永不过期,
|
||
/// 调用方用 payload 里的日窗 id 自行判断"今日"。
|
||
pub fn iter_prefix(prefix: &[u8]) -> Vec<(String, String)> {
|
||
let Some(root) = root() else {
|
||
return Vec::new();
|
||
};
|
||
let guard = root.map.read();
|
||
guard
|
||
.iter()
|
||
.filter_map(|(k, v)| {
|
||
let name = k.as_bytes().strip_prefix(prefix)?;
|
||
let (payload, _) = split_value(v.as_bytes())?;
|
||
Some((
|
||
String::from_utf8_lossy(name).into_owned(),
|
||
String::from_utf8_lossy(payload).into_owned(),
|
||
))
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
// ===========================================================================
|
||
// 业务语义封装
|
||
// ===========================================================================
|
||
|
||
/// 转发映射:子域名 → 后端
|
||
pub fn put_backend(subdomain: &[u8], backend: &[u8], expires_at: i64) -> bool {
|
||
put(crate::config::KEY_SUB_PREFIX, subdomain, backend, expires_at)
|
||
}
|
||
|
||
/// 转发映射查询。返回 `(backend, expires_at)`。
|
||
pub fn get_backend(subdomain: &[u8]) -> Option<(String, i64)> {
|
||
get(crate::config::KEY_SUB_PREFIX, subdomain)
|
||
}
|
||
|
||
/// 失效一个子域名的转发映射(写操作后调用,保证「审核一通过、立刻可访问」)
|
||
pub fn invalidate(subdomain: &[u8]) -> bool {
|
||
remove(crate::config::KEY_SUB_PREFIX, subdomain)
|
||
}
|
||
|
||
/// 管理会话写入
|
||
pub fn put_session(token: &str, username: &str, expires_at: i64) -> bool {
|
||
put(crate::config::KEY_SESS_PREFIX, token.as_bytes(), username.as_bytes(), expires_at)
|
||
}
|
||
|
||
/// 管理会话读取(未过期才返回用户名)
|
||
pub fn get_session(token: &str, now: i64) -> Option<String> {
|
||
get_live(crate::config::KEY_SESS_PREFIX, token.as_bytes(), now)
|
||
}
|
||
|
||
pub fn remove_session(token: &str) -> bool {
|
||
remove(crate::config::KEY_SESS_PREFIX, token.as_bytes())
|
||
}
|
||
|
||
/// 登录失败计数:返回自增后的值
|
||
pub fn bump_login_fail(ip: &str, now: i64) -> i64 {
|
||
let current = match get(crate::config::KEY_FAIL_PREFIX, ip.as_bytes()) {
|
||
Some((_, exp)) if exp > 0 && exp <= now => 0,
|
||
Some((payload, _)) => payload.parse::<i64>().unwrap_or(0),
|
||
None => 0,
|
||
};
|
||
let next = current + 1;
|
||
put(
|
||
crate::config::KEY_FAIL_PREFIX,
|
||
ip.as_bytes(),
|
||
next.to_string().as_bytes(),
|
||
now + crate::config::LOGIN_FAIL_TTL,
|
||
);
|
||
next
|
||
}
|
||
|
||
pub fn get_login_fail(ip: &str, now: i64) -> i64 {
|
||
match get(crate::config::KEY_FAIL_PREFIX, ip.as_bytes()) {
|
||
Some((_, exp)) if exp > 0 && exp <= now => 0,
|
||
Some((payload, _)) => payload.parse::<i64>().unwrap_or(0),
|
||
None => 0,
|
||
}
|
||
}
|
||
|
||
pub fn clear_login_fail(ip: &str) {
|
||
remove(crate::config::KEY_FAIL_PREFIX, ip.as_bytes());
|
||
}
|
||
|
||
/// 窗口计数(限流/配额共用):键固定,value = `<窗口id>:<计数>`,永不过期
|
||
/// (`expires_at = 0`)——跨窗归零靠读时比对窗 id,键数只随用户数增长。
|
||
/// 返回自增后的计数。
|
||
///
|
||
/// 读-增-写跨 worker **没有互斥**:`bump_login_fail` 同款近似语义。
|
||
/// 对限流来说,并发下偶发少计数只是放宽一两 个请求的边界,可接受;
|
||
/// 为此上写锁反而让每个 LLM 请求都串行化,得不偿失。
|
||
pub fn bump_window(prefix: &[u8], name: &str, window: i64) -> i64 {
|
||
let current = window_count(prefix, name, window);
|
||
let next = current + 1;
|
||
put(prefix, name.as_bytes(), format!("{}:{}", window, next).as_bytes(), 0);
|
||
next
|
||
}
|
||
|
||
/// 读窗口计数(未跨窗时),管理台展示用量用
|
||
pub fn window_count(prefix: &[u8], name: &str, window: i64) -> i64 {
|
||
match get(prefix, name.as_bytes()) {
|
||
Some((payload, _)) => match payload.split_once(':') {
|
||
Some((w, c)) if w == window.to_string() => c.parse::<i64>().unwrap_or(0),
|
||
_ => 0,
|
||
},
|
||
None => 0,
|
||
}
|
||
}
|
||
|
||
// ===========================================================================
|
||
// LLM 代理
|
||
// ===========================================================================
|
||
|
||
/// 写入 API Key → 身份索引。
|
||
///
|
||
/// payload = `<username> \n <allowed_models 逗号分隔> \n <llm_rpm> \n <llm_daily>`(4 行,与 `users::identity_payload` 一致)。
|
||
/// **永不过期**(`expires_at = 0`):它的生命周期完全跟随 accounts 表的增删,
|
||
/// 由 `users` 模块在每次写操作后显式同步——这里不能再加一层 TTL,
|
||
/// 否则会出现「账号还在、Key 偶尔 401」这种极难复现的状态。
|
||
pub fn put_ukey(api_key: &str, payload: &str) -> bool {
|
||
put(KEY_UKEY_PREFIX, api_key.as_bytes(), payload.as_bytes(), 0)
|
||
}
|
||
|
||
pub fn remove_ukey(api_key: &str) -> bool {
|
||
remove(KEY_UKEY_PREFIX, api_key.as_bytes())
|
||
}
|
||
|
||
/// 写入上游配置(payload = `base \n auth`)
|
||
pub fn put_upstream(slot: &str, payload: &str) -> bool {
|
||
put(KEY_UP_PREFIX, slot.as_bytes(), payload.as_bytes(), 0)
|
||
}
|
||
|
||
/// 读上游配置。与转发映射一样只读内存,未命中不产生任何 I/O。
|
||
pub fn get_upstream(slot: &str) -> Option<String> {
|
||
get_live(KEY_UP_PREFIX, slot.as_bytes(), crate::util::now())
|
||
}
|
||
|
||
pub fn remove_upstream(slot: &str) -> bool {
|
||
remove(KEY_UP_PREFIX, slot.as_bytes())
|
||
}
|