Files
ipass__ipass/rust/src/lib.rs
T
admin 1b0bde9f72 feat(llm): 上游健康自动标记 + 管理台连通性测试 + 可复制 API 地址
- 健康标记(log 阶段):真实转发的上游状态码写入 uh:<slot>(4xx=活着,
  5xx/502/504=失效,下次成功自动自愈),数据来源就是真实流量本身,
  无需常驻探测进程。状态码读 $upstream_status 变量(r->upstream 在
  上游 finalize 时已置空,log 阶段读不到——access log 同款手法)。
- 管理台「测试」按钮:POST /api/admin/upstreams/test?slot=X,校验后
  ngx_http_internal_redirect 到管理 server 内部 location /_upstream_test,
  复用 LLM 链路的取 slot / 拼路径 / 换真 Key 逻辑,上游原话透传给面板。
  ⚠️ 内部重定向只浅拷贝 ngx_str_t,URI 必须拷进请求池——否则函数返回
  即悬垂,log 阶段 r->uri 全是 NUL,健康标记静默失效(实测踩坑)。
- 上游列表每行 slot 旁 OpenAI / Anthropic 两枚点击复制地址按钮,
  模型发现(/v1/models 与 /api/v1/models、/api/v1/upstreams)附
  anthropic_base_url 与健康状态;anthropic_base_url 统一收口
  upstreams::anthropic_base_url(),base 已钉 /anthropic 时不重复追加。
- 统计卡片挪进独立「数据总览」tab 并设为默认页。
- 回归 +12 条(第 12 节健康标记断言),LLM 111 + 网关 78,失败 0。
- 测试卫生:run.sh 启动靶机前 pkill 残留进程(占 18999 会造成假 200)。
2026-09-12 14:42:32 +08:00

