Files
ssw__ipass/rust/src/api.rs
T
admin 1f548ac953 feat(api-proxy): 新增「API 代理」板块,把外部免费 API 市场挂到网关下
后端(rust/src/apix.rs,新模块)
- /apix/<slug>?<参数> → 市场 POST /api/v1/ai/request;复用 LLM 的 sk_ 鉴权 +
  配额 + 用量统计(slot 带 api/ 前缀,天然归组)
- 请求体由网关从 query 拼:asset_id 服务端决定(调用方只能选参数),堵住
  「客户端自选最贵资产」的口子;GET 经 proxy_method POST + proxy_set_body 转带体
- data/api-proxies.json(含平台真 Key,等同 users.json 敏感度):base+key+items
  shm 写穿 ax:,停用=摘键;平台 Key 不回显(只给掩码)
- 6 个 nginx 变量 + /_apix_probe/<slug>(internal)免费预估探测,复用 $apix_probe_*

前端(www/apix.html + assets/apix.js)
- 市场凭据配置 / 目录直拉(GET /api/v1/assets,跨域已开)/ 代理增删启停 /
  复制地址 / 免费预估测试(带回平台余额)

验证
- 回归 261 条全绿(网关 102 + LLM 159,新增 34 条 apix 断言)
- 涵盖:无/坏 Key→401、不存在/停用 slug→404、GET 改写 POST、换平台 Key、
  体由网关拼、下行 Key 不泄漏、写穿 shm、探测归 api/<slug>

文档
- readme §15.1 API 代理使用 + 变更日志;CLAUDE.md location 表补 ipass_apix
2026-09-13 02:46:35 +08:00

