- 健康标记(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)。
789 lines
29 KiB
Rust
789 lines
29 KiB
Rust
//! 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>) {}
|