789 lines
29 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.
//! iPass 山海关(ipass-gateway)—— nginx + Rust 动态模块(v2)
//!
//! 尚数网 统一网关(动态域名 / LLM API 路由及未来各类统一出口能力)。
//! 本模块承担原 OpenResty + Lua 版的**全部**职责:
//!
//! | 旧版(Lua) | 新版(Rust) |
//! |------------------------------------|-------------------------|
//! | `lua_shared_dict proxy_cache` | `state` 共享内存映射表 |
//! | `lua_shared_dict admin_sessions` | `state` 会话键 |
//! | `lua_shared_dict lua_locks` | `state` 文件写锁 |
//! | `store.lua`(cjson + resty.lock) | `store` + serde_json |
//! | `users.lua` / `domains.lua` | `users` / `domains` |
//! | `api.lua` 路由表 | `api` 精确匹配路由表 |
//! | `proxy.lua` 转发热路径 | `ResolveHandler` |
//! | —(新增能力) | `LlmHandler` LLM 代理 |
//!
//! ## 三条热路径
//!
//! | 入口 | 阶段 | 开关 | 做什么 |
//! | --- | --- | --- | --- |
//! | `*.yourdomain.com/*` | access | `ipass_proxy` | 查 `sub:` 决定后端 |
//! | `llm.yourdomain.com/<slot>/*` | access | `ipass_llm` | 查 `ukey:` 鉴权 + `up:` 定上游 |
//! | `proxy-api.yourdomain.com/api/*` | content | `ipass_api` | 管理接口,读体后分发 |
//!
//! ## 关键实现约束(均为实测/查证确认,详见 CLAUDE.md)
//!
//! * `ngx_http_add_variable` 必须在 **preconfiguration** 阶段调用,
//! 否则配置里的 `proxy_pass http://$proxy_backend_addr` 无法解析。
//! * 阶段处理器在 postconfiguration 阶段注册,且**必须按 location 开关**
//! (`ipass_proxy` / `ipass_api` / `ipass_llm`),否则管理台与 API
//! 也会被转发逻辑 404 掉。
//! * 共享内存只有 `RwLock<RbTreeMap<_, _, SlabPool>, _>` 一种安全形态;
//! `SlabPool` 只能在 zone 初始化回调里取出,锁本身也必须用
//! `ngx::allocator::allocate` 放进共享内存,否则各 worker 拿到的是各自的副本。
//! * ngx crate **没有**暴露请求体读取,必须走
//! `ngx_http_read_client_request_body` 的两段式异步接口(见 `ApiHandler`)。
//! **这也是 LLM 代理不按 body 里的 `model` 字段路由的原因**——access 阶段
//! 根本拿不到请求体。
mod api;
mod config;
mod domains;
mod http;
mod llm;
mod models;
mod session;
mod state;
mod stats;
mod store;
mod upstreams;
mod util;
mod users;
use core::ffi::{c_char, c_void};
use core::ptr;
use core::sync::atomic::{AtomicIsize, AtomicUsize, Ordering};
use ngx::core::{NGX_CONF_ERROR, NGX_CONF_OK, NgxStr, NgxString, Pool, SlabPool, Status};
use ngx::ffi::{
NGX_CONF_TAKE1, NGX_CONF_TAKE2, NGX_HTTP_LOC_CONF, NGX_HTTP_LOC_CONF_OFFSET, NGX_HTTP_MAIN_CONF,
NGX_HTTP_MAIN_CONF_OFFSET, NGX_HTTP_MODULE, NGX_HTTP_VAR_CHANGEABLE, NGX_HTTP_VAR_NOCACHEABLE,
NGX_LOG_EMERG, ngx_command_t, ngx_conf_t, ngx_cycle_t, ngx_http_add_variable,
ngx_http_get_indexed_variable, ngx_http_get_variable_index, ngx_http_module_t,
ngx_http_request_t, ngx_http_variable_value_t, ngx_int_t, ngx_module_t, ngx_parse_size,
ngx_shared_memory_add, ngx_shm_zone_t, ngx_str_t, ngx_uint_t,
};
use ngx::http::{
HTTPStatus, HttpModule, HttpModuleLocationConf, HttpPhase, HttpRequestHandler, Merge,
MergeConfigError,
};
use ngx::{ngx_conf_log_error, ngx_string};
/// `$proxy_backend_addr` 在 `r->variables` 里的下标
static BACKEND_VAR_INDEX: AtomicUsize = AtomicUsize::new(usize::MAX);
// ===========================================================================
// 转发热路径
// ===========================================================================
/// 查共享内存取后端地址;已过期的条目视为不存在。
///
/// **热路径唯一入口**——只读内存,未命中不产生任何 I/O。
/// 旧版这里在 miss 时会去读 `domains.json` 并全量 JSON 解码,
/// 那正是「随便发一堆随机子域名就能打穿磁盘」的入口。
fn resolve_backend(subdomain: &[u8]) -> Option<String> {
let (backend, expires_at) = state::get_backend(subdomain)?;
if expires_at > 0 && expires_at <= util::now() {
return None;
}
Some(backend)
}
/// 取 Host 头里第一个点之前的部分作为子域名。
///
/// 刻意不走 nginx 的 server_name 正则捕获变量(那需要再算一次变量 hash),
/// 热路径上手工切更省。
fn subdomain_of(r: *mut ngx_http_request_t) -> Option<Vec<u8>> {
// SAFETY: r 有效;迭代器只在本函数存续期内使用
let request = unsafe { ngx::http::Request::from_ngx_http_request(r) };
for (key, value) in request.headers_in_iterator() {
if key.as_bytes().eq_ignore_ascii_case(b"host") {
let host = value.as_bytes();
// 去掉端口
let host = match host.iter().position(|&b| b == b':') {
Some(i) => &host[..i],
None => host,
};
// 取第一段标签
let label = match host.iter().position(|&b| b == b'.') {
Some(i) => &host[..i],
None => host,
};
if label.is_empty() {
return None;
}
return Some(label.to_ascii_lowercase());
}
}
None
}
/// 把后端地址写进 `r->variables[$proxy_backend_addr]`,供 `proxy_pass` 使用
fn set_backend_var(r: *mut ngx_http_request_t, backend: &str) {
let idx = BACKEND_VAR_INDEX.load(Ordering::SeqCst);
if idx == usize::MAX {
return;
}
// SAFETY: idx 由 ngx_http_get_variable_index 分配且落在 r->variables 内;
// 值分配在请求池里,随请求回收
unsafe {
let pool = Pool::from_ngx_pool((*r).pool);
let bytes = backend.as_bytes();
let data = pool.alloc(bytes.len()) as *mut u8;
if data.is_null() {
return;
}
ptr::copy_nonoverlapping(bytes.as_ptr(), data, bytes.len());
let vv: *mut ngx_http_variable_value_t = (*r).variables.add(idx);
(*vv).data = data;
(*vv).set_len(bytes.len() as _);
(*vv).set_valid(1);
(*vv).set_not_found(0);
(*vv).set_no_cacheable(1);
}
}
/// 变量 get_handler:`proxy_pass` 求值 `$proxy_backend_addr` 时被调用。
///
/// 与 access 阶段互补——这里保证「即使 access 未赋值也能取到」,
/// access 阶段则负责决定命中不了时返回 404。
extern "C" fn backend_get(
r: *mut ngx_http_request_t,
v: *mut ngx_http_variable_value_t,
_data: usize,
) -> ngx_int_t {
// SAFETY: nginx 传入的 r/v 必然有效
unsafe {
let resolved = subdomain_of(r).as_deref().and_then(resolve_backend);
let Some(backend) = resolved else {
(*v).set_not_found(1);
return Status::NGX_ERROR.into();
};
let pool = Pool::from_ngx_pool((*r).pool);
let bytes = backend.as_bytes();
let data = pool.alloc(bytes.len()) as *mut u8;
if data.is_null() {
(*v).set_not_found(1);
return Status::NGX_ERROR.into();
}
ptr::copy_nonoverlapping(bytes.as_ptr(), data, bytes.len());
(*v).data = data;
(*v).set_len(bytes.len() as _);
(*v).set_valid(1);
(*v).set_no_cacheable(1);
(*v).set_not_found(0);
Status::NGX_OK.into()
}
}
// ===========================================================================
// 阶段处理器
// ===========================================================================
/// 转发热路径:命中则放行(`proxy_pass` 会去取 `$proxy_backend_addr`),未命中直接 404。
struct ResolveHandler;
impl HttpRequestHandler for ResolveHandler {
const PHASE: HttpPhase = HttpPhase::Access;
type Output = Status;
fn handler(request: &mut ngx::http::Request) -> Self::Output {
// 未开启该开关的 location 一律放行(管理台/API 走这里)
if !Module::location_conf(request).map(|c| c.proxy).unwrap_or(false) {
return Status::NGX_DECLINED;
}
let r: *mut ngx_http_request_t = request.as_mut() as *mut ngx_http_request_t;
let Some(host) = subdomain_of(r) else {
return HTTPStatus::NOT_FOUND.into();
};
match resolve_backend(&host) {
Some(backend) => {
set_backend_var(r, &backend);
Status::NGX_DECLINED
}
// 与旧版语义一致:查不到 = 未配置 / 已过期 / 已删除 / 尚未审核通过
None => HTTPStatus::NOT_FOUND.into(),
}
}
}
/// LLM 代理热路径:鉴权 → 校验上游与白名单 → 放行。
///
/// 刻意**只做决策、不搬数据**:真正的转发交给 nginx 的 proxy 模块,
/// 于是 SSE 流式、`proxy_buffering`、上游超时全部是 nginx 原生行为,
/// 不需要自己实现 upstream——那正是「按 body 里的 model 路由」代价高昂之处。
///
/// 变量(`$llm_target` / `$llm_host` / `$llm_auth`)不在这里赋值,
/// 而由 `llm::var_get` 在 `proxy_pass` 求值时计算,与 `$proxy_backend_addr` 同构。
struct LlmHandler;
impl HttpRequestHandler for LlmHandler {
const PHASE: HttpPhase = HttpPhase::Access;
type Output = Status;
fn handler(request: &mut ngx::http::Request) -> Self::Output {
if !Module::location_conf(request).map(|c| c.llm).unwrap_or(false) {
return Status::NGX_DECLINED;
}
let r: *mut ngx_http_request_t = request.as_mut() as *mut ngx_http_request_t;
let Some(slot) = llm::slot_of(r) else {
return llm::fail(
r,
HTTPStatus::BAD_REQUEST,
"invalid_request_error",
"路径缺少上游段,正确形式:/<上游名>/v1/chat/completions",
);
};
let Some(key) = llm::downstream_key(r) else {
return llm::fail(
r,
HTTPStatus::UNAUTHORIZED,
"invalid_api_key",
"缺少 API Key,请在 Authorization: Bearer 或 x-api-key 中携带",
);
};
// 只碰共享内存:这里若改成 users::find_by_key 会每请求读一次 users.json
let Some((username, allowed, rpm, daily)) = llm::identity(&key) else {
util::log_warn(&format!(
"[llm] API Key 校验失败 slot={slot} client={}",
http::remote_addr(r)
));
return llm::fail(
r,
HTTPStatus::UNAUTHORIZED,
"invalid_api_key",
"API Key 无效或已失效",
);
};
// 「列出可用模型」是网关自己的元信息接口(OpenAI 兼容形状),
// 在查上游之前就地应答——否则 `/v1/models` 会被当成 slot=v1 → 404。
if llm::is_models_probe(r) {
return llm::respond_models(r, &allowed);
}
if state::get_upstream(&slot).is_none() {
return llm::fail(
r,
HTTPStatus::NOT_FOUND,
"model_not_found",
&format!("上游 {slot} 不存在或已停用"),
);
}
// 空白名单 = 不限(老账号没有该字段时的语义)
if !allowed.is_empty() && !allowed.iter().any(|s| s == &slot) {
util::log_warn(&format!("[llm] {username} 无权访问上游 {slot}"));
return llm::fail(
r,
HTTPStatus::FORBIDDEN,
"permission_denied",
&format!("当前账号无权访问上游 {slot}"),
);
}
// 限流与每日配额(先增后判,纯共享内存)。放在最后:
// 鉴权/白名单都没过的请求不该消耗对方的计数
// SAFETY: r 由 nginx 传入且有效
if let Some(resp) = unsafe { llm::check_quota(r, &username, rpm, daily) } {
return resp;
}
// 用量统计:走到这里说明请求**真的会被转发**,才计入。
// 被拒的请求(401/403/404/429)不进统计——那是给人看的数字,
// 把拒绝也算进"用量"只会误导(与配额计数 st: 的语义刻意不同)。
stats::record(&username, &slot, util::now());
Status::NGX_DECLINED
}
}
/// `$upstream_status` 的变量索引,postconfiguration 时解析一次(log 阶段复用)。
static UPSTREAM_STATUS_IDX: AtomicIsize = AtomicIsize::new(-1);
/// LLM 上游健康标记(log 阶段):把上游**真实**状态码写进 `uh:<slot>` 缓存。
///
/// 为什么在 log 阶段:转发决策在 access、响应在 proxy 模块手里,只有 log
/// 阶段能同时拿到「slot 是谁」和「上游实际回了什么」。这相当于让**真实流量
/// 自己当探针**——不需要额外的常驻探测进程(项目红线),健康状态也最真实。
/// 管理台「测试」按钮的探测请求走同一条 `proxy_pass` 链路,天然共用本逻辑。
///
/// 写下的缓存**只用于展示**(列表标红 / 模型发现附状态),转发路径不读它,
/// 误标不影响任何请求的结果。
///
/// ⚠️ 状态码从 `$upstream_status` 变量读,**不能读 `r->upstream`**——
/// `ngx_http_upstream_finalize_request` 在日志阶段之前就把 `r->upstream`
/// 置空了(实测踩过:代码编译通过、跑起来状态永远是 unknown)。
/// access log 模块同款手法:变量在 finalize 时快照,log 阶段仍有效。
struct LlmHealthHandler;
impl HttpRequestHandler for LlmHealthHandler {
const PHASE: HttpPhase = HttpPhase::Log;
type Output = Status;
fn handler(request: &mut ngx::http::Request) -> Self::Output {
let r: *mut ngx_http_request_t = request.as_mut() as *mut ngx_http_request_t;
// 两类请求要标记:
// ① LLM server 的真实转发流量(location_conf.llm == true);
// ② 管理台探测流量——内部重定向到管理 server 的 /_upstream_test location,
// 那里**没有** ipass_llm 指令(有就会重跑 access 鉴权,探测请求只有
// 登录会话没有 API Key),所以只能按 URI 前缀认。
let uri = crate::http::uri(r);
let is_llm = Module::location_conf(request).map(|c| c.llm).unwrap_or(false);
let is_probe = uri.starts_with("/_upstream_test");
if !is_llm && !is_probe {
return Status::NGX_DECLINED;
}
// SAFETY: r 有效;索引在 postconfiguration 已解析(见 postconfiguration)
let code = unsafe {
let idx = UPSTREAM_STATUS_IDX.load(Ordering::Relaxed);
if idx < 0 {
0
} else {
let v = ngx_http_get_indexed_variable(r, idx as ngx_uint_t);
if (*v).not_found() != 0 || (*v).data.is_null() {
0
} else {
let s = core::str::from_utf8(core::slice::from_raw_parts(
(*v).data,
(*v).len() as usize,
))
.unwrap_or("");
// 内部重定向会有多段(如 "502, 200"),取**最后一段** = 最近一次上游尝试
s.rsplit(',').next().unwrap_or("").trim().parse().unwrap_or(0)
}
}
};
// 没有 upstream(本地应答如 /v1/models)或没拿到状态码(客户端中途
// 断连等)→ 无从判断,不写缓存,留给下一次真实转发
if code == 0 {
return Status::NGX_DECLINED;
}
if let Some(slot) = llm::slot_of(r) {
// 上游回了头 = 它活着:2xx~4xx 都算正常(4xx 是它对我们请求的意见,
// 不是机器死了);5xx / 连接失败(502) / 等头超时(504) 才算失效
upstreams::mark_health(&slot, (200..500).contains(&code), code);
}
Status::NGX_DECLINED
}
}
/// 管理 API:content 阶段先读请求体,读完后交给 `api::dispatch`。
///
/// 这是本项目唯一需要异步的地方。`ngx_http_read_client_request_body` 是
/// **两段式**接口:请求体已在缓冲区时会**同步**调用 post_handler,
/// 否则挂起等 socket 事件后回调。两条路径都必须正确,所以不能假设
/// 「回调一定晚于本次返回」。
struct ApiHandler;
impl HttpRequestHandler for ApiHandler {
const PHASE: HttpPhase = HttpPhase::Content;
type Output = Status;
fn handler(request: &mut ngx::http::Request) -> Self::Output {
if !Module::location_conf(request).map(|c| c.api).unwrap_or(false) {
return Status::NGX_DECLINED;
}
let r: *mut ngx_http_request_t = request.as_mut() as *mut ngx_http_request_t;
// SAFETY: r 有效;回调只会在请求内存池存活期间被调用
let rc = unsafe { nginx_sys::ngx_http_read_client_request_body(r, Some(api_body_ready)) };
// 读体失败(请求体超限等):把原始状态码交回 nginx,由它生成对应错误页
if rc >= nginx_sys::NGX_HTTP_SPECIAL_RESPONSE as ngx_int_t {
return Status(rc);
}
// 响应由回调发出,本阶段到此挂起
Status::NGX_DONE
}
}
/// 请求体就绪回调:执行路由分发并终结请求。
unsafe extern "C" fn api_body_ready(r: *mut ngx_http_request_t) {
let status = api::dispatch(r);
// SAFETY: r 由 nginx 传入且仍然有效;NGX_OK 表示响应已完整发出
unsafe { nginx_sys::ngx_http_finalize_request(r, status.0) };
}
// ===========================================================================
// 模块定义
// ===========================================================================
struct Module;
/// 按 location 生效的开关。
///
/// 必须存在:阶段处理器注册在 http 主配置上,若不按 location 收敛,
/// 管理台与 API 也会走转发逻辑并被 404。
#[derive(Debug, Default)]
struct ModuleConfig {
/// 该 location 走「子域名 → 后端」转发
proxy: bool,
/// 该 location 暴露管理 API(/api/admin/*、/api/v1/*)
api: bool,
/// 该 location 走 LLM 代理(`/<slot>/...` → 上游)
llm: bool,
}
unsafe impl HttpModuleLocationConf for Module {
type LocationConf = ModuleConfig;
}
impl Merge for ModuleConfig {
fn merge(&mut self, prev: &ModuleConfig) -> Result<(), MergeConfigError> {
if prev.proxy {
self.proxy = true;
}
if prev.api {
self.api = true;
}
if prev.llm {
self.llm = true;
}
Ok(())
}
}
/// 注册一个只读变量,值由 `llm::var_get` 按 `slot` 分派计算。
///
/// 与 `$proxy_backend_addr` 不同,LLM 三件套**不需要**
/// `ngx_http_get_variable_index`——它们是纯只读的,模块从不主动写,
/// 只有 `proxy_pass` / `proxy_set_header` 求值时触发 get_handler。
unsafe fn add_llm_var(cf: *mut ngx_conf_t, name: *mut ngx_str_t, slot: usize) -> bool {
// SAFETY: cf 由 nginx 传入;name 指向本函数调用方栈上的 ngx_str_t,注册时被拷贝
let var = unsafe {
ngx_http_add_variable(
cf,
name,
(NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE) as ngx_uint_t,
)
};
if var.is_null() {
return false;
}
// SAFETY: var 非空且由本函数独占初始化;data 承载分派标记
unsafe {
(*var).get_handler = Some(llm::var_get);
(*var).set_handler = None;
(*var).data = slot;
}
true
}
impl HttpModule for Module {
fn module() -> &'static ngx_module_t {
// SAFETY: 模块定义是静态的,生命周期贯穿进程
unsafe { &*ptr::addr_of!(ngx_http_ipass_module) }
}
/// 必须在配置解析前注册变量,否则 `proxy_pass http://$proxy_backend_addr` 无法解析
unsafe extern "C" fn preconfiguration(cf: *mut ngx_conf_t) -> ngx_int_t {
let mut name = ngx_string!("proxy_backend_addr");
let idx = unsafe { ngx_http_get_variable_index(cf, &raw mut name) };
if idx == -1 {
return Status::NGX_ERROR.into();
}
BACKEND_VAR_INDEX.store(idx as usize, Ordering::SeqCst);
let var = unsafe {
ngx_http_add_variable(
cf,
&raw mut name,
(NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE) as ngx_uint_t,
)
};
if var.is_null() {
return Status::NGX_ERROR.into();
}
// SAFETY: var 非空且由本函数独占初始化
unsafe {
(*var).get_handler = Some(backend_get);
(*var).set_handler = None;
(*var).data = 0;
}
// LLM 三件套。名字里的 `llm_` 前缀不要省:nginx 变量名全局唯一,
// 将来接入别的模块时才不会撞名。
let mut target = ngx_string!("llm_target");
let mut host = ngx_string!("llm_host");
let mut auth = ngx_string!("llm_auth");
let llm_ok = unsafe {
add_llm_var(cf, &raw mut target, llm::VAR_TARGET)
&& add_llm_var(cf, &raw mut host, llm::VAR_HOST)
&& add_llm_var(cf, &raw mut auth, llm::VAR_AUTH)
};
if !llm_ok {
ngx_conf_log_error!(NGX_LOG_EMERG, unsafe { &mut *cf }, "注册 LLM 变量失败");
return Status::NGX_ERROR.into();
}
Status::NGX_OK.into()
}
unsafe extern "C" fn postconfiguration(cf: *mut ngx_conf_t) -> ngx_int_t {
let cf = unsafe { &mut *cf };
if ngx::http::add_phase_handler::<ResolveHandler>(cf).is_err() {
return Status::NGX_ERROR.into();
}
if ngx::http::add_phase_handler::<LlmHandler>(cf).is_err() {
return Status::NGX_ERROR.into();
}
if ngx::http::add_phase_handler::<LlmHealthHandler>(cf).is_err() {
return Status::NGX_ERROR.into();
}
if ngx::http::add_phase_handler::<ApiHandler>(cf).is_err() {
return Status::NGX_ERROR.into();
}
// 预取 `$upstream_status` 索引(upstream 模块 preconfiguration 已注册该内建变量)
let mut name = ngx_str_t {
len: "upstream_status".len() as usize,
data: b"upstream_status\0".as_ptr() as *mut u8,
};
let idx = ngx_http_get_variable_index(cf, &mut name);
if idx == -1 {
return Status::NGX_ERROR.into();
}
UPSTREAM_STATUS_IDX.store(idx as isize, Ordering::Relaxed);
Status::NGX_OK.into()
}
}
static mut NGX_HTTP_IPASS_COMMANDS: [ngx_command_t; 6] = [
ngx_command_t {
name: ngx_string!("ipass_state"),
type_: (NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE2) as ngx_uint_t,
set: Some(set_state_zone),
conf: NGX_HTTP_MAIN_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t {
name: ngx_string!("ipass_data_dir"),
type_: (NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE1) as ngx_uint_t,
set: Some(set_data_dir),
conf: NGX_HTTP_MAIN_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t {
name: ngx_string!("ipass_proxy"),
type_: (NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1) as ngx_uint_t,
set: Some(set_flag_proxy),
conf: NGX_HTTP_LOC_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t {
name: ngx_string!("ipass_api"),
type_: (NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1) as ngx_uint_t,
set: Some(set_flag_api),
conf: NGX_HTTP_LOC_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t {
name: ngx_string!("ipass_llm"),
type_: (NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1) as ngx_uint_t,
set: Some(set_flag_llm),
conf: NGX_HTTP_LOC_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t::empty(),
];
static NGX_HTTP_IPASS_MODULE_CTX: ngx_http_module_t = ngx_http_module_t {
preconfiguration: Some(Module::preconfiguration),
postconfiguration: Some(Module::postconfiguration),
create_main_conf: None,
init_main_conf: None,
create_srv_conf: None,
merge_srv_conf: None,
create_loc_conf: Some(Module::create_loc_conf),
merge_loc_conf: Some(Module::merge_loc_conf),
};
// 脱离 nginx 构建系统、单独产出 cdylib 时必须靠这个宏导出 ngx_modules 表
#[cfg(feature = "export-modules")]
ngx::ngx_modules!(ngx_http_ipass_module);
#[used]
#[allow(non_upper_case_globals)]
pub static mut ngx_http_ipass_module: ngx_module_t = ngx_module_t {
ctx: &raw const NGX_HTTP_IPASS_MODULE_CTX as _,
commands: unsafe { &raw mut NGX_HTTP_IPASS_COMMANDS[0] },
type_: NGX_HTTP_MODULE as _,
init_process: Some(init_process),
..ngx_module_t::default()
};
/// 每个 worker 启动后执行一次。管理员播种是**幂等**的:
/// 文件里已有任何账号就直接跳过,所以多 worker 同时跑不会重复创建。
unsafe extern "C" fn init_process(_cycle: *mut ngx_cycle_t) -> ngx_int_t {
match users::seed_admin() {
Ok(true) => util::log_warn(
"[ipass] 已创建初始管理员 admin,请首次登录后立即修改密码",
),
Ok(false) => {}
Err(e) => util::log_err(&format!("[ipass] 初始化管理员失败: {e}")),
}
Status::NGX_OK.into()
}
// ===========================================================================
// 指令处理
// ===========================================================================
/// 读第 2 个参数并转成 bool(on/off/1/0/yes/no)。
unsafe fn arg_flag(cf: *mut ngx_conf_t, idx: usize) -> Option<bool> {
let cf_ref = unsafe { cf.as_mut() }?;
let args: &mut [ngx_str_t] = unsafe { (*cf_ref.args).as_slice_mut() };
let raw = args.get(idx)?.as_bytes();
let s = core::str::from_utf8(raw).ok()?;
Some(matches!(s.to_ascii_lowercase().as_str(), "on" | "1" | "true" | "yes"))
}
extern "C" fn set_flag_proxy(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
conf: *mut c_void,
) -> *mut c_char {
let Some(flag) = (unsafe { arg_flag(cf, 1) }) else {
return NGX_CONF_ERROR;
};
// SAFETY: nginx 保证 conf 指向本模块的 loc conf 结构
unsafe { (*(conf as *mut ModuleConfig)).proxy = flag };
NGX_CONF_OK
}
extern "C" fn set_flag_api(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
conf: *mut c_void,
) -> *mut c_char {
let Some(flag) = (unsafe { arg_flag(cf, 1) }) else {
return NGX_CONF_ERROR;
};
// SAFETY: 同上
unsafe { (*(conf as *mut ModuleConfig)).api = flag };
NGX_CONF_OK
}
extern "C" fn set_flag_llm(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
conf: *mut c_void,
) -> *mut c_char {
let Some(flag) = (unsafe { arg_flag(cf, 1) }) else {
return NGX_CONF_ERROR;
};
// SAFETY: 同上
unsafe { (*(conf as *mut ModuleConfig)).llm = flag };
NGX_CONF_OK
}
extern "C" fn set_state_zone(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
_conf: *mut c_void,
) -> *mut c_char {
// SAFETY: 配置回调必然拿到有效的 cf
let cf_ref = unsafe { cf.as_mut().unwrap() };
let args: &mut [ngx_str_t] = unsafe { (*cf_ref.args).as_slice_mut() };
let mut name: ngx_str_t = args[1];
let size = unsafe { ngx_parse_size(&raw mut args[2]) };
if size == -1 {
ngx_conf_log_error!(NGX_LOG_EMERG, cf_ref, "ipass_state: 共享内存大小非法");
return NGX_CONF_ERROR;
}
let zone = unsafe {
ngx_shared_memory_add(
cf,
&raw mut name,
size as usize,
(&raw mut ngx_http_ipass_module).cast(),
)
};
if zone.is_null() {
return NGX_CONF_ERROR;
}
unsafe {
(*zone).init = Some(state_zone_init);
}
state::set_zone(zone);
NGX_CONF_OK
}
/// 共享内存初始化:由 nginx 在 **fork 之前**调用一次。
///
/// 在这里装载三张表,所有 worker 直接共享结果——比放在
/// `init_process`(每个 worker 各跑一遍)省掉 N-1 次文件读与 JSON 解析。
extern "C" fn state_zone_init(zone: *mut ngx_shm_zone_t, _data: *mut c_void) -> ngx_int_t {
let status = state::init_zone(zone);
if status != Status::NGX_OK {
return status.into();
}
let loaded = domains::reload_shm();
util::log_notice(&format!("[ipass] 共享内存已装载 {loaded} 条转发映射"));
// 账号 Key 与 LLM 上游必须一起进内存:LLM 热路径未命中即 401 / 404,
// 没有任何回源兜底(同 domains 的写穿语义)。
let keys = users::reload_shm();
let ups = upstreams::reload_shm();
util::log_notice(&format!(
"[ipass] 已装载 {keys} 个账号 Key、{ups} 个 LLM 上游"
));
Status::NGX_OK.into()
}
extern "C" fn set_data_dir(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
_conf: *mut c_void,
) -> *mut c_char {
// SAFETY: 配置回调必然拿到有效的 cf
let cf_ref = unsafe { cf.as_mut().unwrap() };
let args: &mut [ngx_str_t] = unsafe { (*cf_ref.args).as_slice_mut() };
match core::str::from_utf8(args[1].as_bytes()) {
Ok(dir) => {
store::set_data_dir(dir);
NGX_CONF_OK
}
Err(_) => {
ngx_conf_log_error!(NGX_LOG_EMERG, cf_ref, "ipass_data_dir: 路径不是合法 UTF-8");
NGX_CONF_ERROR
}
}
}
/// 供测试与诊断使用:`NgxStr` 类型在模块里被多处引用,确保编译期链接到正确的符号
#[allow(dead_code)]
fn _type_witness(_: &NgxStr, _: &NgxString<SlabPool>) {}