//! 共享内存状态层。 //! //! 这是「配置放内存」的落点,替代旧版的 `lua_shared_dict proxy_cache / //! admin_sessions / lua_locks` 三个字典。全部派生状态集中在一张 //! `RbTreeMap` 里,用键前缀区分用途: //! //! ```text //! sub: → \x1f 转发映射 //! sess: → \x1f 管理会话 //! fail: → \x1f 登录失败计数 //! ``` //! //! ## 为什么过期时间写在 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>; /// 共享内存根对象:一张表 + 一把文件写锁。 /// /// 文件写锁**独立于表的读写锁**:文件 I/O 期间若持有表的写锁, /// 会把所有转发请求(需要读锁)一起卡住。分开后,域名的热路径只受 /// 自身短临界区影响。 pub struct ShmRoot { pub map: RwLock, /// 保护 `store` 的「读-改-写」与落盘,跨 worker 互斥 pub file_lock: RwLock<()>, } /// 由 `ipass_state ` 注册的共享内存区 static STATE_ZONE: AtomicPtr = 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::().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 { 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> { 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:` \x1f ` 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::().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 { 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> = 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 { 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::().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::().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::().unwrap_or(0), _ => 0, }, None => 0, } } // =========================================================================== // LLM 代理 // =========================================================================== /// 写入 API Key → 身份索引。 /// /// payload = ` \n \n \n `(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 { 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()) }