//! 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::Status; use ngx::ffi::ngx_http_request_t; use ngx::http::HTTPStatus; use serde_json::{Value, json}; 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/delete") => (Guard::Admin, h_admin_upstream_delete), ("GET", "/api/admin/usage") => (Guard::Admin, h_admin_usage), ("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 = HashMap::new(); for d in domains::all() { *counts.entry(d.owner).or_insert(0) += 1; } let now = util::now(); // 一次扫表拿到所有人的 LLM 用量(含各自的上游明细),避免逐账号查共享内存 let usage: HashMap = stats::all_users(now).into_iter().map(|u| (u.username.clone(), u)).collect(); let items: Vec = 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(), }), "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); 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 { 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), } } /// 管理员: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 上游白名单(`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 = 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, String> { match p.get(key) { None => Ok(None), Some(v) if util::trim(v).is_empty() => Ok(None), Some(v) => util::trim(v) .parse::() .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 { 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 = upstreams::available(&user.allowed_models) .into_iter() .map(|(slot, up)| { json!({ "slot": slot, "base_url": upstreams::base_url(&slot, &up, &port), "models": up.models, "note": up.note, }) }) .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 = 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)| json!({ "slot": slot, "base_url": upstreams::base_url(slot, up, &port), "models": up.models, })) .collect::>(), }), "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); let models: Vec = 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() }, "models": models, // 限额一起回显:客户端可据此自我节流,不必等 429 "limits": { "rpm": user.llm_rpm, "daily": user.llm_daily }, }), "ok", ) }