后端(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
1055 lines
41 KiB
Rust
1055 lines
41 KiB
Rust
//! 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",
|
||
)
|
||
}
|