1055 lines
41 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.
//! API 统一分发器。
//!
//! 对应旧版 `lua/api.lua`。两类调用方、两套鉴权:
//!
//! ```text
//! /api/v1/* 账号态:请求头 X-API-Key(用户随机 Key)
//! /api/admin/* 管理员态:登录会话 Cookie(除 login 外均需登录且 role=admin)
//! ```
//!
//! 所有写操作完成后都会同步共享内存(`domains::sync_shm`),做到
//! 「审核一通过、立刻可访问」——注意新版**没有**回源读文件这条兜底路径,
//! 所以写穿不是优化而是正确性要求。
use std::collections::HashMap;
use ngx::core::{Pool, Status};
use ngx::ffi::ngx_http_request_t;
use ngx::http::HTTPStatus;
use serde_json::{Value, json};
use crate::apix;
use crate::config;
use crate::domains;
use crate::http;
use crate::models::User;
use crate::session;
use crate::state;
use crate::stats;
use crate::upstreams;
use crate::users;
use crate::util;
// ===========================================================================
// 路由
// ===========================================================================
/// 鉴权后传给处理器的身份
pub enum Actor {
/// 公开接口,无身份
None,
/// 账号态(X-API-Key)
User(User),
/// 管理员态(登录会话)
Admin(User),
}
impl Actor {
/// 操作者名称:审核记录 `reviewed_by`、审计日志都用它
fn admin_name(&self) -> &str {
match self {
Actor::Admin(u) => &u.username,
Actor::User(u) => &u.username,
Actor::None => "",
}
}
}
#[derive(Clone, Copy, PartialEq)]
enum Guard {
Public,
User,
Admin,
}
type Handler = fn(*mut ngx_http_request_t, Actor) -> Status;
/// 路由表。刻意用精确匹配而非正则——接口路径是固定的,
/// 正则只会引入「写错锚点导致前缀误匹配」的风险。
fn route(method: &str, uri: &str) -> Option<(Guard, Handler)> {
let entry: (Guard, Handler) = match (method, uri) {
("POST", "/api/admin/login") => (Guard::Public, h_login),
("POST", "/api/admin/logout") => (Guard::Admin, h_logout),
("GET", "/api/admin/session") => (Guard::Admin, h_session),
("GET", "/api/admin/users") => (Guard::Admin, h_admin_users),
("POST", "/api/admin/users/create") => (Guard::Admin, h_admin_user_create),
("POST", "/api/admin/users/key") => (Guard::Admin, h_admin_user_key),
("POST", "/api/admin/users/grant") => (Guard::Admin, h_admin_user_grant),
("POST", "/api/admin/users/password") => (Guard::Admin, h_admin_user_password),
("POST", "/api/admin/users/delete") => (Guard::Admin, h_admin_user_delete),
("POST", "/api/admin/users/models") => (Guard::Admin, h_admin_user_models),
("POST", "/api/admin/users/limits") => (Guard::Admin, h_admin_user_limits),
("POST", "/api/admin/users/display") => (Guard::Admin, h_admin_user_display),
("GET", "/api/admin/domains") => (Guard::Admin, h_admin_domains),
("POST", "/api/admin/domains/review") => (Guard::Admin, h_admin_domain_review),
("POST", "/api/admin/domains/create") => (Guard::Admin, h_admin_domain_create),
("POST", "/api/admin/domains/delete") => (Guard::Admin, h_admin_domain_delete),
("POST", "/api/admin/purge") => (Guard::Admin, h_admin_purge),
("GET", "/api/admin/upstreams") => (Guard::Admin, h_admin_upstreams),
("POST", "/api/admin/upstreams/save") => (Guard::Admin, h_admin_upstream_save),
("POST", "/api/admin/upstreams/test") => (Guard::Admin, h_admin_upstream_test),
("POST", "/api/admin/upstreams/delete") => (Guard::Admin, h_admin_upstream_delete),
("GET", "/api/admin/usage") => (Guard::Admin, h_admin_usage),
("GET", "/api/admin/trend") => (Guard::Admin, h_admin_trend),
("GET", "/api/admin/apix") => (Guard::Admin, h_admin_apix),
("POST", "/api/admin/apix/save") => (Guard::Admin, h_admin_apix_save),
("POST", "/api/admin/apix/delete") => (Guard::Admin, h_admin_apix_delete),
("POST", "/api/admin/apix/platform") => (Guard::Admin, h_admin_apix_platform),
("POST", "/api/admin/apix/price") => (Guard::Admin, h_admin_apix_price),
("POST", "/api/admin/apix/test") => (Guard::Admin, h_admin_apix_test),
("GET", "/api/v1/apix") => (Guard::User, h_my_apix),
("GET", "/api/v1/me") => (Guard::User, h_me),
("GET", "/api/v1/models") => (Guard::User, h_my_models),
("GET", "/api/v1/usage") => (Guard::User, h_my_usage),
("GET", "/api/v1/upstreams") => (Guard::User, h_my_upstreams),
("GET", "/api/v1/domains") => (Guard::User, h_my_domains),
("POST", "/api/v1/domains/apply") => (Guard::User, h_apply),
("POST", "/api/v1/domains/delete") => (Guard::User, h_my_delete),
_ => return None,
};
Some(entry)
}
/// 一次请求的完整处理:路由 → 鉴权 → 执行
pub fn dispatch(r: *mut ngx_http_request_t) -> Status {
let method = http::method_str(r);
let uri = http::uri(r);
let Some((guard, handler)) = route(&method, &uri) else {
return http::fail(
r,
HTTPStatus::NOT_FOUND,
&format!("接口不存在:{method} {uri}"),
);
};
let actor = match guard {
Guard::Public => Actor::None,
Guard::User => {
let key = http::header(r, "x-api-key").unwrap_or_default();
match users::find_by_key(&key) {
Some(u) => Actor::User(u),
None => {
util::log_warn(&format!(
"[api] API Key 校验失败 client={}",
http::remote_addr(r)
));
return http::fail(
r,
HTTPStatus::UNAUTHORIZED,
"API Key 无效或缺失,请在请求头携带 X-API-Key",
);
}
}
}
Guard::Admin => {
let cookie = http::header(r, "cookie");
match session::authenticate(cookie.as_deref()).and_then(|name| users::get(&name)) {
Some(u) if u.is_admin() => Actor::Admin(u),
// 会话有效但非管理员:403 而不是 401,便于前端区分
Some(_) => return http::fail(r, HTTPStatus::FORBIDDEN, "需要管理员权限"),
None => {
return http::fail(
r,
HTTPStatus::UNAUTHORIZED,
"未登录或会话已过期,请重新登录",
);
}
}
}
};
handler(r, actor)
}
// ===========================================================================
// 管理员:登录 / 会话
// ===========================================================================
fn h_login(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let ip = http::remote_addr(r);
let now = util::now();
if state::get_login_fail(&ip, now) >= config::LOGIN_MAX_FAIL {
return http::fail(r, HTTPStatus::TOO_MANY_REQUESTS, "登录失败次数过多,请 5 分钟后再试");
}
let p = http::params(r);
let username = p.get("username").map(|s| util::trim(s).to_owned()).unwrap_or_default();
let password = p.get("password").cloned().unwrap_or_default();
if username.is_empty() || password.is_empty() {
return http::fail(r, HTTPStatus::BAD_REQUEST, "请输入账号和密码");
}
let Some(user) = users::get(&username) else {
state::bump_login_fail(&ip, now);
util::log_warn(&format!("[api] 登录失败 user={username} client={ip}"));
return http::fail(r, HTTPStatus::UNAUTHORIZED, "账号或密码错误");
};
if !util::verify_password(&password, &user.salt, &user.pwd_hash) {
state::bump_login_fail(&ip, now);
util::log_warn(&format!("[api] 登录失败 user={username} client={ip}"));
return http::fail(r, HTTPStatus::UNAUTHORIZED, "账号或密码错误");
}
if !user.is_admin() {
return http::fail(r, HTTPStatus::FORBIDDEN, "该账号不是管理员,无法登录管理台");
}
state::clear_login_fail(&ip);
let token = session::create(&username);
let cookie = session::set_cookie(&token);
util::log_notice(&format!("[api] 管理员登录 user={username} client={ip}"));
http::ok_with(r, users::view(&user), "登录成功", &[("Set-Cookie", &cookie)])
}
fn h_logout(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let cookie = http::header(r, "cookie");
session::destroy(cookie.as_deref());
let cleared = session::clear_cookie();
http::ok_with(r, json!({}), "已退出登录", &[("Set-Cookie", &cleared)])
}
fn h_session(r: *mut ngx_http_request_t, actor: Actor) -> Status {
let Actor::Admin(user) = actor else {
return http::fail(r, HTTPStatus::UNAUTHORIZED, "未登录或会话已过期,请重新登录");
};
http::ok(r, users::view(&user), "ok")
}
// ===========================================================================
// 管理员:账号管理
// ===========================================================================
fn h_admin_users(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let mut counts: HashMap<String, usize> = HashMap::new();
for d in domains::all() {
*counts.entry(d.owner).or_insert(0) += 1;
}
let now = util::now();
// 一次扫表拿到所有人的 LLM 用量(含各自的上游明细),避免逐账号查共享内存
let usage: HashMap<String, stats::UserUsage> =
stats::all_users(now).into_iter().map(|u| (u.username.clone(), u)).collect();
let items: Vec<Value> = users::all()
.iter()
.map(|u| {
let mut v = users::view(u);
let mut usage_json = json!({ "today": 0, "total": 0, "last_ts": 0, "last_ts_text": "" });
if let Some(uu) = usage.get(&u.username) {
usage_json = uu.usage.json();
}
if let Value::Object(ref mut m) = v {
m.insert(
"domain_count".to_owned(),
json!(counts.get(&u.username).copied().unwrap_or(0)),
);
// 今日 LLM 用量:与热路径同一数据源(共享内存)——注意口径是
// **已转发**的请求,不含被限流/越权拒掉的那些
m.insert(
"llm_today".to_owned(),
json!(usage.get(&u.username).map(|x| x.usage.today).unwrap_or(0)),
);
m.insert("llm_usage".to_owned(), usage_json);
}
v
})
.collect();
http::ok(r, json!({ "items": items }), "ok")
}
fn h_admin_user_create(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let grant_temp = util::to_bool(p.get("grant_temp"));
match users::create(
p.get("username").map(String::as_str).unwrap_or(""),
p.get("display_name").map(String::as_str).unwrap_or(""),
p.get("password").map(String::as_str).unwrap_or(""),
p.get("role").map(String::as_str).unwrap_or("user"),
grant_temp,
) {
Ok(user) => {
util::log_notice(&format!(
"[api] 创建账号 {} name={} role={} temp_grant={grant_temp}",
user.username, user.display_name, user.role
));
http::ok(r, users::view(&user), "账号创建成功")
}
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
/// 设置展示名(中文姓名等)。传空串 = 清空,前端回落到账号名。
fn h_admin_user_display(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let username = p.get("username").map(|s| util::trim(s).to_owned()).unwrap_or_default();
match users::set_display_name(&username, p.get("display_name").map(String::as_str).unwrap_or("")) {
Ok(u) => http::ok(r, users::view(&u), "已更新展示名"),
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
fn h_admin_user_key(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let username = p.get("username").map(|s| util::trim(s).to_owned()).unwrap_or_default();
match users::regenerate_key(&username) {
Ok(key) => http::ok(r, json!({ "username": username, "api_key": key }), "已重置 API Key"),
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
fn h_admin_user_grant(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let username = p.get("username").map(|s| util::trim(s).to_owned()).unwrap_or_default();
if util::to_bool(p.get("revoke")) {
if let Err(e) = users::revoke_temp(&username) {
return http::fail(r, HTTPStatus::BAD_REQUEST, &e);
}
let view = users::get(&username).map(|u| users::view(&u)).unwrap_or(Value::Null);
return http::ok(r, view, "已取消临时授权权限");
}
match users::grant_temp(&username, p.get("hours")) {
Ok(_) => {
let view = users::get(&username).map(|u| users::view(&u)).unwrap_or(Value::Null);
http::ok(r, view, "已授予临时授权权限")
}
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
fn h_admin_user_password(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let username = p.get("username").map(|s| util::trim(s).to_owned()).unwrap_or_default();
let password = p.get("password").map(String::as_str).unwrap_or("");
match users::set_password(&username, password) {
Ok(()) => http::ok(r, json!({}), "密码已重置"),
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
fn h_admin_user_delete(r: *mut ngx_http_request_t, actor: Actor) -> Status {
let p = http::params(r);
let username = p.get("username").map(|s| util::trim(s).to_owned()).unwrap_or_default();
if let Err(e) = users::delete(&username, actor.admin_name()) {
return http::fail(r, HTTPStatus::BAD_REQUEST, &e);
}
// 连带回收该账号名下的域名,避免出现无主映射
let removed = domains::remove_by_owner(&username);
util::log_notice(&format!("[api] 删除账号 {username},连带域名 {removed} 条"));
http::ok(r, json!({ "removed_domains": removed }), "账号已删除")
}
// ===========================================================================
// 管理员:域名审核
// ===========================================================================
fn h_admin_domains(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
http::ok(
r,
json!({
"items": domains::view_all(&domains::all()),
"pending": domains::count_pending(),
// 子域名命名规则:前端据此渲染「i + 8位数字 + dm」输入框,
// 避免前后端各写一份前缀/后缀/zone 而漂移(真源 = config.rs)
"subdomain_rule": {
"zone": config::ENTERPRISE_ZONE,
"prefix": config::SUBDOMAIN_PREFIX,
"suffix": config::SUBDOMAIN_SUFFIX,
"digits": config::SUBDOMAIN_RAND_DIGITS,
},
}),
"ok",
)
}
fn h_admin_domain_review(r: *mut ngx_http_request_t, actor: Actor) -> Status {
let p = http::params(r);
let id = p.get("id").map(String::as_str).unwrap_or("");
let action = p.get("action").map(String::as_str).unwrap_or("");
match domains::review(id, action, actor.admin_name()) {
Ok(entry) => {
let msg = if action == "approve" { "已通过审核" } else { "已驳回" };
http::ok(r, domains::view(&entry), msg)
}
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
fn h_admin_domain_create(r: *mut ngx_http_request_t, actor: Actor) -> Status {
let p = http::params(r);
// subdomain 缺省(或空串)= 由网关按规则自动生成 `i<8位随机数字>dm`,
// 与面板上「i + 8位随机数 + dm」是同一套规则(见 domains::gen_subdomain)。
match domains::create_by_admin(
p.get("subdomain").map(String::as_str).unwrap_or(""),
p.get("backend").map(String::as_str).unwrap_or(""),
p.get("type"),
p.get("owner"),
actor.admin_name(),
) {
Ok(entry) => http::ok(r, domains::view(&entry), "已创建并直接放行"),
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
fn h_admin_domain_delete(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let id = p.get("id").map(String::as_str).unwrap_or("");
match domains::remove(id) {
Ok(sub) => http::ok(r, json!({ "subdomain": sub }), "已删除"),
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
fn h_admin_purge(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
match domains::purge() {
Ok(removed) => http::ok(
r,
json!({ "removed": removed }),
&format!("已清理 {removed} 条过期/陈旧记录"),
),
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
// ===========================================================================
// 账号态 API
// ===========================================================================
fn h_me(r: *mut ngx_http_request_t, actor: Actor) -> Status {
let Actor::User(user) = actor else {
return http::fail(r, HTTPStatus::UNAUTHORIZED, "API Key 无效或缺失,请在请求头携带 X-API-Key");
};
let mut v = users::view(&user);
if let Value::Object(ref mut m) = v {
m.insert(
"domains".to_owned(),
json!(domains::view_all(&domains::by_owner(&user.username))),
);
// 用量摘要(明细走 /api/v1/usage)——让客户端一个请求就能决定要不要自我节流
m.insert("llm_usage".to_owned(), stats::user(&user.username, util::now()).json());
m.insert(
"policy".to_owned(),
json!({
"temp_grant_ttl_hours": config::TEMP_GRANT_TTL / 3600,
"temp_domain_ttl_hours": config::TEMP_DOMAIN_TTL / 3600,
}),
);
}
http::ok(r, v, "ok")
}
fn h_my_domains(r: *mut ngx_http_request_t, actor: Actor) -> Status {
let Actor::User(user) = actor else {
return http::fail(r, HTTPStatus::UNAUTHORIZED, "API Key 无效或缺失,请在请求头携带 X-API-Key");
};
http::ok(
r,
json!({ "items": domains::view_all(&domains::by_owner(&user.username)) }),
"ok",
)
}
fn h_apply(r: *mut ngx_http_request_t, actor: Actor) -> Status {
let Actor::User(user) = actor else {
return http::fail(r, HTTPStatus::UNAUTHORIZED, "API Key 无效或缺失,请在请求头携带 X-API-Key");
};
let p = http::params(r);
let entry = match domains::apply(
&user.username,
p.get("subdomain").map(String::as_str).unwrap_or(""),
p.get("backend").map(String::as_str).unwrap_or(""),
p.get("type"),
) {
Ok(e) => e,
Err(e) => return http::fail(r, HTTPStatus::BAD_REQUEST, &e),
};
let view = domains::view(&entry);
util::log_notice(&format!(
"[api] {} 申请 {} type={} status={}",
user.username,
entry.subdomain,
entry.dtype,
entry.effective_status(util::now())
));
let msg = if entry.status == "approved" {
format!(
"已直接放行(临时授权权限生效),{} 小时后自动失效",
config::TEMP_DOMAIN_TTL / 3600
)
} else {
"已提交申请,等待管理员审核".to_owned()
};
http::ok(r, view, &msg)
}
fn h_my_delete(r: *mut ngx_http_request_t, actor: Actor) -> Status {
let Actor::User(user) = actor else {
return http::fail(r, HTTPStatus::UNAUTHORIZED, "API Key 无效或缺失,请在请求头携带 X-API-Key");
};
let p = http::params(r);
let id = p.get("id").map(String::as_str).unwrap_or("");
match domains::remove_own(id, &user.username) {
Ok(sub) => http::ok(r, json!({ "subdomain": sub }), "已删除"),
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
// ===========================================================================
// 管理员:LLM 上游
// ===========================================================================
fn h_admin_upstreams(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
http::ok(
r,
json!({ "items": upstreams::view_all(&upstreams::all(), &http::host_port(r)) }),
"ok",
)
}
fn h_admin_upstream_save(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
// 表单没提交 enabled 字段时视为「启用」——否则改个备注就会把上游改停,
// 这种误伤在管理台上极难自查
let enabled = match p.get("enabled") {
None => true,
Some(v) => util::to_bool(Some(v)),
};
// models 缺省 = 保持原清单;显式传(哪怕是空串)= 覆盖。
// 分隔符同时接受换行/逗号/顿号/分号——粘一份厂商文档里的模型列表是常见操作。
let models = p.get("models").map(|raw| parse_model_list(raw));
let slot_raw = p.get("slot").map(String::as_str).unwrap_or("");
match upstreams::upsert(
slot_raw,
p.get("base").map(String::as_str).unwrap_or(""),
models,
p.get("auth"),
enabled,
p.get("note"),
) {
Ok(up) => {
// 用校验后的 slot 回显;直接拿原始入参会把大小写差异带进响应
let slot = upstreams::validate_slot(slot_raw).unwrap_or_default();
util::log_notice(&format!(
"[api] 保存 LLM 上游 {slot} enabled={enabled} models={}",
up.models.len()
));
// base_url 带「调用方正在用的端口」:见 upstreams::base_url 的说明
http::ok(r, upstreams::view(&slot, &up, &http::host_port(r)), "已保存")
}
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
/// 把管理台/接口传入的模型列表串拆成模型名数组。
///
/// 允许的写法(混用也认):`a,b` / `a、b` / `a;b` / 一行一个。
pub fn parse_model_list(raw: &str) -> Vec<String> {
raw.split(|c: char| c == ',' || c == '、' || c == ';' || c == '\n' || c == '\r' || c == '\t')
.map(|s| util::trim(s).to_owned())
.filter(|s| !s.is_empty())
.collect()
}
fn h_admin_upstream_delete(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
match upstreams::remove(p.get("slot").map(String::as_str).unwrap_or("")) {
Ok(slot) => {
util::log_notice(&format!("[api] 删除 LLM 上游 {slot}"));
http::ok(r, json!({ "slot": slot }), "已删除")
}
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
/// 管理员:上游连通性测试(管理台「测试」按钮)。
///
/// 面板把 slot 放在 query(`?slot=x`),把**要发给上游的探测 JSON**(真实
/// chat/completions 请求,max_tokens=1)放在请求体——模块对体零改写。
/// 实现上校验 slot 存在后 `ngx_http_internal_redirect` 到管理 server 的
/// 内部 location `/_upstream_test/<slot>/v1/chat/completions`:
///
/// * `proxy_pass $llm_target` 原样复用 LLM 链路的取 slot / 拼路径 / 换真 Key
/// 逻辑(见 `llm::slot_of` 对 `/_upstream_test` 前缀的识别);
/// * 请求体在 API 两段式读取里已经进 `r->request_body`,内部重定向后由
/// proxy 原样转发;
/// * 上游的真实状态码与响应体直接透传给面板——通不通、错在哪个厂商,
/// 面板看到的就是厂商原话。
///
/// 为什么不能在浏览器里直测:上游真 Key 只存在服务端(面板只有掩码),
/// 且 lm 域名与 mdm 不同源,fetch 会被 CORS 拦住——测试必须在服务端发起。
fn h_admin_upstream_test(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let slot_raw = http::params(r).get("slot").cloned().unwrap_or_default();
let slot = match upstreams::validate_slot(&slot_raw) {
Ok(s) => s,
Err(e) => return http::fail(r, HTTPStatus::BAD_REQUEST, &e),
};
if state::get_upstream(&slot).is_none() {
return http::fail(r, HTTPStatus::NOT_FOUND, &format!("上游 {slot} 不存在"));
}
let uri = format!("/_upstream_test/{slot}/v1/chat/completions");
util::log_notice(&format!("[api] 测试 LLM 上游 {slot}"));
// ⚠️ nginx 的 internal_redirect 只**浅拷贝 ngx_str_t 结构体**(data 指针 + len),
// 不拷贝字节内容。若把栈上 String 的指针直接递过去,函数一返回堆内存就被回收,
// 之后 log 阶段读 r->uri 全是 NUL——健康标记、slot 解析全部静默失效(实测踩过)。
// 必须把 URI 字节拷进**请求池**,让它活到请求结束。
//
// SAFETY: r 有效;池内存在整个请求生命周期内有效。
unsafe {
let pool = Pool::from_ngx_pool((*r).pool);
let bytes = uri.as_bytes();
let data = pool.alloc(bytes.len()) as *mut u8;
if data.is_null() {
return http::fail(r, HTTPStatus::INTERNAL_SERVER_ERROR, "内存分配失败");
}
core::ptr::copy_nonoverlapping(bytes.as_ptr(), data, bytes.len());
let mut u = nginx_sys::ngx_str_t {
len: bytes.len(),
data,
};
let mut args = nginx_sys::ngx_str_t {
len: 0,
data: std::ptr::null_mut(),
};
nginx_sys::ngx_http_internal_redirect(r, &mut u, &mut args);
}
Status::NGX_DONE
}
/// 管理员:LLM 用量总览(每人 / 每上游 / 合计)。
///
/// 口径是**请求数**,且只统计真正转发出去的请求(见 `stats` 模块头注释)。
/// 想看 token 级用量得改架构(自建 upstream 拦响应体),不在本项目范围。
fn h_admin_usage(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
http::ok(r, stats::overview(util::now()), "ok")
}
/// 管理员:LLM 用量趋势(图表数据源)。
///
/// `days` 缺省 14 天,上限由 `config::TREND_DAYS_MAX` 兜住。
/// 按账号 / 按上游两个维度需要**先知道有哪些名字**(键里带日窗 id,扫不出来),
/// 所以这里把 users / upstreams 的名册传进去,由 stats 逐个精确取键。
fn h_admin_trend(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let days = p
.get("days")
.and_then(|v| util::trim(v).parse::<i64>().ok())
.unwrap_or_else(stats::trend_default_days);
let usernames: Vec<String> = users::all().into_iter().map(|u| u.username).collect();
// API 代理与 LLM 上游共用同一片用量键空间,只是 slot 带 `api/` 前缀
// (见 `config::APIX_STATS_PREFIX`)——这里一起列出,趋势图才会出现它们
let slots: Vec<String> = upstreams::all()
.into_iter()
.map(|(slot, _)| slot)
.chain(apix::all().into_iter().map(|(slug, _)| format!("{}{}", config::APIX_STATS_PREFIX, slug)))
.collect();
http::ok(r, stats::trend(util::now(), days, &usernames, &slots), "ok")
}
// ===========================================================================
// API 代理管理
// ===========================================================================
/// 管理员:API 代理清单 + 平台凭据状态
fn h_admin_apix(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let port = http::host_port(r);
let list = apix::all();
http::ok(
r,
json!({
"platform": apix::platform_view(),
"items": apix::view_all(&list, &port),
"count": list.len(),
}),
"ok",
)
}
/// 管理员:新增/修改一个 API 代理条目
fn h_admin_apix_save(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let slug = p.get("slug").cloned().unwrap_or_default();
let asset = p.get("asset_id").cloned().unwrap_or_default();
// 参数清单允许两种写法:逗号分隔(`q,format`)或 JSON 数组(`["q"]`)
let params = p.get("params").and_then(|v| {
let v = util::trim(v);
if v.is_empty() {
return None;
}
Some(if let Ok(Value::Array(arr)) = serde_json::from_str::<Value>(v) {
arr.into_iter()
.filter_map(|x| x.as_str().map(str::to_owned))
.collect::<Vec<String>>()
} else {
v.split(',').map(str::to_owned).collect::<Vec<String>>()
})
});
// 不带 enabled 视为「启用」:新建表单里漏勾是常见手滑,默认值取更安全的一侧
let enabled = match p.get("enabled") {
Some(v) => util::to_bool(Some(v)),
None => true,
};
match apix::upsert(
&slug,
&asset,
p.get("name"),
p.get("desc"),
params,
enabled,
p.get("note"),
) {
Ok(item) => {
util::log_notice(&format!("[api] 保存 API 代理 {slug} → {asset}"));
http::ok(r, json!({ "slug": slug, "asset_id": item.asset_id }), "已保存")
}
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
/// 管理员:删除一个 API 代理条目
fn h_admin_apix_delete(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
match apix::remove(p.get("slug").map(String::as_str).unwrap_or("")) {
Ok(slug) => {
util::log_notice(&format!("[api] 删除 API 代理 {slug}"));
http::ok(r, json!({ "slug": slug }), "已删除")
}
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
/// 管理员:设置市场基址与平台 Key
fn h_admin_apix_platform(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
match apix::set_platform(p.get("base"), p.get("key")) {
Ok(data) => {
util::log_notice(&format!(
"[api] 更新 API 代理平台配置 base={} key_set={}",
data.base,
!data.key.is_empty()
));
http::ok(
r,
json!({ "base": data.base, "key_set": !data.key.is_empty() }),
"已保存",
)
}
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
/// 管理员:回填展示用的单价快照(从市场目录同步下来的数字,不参与计费)
fn h_admin_apix_price(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let slug = p.get("slug").cloned().unwrap_or_default();
let num = |k: &str| -> f64 {
p.get(k)
.map(|v| util::trim(v).parse::<f64>().unwrap_or(0.0))
.unwrap_or(0.0)
};
if apix::validate_slug(&slug).is_err() {
return http::fail(r, HTTPStatus::BAD_REQUEST, "slug 不合法");
}
apix::set_price(&slug, num("price_per_call"), num("price_in"), num("price_out"));
http::ok(r, json!({ "slug": slug }), "ok")
}
/// 管理员:探测平台 Key 是否可用(管理台「测试」按钮)。
///
/// 走市场的**免费预估**接口(`/api/v1/ai/estimate`):它不执行资产、不扣费,
/// 响应里还带 `current_balance_usd` —— 一次调用同时拿到「Key 通不通」和
/// 「还剩多少钱」。实现上内部重定向到管理 server 的 `/_apix_probe/<slug>`,
/// 复用 `$apix_probe_*` 变量(拼体、换 Key 与真实转发同一套逻辑)。
fn h_admin_apix_test(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let slug_raw = http::params(r).get("slug").cloned().unwrap_or_default();
let slug = match apix::validate_slug(&slug_raw) {
Ok(s) => s,
Err(e) => return http::fail(r, HTTPStatus::BAD_REQUEST, &e),
};
if apix::lookup(&slug).is_none() {
return http::fail(r, HTTPStatus::NOT_FOUND, &format!("代理 {slug} 不存在或已停用"));
}
let uri = format!("{}{}", apix::PROBE_URI_PREFIX, slug);
util::log_notice(&format!("[api] 测试 API 代理 {slug}"));
// ⚠️ 与 h_admin_upstream_test 同一个坑:internal_redirect 只浅拷贝 ngx_str_t,
// 必须把字节拷进请求池,否则函数返回后 r->uri 全是 NUL。
// SAFETY: r 有效;池内存在整个请求生命周期内有效。
unsafe {
let pool = Pool::from_ngx_pool((*r).pool);
let bytes = uri.as_bytes();
let data = pool.alloc(bytes.len()) as *mut u8;
if data.is_null() {
return http::fail(r, HTTPStatus::INTERNAL_SERVER_ERROR, "内存分配失败");
}
core::ptr::copy_nonoverlapping(bytes.as_ptr(), data, bytes.len());
let mut u = nginx_sys::ngx_str_t { len: bytes.len(), data };
let mut args = nginx_sys::ngx_str_t {
len: 0,
data: core::ptr::null_mut(),
};
nginx_sys::ngx_http_internal_redirect(r, &mut u, &mut args);
}
Status::NGX_DONE
}
/// 账号态:列出当前可用的 API 代理及调用地址
fn h_my_apix(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let port = http::host_port(r);
let items: Vec<Value> = apix::all()
.into_iter()
.filter(|(_, it)| it.enabled)
.map(|(slug, it)| apix::view(&slug, &it, &port))
.collect();
http::ok(r, json!({ "items": items, "count": items.len() }), "ok")
}
/// 设置某账号可用的 LLM 上游白名单(`models` 字段 = 上游 slot 列表,传空串 = 解除限制)。
///
/// 注意与**上游登记模型清单**(`Upstream.models`)是两件事:这里管"这个账号能用哪几家
/// 上游",那里管"这家上游提供哪些模型"。白名单按 slot 生效,模型发现再按白名单过滤。
fn h_admin_user_models(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let username = p.get("username").map(|s| util::trim(s).to_owned()).unwrap_or_default();
let slots: Vec<String> = p
.get("models")
.map(|s| {
s.split(',')
.map(|x| x.trim().to_owned())
.filter(|x| !x.is_empty())
.collect()
})
.unwrap_or_default();
// 上游必须先存在:否则白名单里会存进永远匹配不上的死名字,
// 表现为「账号被授权了却一直 403」,排查起来很绕
for slot in &slots {
if upstreams::get(slot).is_none() {
return http::fail(r, HTTPStatus::BAD_REQUEST, &format!("上游 {slot} 不存在"));
}
}
match users::set_allowed_models(&username, slots) {
Ok(u) => http::ok(r, users::view(&u), "已更新可用上游"),
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
/// 设置账号的 LLM 限流参数。字段缺省 = 保持现值,`0` = 不限。
fn h_admin_user_limits(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
let p = http::params(r);
let username = p.get("username").map(|s| util::trim(s).to_owned()).unwrap_or_default();
let parse_limit = |key: &str| -> Result<Option<i64>, String> {
match p.get(key) {
None => Ok(None),
Some(v) if util::trim(v).is_empty() => Ok(None),
Some(v) => util::trim(v)
.parse::<i64>()
.map(Some)
.map_err(|_| format!("{key} 必须是非负整数(0 表示不限)")),
}
};
let rpm = match parse_limit("rpm") {
Ok(v) => v,
Err(e) => return http::fail(r, HTTPStatus::BAD_REQUEST, &e),
};
let daily = match parse_limit("daily") {
Ok(v) => v,
Err(e) => return http::fail(r, HTTPStatus::BAD_REQUEST, &e),
};
if rpm.is_none() && daily.is_none() {
return http::fail(r, HTTPStatus::BAD_REQUEST, "至少提供 rpm 或 daily 之一");
}
util::log_notice(&format!(
"[api] 设置账号 {username} LLM 限流 rpm={rpm:?} daily={daily:?}"
));
match users::set_llm_limits(&username, rpm, daily) {
Ok(u) => http::ok(r, users::view(&u), "已更新限流参数"),
Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e),
}
}
/// 账号态接口的公共前置:取账号身份,取不到就回 401。
fn user_or_401(r: *mut ngx_http_request_t, actor: Actor) -> Result<User, Status> {
match actor {
Actor::User(u) => Ok(u),
_ => Err(http::fail(
r,
HTTPStatus::UNAUTHORIZED,
"API Key 无效或缺失,请在请求头携带 X-API-Key",
)),
}
}
/// 账号态:看看自己能用哪些上游。
///
/// 刻意只回显 slot / base_url / **模型清单**——**不回显任何密钥**(连脱敏都不给,
/// 上游密钥与调用方无关,没有知道的必要)。
fn h_my_upstreams(r: *mut ngx_http_request_t, actor: Actor) -> Status {
// 回显的 base_url 必须带「调用方正在用的端口」,否则客户端照着拼会打不通
let port = http::host_port(r);
let user = match user_or_401(r, actor) {
Ok(u) => u,
Err(e) => return e,
};
let items: Vec<Value> = upstreams::available(&user.allowed_models)
.into_iter()
.map(|(slot, up)| {
let (status, code, checked_at) = match upstreams::health(&slot) {
Some((ok, c, ts)) => (if ok { "ok" } else { "failed" }, c, ts),
None => ("unknown", 0, 0),
};
json!({
"slot": slot,
"base_url": upstreams::base_url(&slot, &up, &port),
"anthropic_base_url": upstreams::anthropic_base_url(&slot, &up, &port),
"models": up.models,
"note": up.note,
"status": status,
"status_code": if code > 0 { json!(code) } else { Value::Null },
"checked_at": checked_at,
})
})
.collect();
http::ok(r, json!({ "items": items }), "ok")
}
/// 账号态:列出自己**可用的模型**(上游登记的模型清单,按白名单过滤)。
///
/// 与 LLM 域名下的 `GET /v1/models` 是同一份数据:那边给 OpenAI SDK 用
/// (形状 `{object:"list",data:[{id,...}]}`),这边给管理/自研客户端用
/// (形状 `{code,msg,data}`,带 base_url 便于直接拼请求)。
fn h_my_models(r: *mut ngx_http_request_t, actor: Actor) -> Status {
// 同 h_my_upstreams:base_url 跟随调用方所用的端口
let port = http::host_port(r);
let user = match user_or_401(r, actor) {
Ok(u) => u,
Err(e) => return e,
};
let available = upstreams::available(&user.allowed_models);
let mut items: Vec<Value> = Vec::new();
for (slot, up) in &available {
for model in &up.models {
items.push(json!({
"model": model,
"slot": slot,
"base_url": upstreams::base_url(slot, up, &port),
"note": up.note,
}));
}
}
http::ok(
r,
json!({
"items": items,
"upstreams": available
.iter()
.map(|(slot, up)| {
let (status, code, checked_at) = match upstreams::health(slot) {
Some((ok, c, ts)) => (if ok { "ok" } else { "failed" }, c, ts),
None => ("unknown", 0, 0),
};
json!({
"slot": slot,
"base_url": upstreams::base_url(slot, up, &port),
"anthropic_base_url": upstreams::anthropic_base_url(slot, up, &port),
"models": up.models,
"status": status,
"status_code": if code > 0 { json!(code) } else { Value::Null },
"checked_at": checked_at,
})
})
.collect::<Vec<_>>(),
}),
"ok",
)
}
/// 账号态:查自己的 LLM 用量(今日 / 累计 / 最近调用 + 分上游明细)。
fn h_my_usage(r: *mut ngx_http_request_t, actor: Actor) -> Status {
let user = match user_or_401(r, actor) {
Ok(u) => u,
Err(e) => return e,
};
let now = util::now();
let usage = stats::user(&user.username, now);
// token 计量(body filter 从上游 usage 抓的;抓不到 = 0,不补估)
let tin = stats::tokens_user(&user.username, now);
let models: Vec<Value> = stats::user_models(&user.username, now)
.into_iter()
.map(|(slot, u)| {
json!({
"slot": slot,
"today": u.today,
"total": u.total,
"last_ts": u.last_ts,
"last_ts_text": if u.last_ts > 0 { util::fmt_time(u.last_ts) } else { String::new() },
})
})
.collect();
http::ok(
r,
json!({
"username": user.username,
"display_name": user.display_name,
"today": usage.today,
"total": usage.total,
"last_ts": usage.last_ts,
"last_ts_text": if usage.last_ts > 0 { util::fmt_time(usage.last_ts) } else { String::new() },
"tokens": tin.json(),
"models": models,
// 限额一起回显:客户端可据此自我节流,不必等 429
"limits": { "rpm": user.llm_rpm, "daily": user.llm_daily },
}),
"ok",
)
}