Files
ipass__ipass/rust/src/state.rs
T
admin e38237dc4a feat(deploy): 新增 .11 一键更新脚本 + 上游多模型/模型发现/用量统计
功能(本轮 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 常用操作 + 排障速查已同步。
2026-09-12 10:09:56 +08:00

363 lines
14 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.
//! 共享内存状态层。
//!
//! 这是「配置放内存」的落点,替代旧版的 `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())
}