一个 slot 挂多把上游账号 Key,解决厂商「单账号额度/并发受限」与 「同一用户缓存命中」两个矛盾诉求。 多账号路由 (plugin-llm) - models: Upstream.accounts[] (auth/note/resets) + 上游级 exhaust_status/exhaust_markers;顶层 auth 保留兼容(accounts 为空时合成单账号) - upstreams::pick_account:粘性绑定 ukb:<key> 优先 → 无绑定时 FNV-1a(下游 Key) % 可用数 冷分散 → 绑定账号冷却则重新分散 → 全冷却取最早恢复 * 分散避开厂商单账号 agent 并发上限;落点固定保住 prompt/token 缓存 - cool_until_until 天锚定冷却:boundary = day0 + ceil(已过/窗口)*窗口, 封顶次日 0 点(MiniMax 5h 窗口、24=5*4+4 → 末段 20:00-24:00 只有 4h 随天重置) - 耗尽双检测 (log 阶段):$upstream_status 命中 exhaust_status,或 usage_filter 流式扫到 marker → $llm_acct 定位本次账号 → 写冷却 uac: - shm: up:/upa:/uac:/ukb:/upe: 五类前缀;$llm_acct 变量 (NOCACHEABLE) 账号级负载统计(问题发现与跟踪) - 新增 uda:<slot>:<idx>:<day>(请求/token)与 uex:(耗尽次数) 日桶, 复用内核 usage::bump_day —— 无数据库、无新进程(项目红线) - 计数点只在 log 阶段一次;pick_account 会被 $llm_target/$llm_auth/$llm_acct 三个变量各触发一次,放进那里会三倍计数 - view() 投影带每账号 load 与 account_trend + trend_labels(日期由后端算) - 管理台「上游」页密钥列:各 Key 今日请求/token/耗尽 + 负载比例条 + 14 天迷你趋势(自绘 SVG,零第三方依赖)+ 冷却/耗尽徽标 + 上游合计 测试与验证 - 回归 279 条全绿(网关 102 + LLM 177),新增 6 条多账号/负载断言 - 假上游新增 UPSTREAM_FAIL_AUTH 模拟账号额度耗尽;靶机验证 Key 真被替换 - 前端以真实 admin.css + upstreams.js 渲染路径做无头浏览器断言: 比例条与负载成比例(412 vs 96 → 100%/23%)、每账号 14 条块、 悬停峰值日期与数据逐位吻合、单账号/无账号兜底正常、无横向溢出、零 JS 错误 文档 - 新增 docs/llm/MULTI_ACCOUNT_ROUTING.md(数据模型/路由/冷却数学/shm 布局/负载统计) - readme §11 数据模型 + §15 上游配置 + §15 用量统计 + §12.6 tag 表 + §16 变更记录 - 修正 docs/llm/*.md 中插件化前的过时路径(rust/src/* → crates/plugin-llm/src/*)
926 lines
37 KiB
Rust
926 lines
37 KiB
Rust
//! LLM 上游配置与共享内存同步。
|
||
//!
|
||
//! 这是「转发映射」机制在 LLM 侧的翻版:`domains.rs` 管
|
||
//! `子域名 → 后端`,本模块管 `路径前缀(slot) → 上游(基址 + 密钥)`。
|
||
//! 两者都**写穿共享内存**,理由相同——热路径未命中即失败,不回源读文件。
|
||
//!
|
||
//! ## 为什么按 URL 前缀分上游,而不是按请求体里的 `model`
|
||
//!
|
||
//! 转发决策点在 access 阶段,而请求体要到 content 阶段才读得到
|
||
//! (见 `http::collect_body` 的调用前提)。按 `model` 字段分流就必须放弃
|
||
//! `proxy_pass`、自己实现 upstream 转发,代码量与出错面差一个数量级。
|
||
//! 代价只是客户端 base_url 需要带上 slot 段,可接受。
|
||
//!
|
||
//! `data/llm-upstreams.json` 含上游真实 API Key,**敏感级别等同 `users.json`**。
|
||
|
||
use serde_json::{Value, json};
|
||
|
||
use crate::config::{
|
||
ACCT_COOLDOWN_DEFAULT, ACCT_TREND_DAYS, AFFINITY_TTL_DEFAULT, EXHAUST_STATUS_DEFAULT,
|
||
KEY_UAC_PREFIX, KEY_UDAY_ACCT_PREFIX, KEY_UEX_PREFIX, KEY_UH_PREFIX, KEY_UKB_PREFIX,
|
||
KEY_UPA_PREFIX, KEY_UPE_PREFIX, KEY_UP_PREFIX, MODEL_NAME_MAX_LEN, RESET_DAY_OFFSET_SEC,
|
||
TREND_DAYS_MAX, TREND_KEEP_SECS, UPSTREAM_BASE_MAX_LEN, UPSTREAM_MODELS_MAX,
|
||
UPSTREAM_SLOT_MAX_LEN,
|
||
};
|
||
use crate::models::{Upstream, UpstreamAccount};
|
||
use crate::store;
|
||
use ipass_core::config::LLM_PUBLIC_HOST;
|
||
use ipass_core::{state, usage, util};
|
||
|
||
/// 共享内存 payload 的内部分隔符:base 与 auth 之间。
|
||
///
|
||
/// 与 `config::VAL_SEP`(0x1f,负责切 payload / expires_at)是两层不同的
|
||
/// 分隔,不能混用。base 是 URL、auth 是 `Bearer <token>`,都不可能含换行。
|
||
pub const PAYLOAD_SEP: char = '\n';
|
||
|
||
// ===========================================================================
|
||
// 校验
|
||
// ===========================================================================
|
||
|
||
/// slot:小写字母/数字开头,其后可含短横线、下划线,总长 ≤ 32。
|
||
///
|
||
/// 允许下划线(`azure_openai` 这类厂牌写法很常见),这点比子域名规则宽。
|
||
pub fn validate_slot(raw: &str) -> Result<String, String> {
|
||
let s = util::trim(raw).to_ascii_lowercase();
|
||
if s.is_empty() {
|
||
return Err("缺少 slot 参数".to_owned());
|
||
}
|
||
if s.len() > UPSTREAM_SLOT_MAX_LEN {
|
||
return Err(format!("slot 长度不能超过 {UPSTREAM_SLOT_MAX_LEN} 个字符"));
|
||
}
|
||
let bytes = s.as_bytes();
|
||
let head_ok = matches!(bytes[0], b'a'..=b'z' | b'0'..=b'9');
|
||
let tail_ok = bytes[1..].iter().all(|&b| matches!(b, b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_'));
|
||
if !head_ok || !tail_ok {
|
||
return Err("slot 只能是小写字母、数字、短横线或下划线,且不能以符号开头".to_owned());
|
||
}
|
||
Ok(s)
|
||
}
|
||
|
||
/// 模型名清单:去空白、去空项、去重、限长。
|
||
///
|
||
/// 刻意**允许** `/` `.` `:` 等字符——`Qwen/Qwen2.5-7B`(HF 风格)、
|
||
/// `llama3:8b`(Ollama 标签)都是合法模型名。只挡空白与控制字符,
|
||
/// 因为模型名要出现在 URL/JSON/HTML 里,空白只会带来歧义。
|
||
fn check_models(raw: &[String]) -> Result<Vec<String>, String> {
|
||
let mut out: Vec<String> = Vec::new();
|
||
for item in raw {
|
||
let m = util::trim(item);
|
||
if m.is_empty() {
|
||
continue;
|
||
}
|
||
if m.chars().count() > MODEL_NAME_MAX_LEN {
|
||
return Err(format!("模型名「{m}」超过 {MODEL_NAME_MAX_LEN} 个字符"));
|
||
}
|
||
if m.chars().any(char::is_whitespace) || m.chars().any(char::is_control) {
|
||
return Err(format!("模型名「{m}」不能包含空格或控制字符"));
|
||
}
|
||
if !out.iter().any(|x| x == m) {
|
||
out.push(m.to_owned());
|
||
}
|
||
}
|
||
if out.len() > UPSTREAM_MODELS_MAX {
|
||
return Err(format!("单个上游最多登记 {UPSTREAM_MODELS_MAX} 个模型"));
|
||
}
|
||
Ok(out)
|
||
}
|
||
|
||
/// 上游基址:必须显式带 `http://` 或 `https://`。
|
||
///
|
||
/// 比子域名的 `backend`(纯 host:port)宽——LLM 上游常挂在网关路径下
|
||
/// (如 `https://gw.corp.com/llm`),所以要允许尾随路径。
|
||
pub fn validate_base(raw: &str) -> Result<String, String> {
|
||
let s = util::trim(raw).trim_end_matches('/').to_owned();
|
||
if s.is_empty() {
|
||
return Err("缺少 base 参数".to_owned());
|
||
}
|
||
if s.len() > UPSTREAM_BASE_MAX_LEN {
|
||
return Err(format!("base 长度不能超过 {UPSTREAM_BASE_MAX_LEN} 个字符"));
|
||
}
|
||
let rest = if let Some(r) = s.strip_prefix("https://") {
|
||
r
|
||
} else if let Some(r) = s.strip_prefix("http://") {
|
||
r
|
||
} else {
|
||
return Err("base 必须以 http:// 或 https:// 开头,例如 https://api.openai.com".to_owned());
|
||
};
|
||
if rest.is_empty() {
|
||
return Err("base 缺少主机名".to_owned());
|
||
}
|
||
if rest.chars().any(char::is_whitespace) || rest.contains('@') {
|
||
return Err("base 不允许包含空格或用户信息(user@host)".to_owned());
|
||
}
|
||
if rest.split('/').next().unwrap_or("").is_empty() {
|
||
return Err("base 缺少主机名".to_owned());
|
||
}
|
||
Ok(s)
|
||
}
|
||
|
||
// ===========================================================================
|
||
// 共享内存同步(写穿 / 装载)
|
||
// ===========================================================================
|
||
|
||
/// 一个 slot 最多支持的账号下标(清理残留旧账号下标时遍历的上界)。
|
||
/// 实际部署不会接近这个数;超出部分不被支持(管理台会拦)。
|
||
const ACCOUNT_INDEX_MAX: usize = 64;
|
||
|
||
/// `up:<slot>` payload:`base \n <账号数>`。
|
||
fn up_payload(base: &str, n: usize) -> String {
|
||
format!("{base}\n{n}")
|
||
}
|
||
|
||
/// `upa:<slot>:<idx>` payload:`auth \n <resets csv>`(resets 空则第二段为空)。
|
||
fn upa_payload(auth: &str, resets: &[i64]) -> String {
|
||
let csv = resets
|
||
.iter()
|
||
.map(|x| x.to_string())
|
||
.collect::<Vec<_>>()
|
||
.join(",");
|
||
format!("{auth}\n{csv}")
|
||
}
|
||
|
||
/// 把一条上游配置同步进共享内存。**所有写操作之后必须调用它**。
|
||
///
|
||
/// 关闭(`enabled=false`)时是**删除**整个 slot 的键(up/upa/uac/upe),而不是
|
||
/// 写入空值——热路径「查不到 = 不可用」,停用即刻生效且不留残留。
|
||
///
|
||
/// 多账号布局(见 `config` 的键前缀注释):
|
||
/// * `up:<slot>` = `base \n <账号数>`
|
||
/// * `upa:<slot>:<i>` = `auth \n <resets csv>`(每个账号一条)
|
||
/// * `upe:<slot>` = `<status csv> \n <markers json>`(上游级耗尽探测配置)
|
||
/// * `uac:<slot>:<i>`(冷却运行时态)**不在此清除**——保留到自然到期,
|
||
/// 这样「正在冷却的账号」不会因为一次普通的 upsert(比如改备注)而莫名复活。
|
||
pub fn sync_shm(slot: &str, up: &Upstream) {
|
||
if !up.enabled {
|
||
remove_slot_shm(slot);
|
||
return;
|
||
}
|
||
let accts = up.effective_accounts();
|
||
|
||
if !state::put(
|
||
KEY_UP_PREFIX,
|
||
slot.as_bytes(),
|
||
up_payload(&up.base, accts.len()).as_bytes(),
|
||
0,
|
||
) {
|
||
util::log_err(&format!(
|
||
"[upstreams] 上游 base 写共享内存失败 slot={slot} —— 该上游会 404(共享内存可能已满)"
|
||
));
|
||
}
|
||
write_upe(slot, up);
|
||
|
||
for (i, a) in accts.iter().enumerate() {
|
||
let ak = format!("{slot}:{i}");
|
||
if !state::put(
|
||
KEY_UPA_PREFIX,
|
||
ak.as_bytes(),
|
||
upa_payload(&a.auth, &a.resets).as_bytes(),
|
||
0,
|
||
) {
|
||
util::log_err(&format!(
|
||
"[upstreams] 上游账号写共享内存失败 slot={slot}#{i} —— 该账号会 404"
|
||
));
|
||
}
|
||
}
|
||
// 清掉被删/被减的账号下标(i >= 现账号数),避免旧 upa/uac 残留被误读
|
||
for i in accts.len()..ACCOUNT_INDEX_MAX {
|
||
state::remove(KEY_UPA_PREFIX, format!("{slot}:{i}").as_bytes());
|
||
state::remove(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes());
|
||
}
|
||
}
|
||
|
||
/// 删除一个 slot 在共享内存里的全部键(up / upe / upa* / uac*)。
|
||
pub fn remove_slot_shm(slot: &str) {
|
||
state::remove(KEY_UP_PREFIX, slot.as_bytes());
|
||
state::remove(KEY_UPE_PREFIX, slot.as_bytes());
|
||
for i in 0..ACCOUNT_INDEX_MAX {
|
||
state::remove(KEY_UPA_PREFIX, format!("{slot}:{i}").as_bytes());
|
||
state::remove(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes());
|
||
}
|
||
}
|
||
|
||
/// 写上游级「额度耗尽」探测配置:`upe:<slot>` = `<status csv> \n <markers json>`。
|
||
fn write_upe(slot: &str, up: &Upstream) {
|
||
let status = up
|
||
.effective_exhaust_status()
|
||
.iter()
|
||
.map(|x| x.to_string())
|
||
.collect::<Vec<_>>()
|
||
.join(",");
|
||
let markers = serde_json::to_string(&up.exhaust_markers).unwrap_or_else(|_| "[]".to_owned());
|
||
let payload = format!("{status}\n{markers}");
|
||
if !state::put(KEY_UPE_PREFIX, slot.as_bytes(), payload.as_bytes(), 0) {
|
||
util::log_err(&format!("[upstreams] 上游耗尽配置写共享内存失败 slot={slot}"));
|
||
}
|
||
}
|
||
|
||
/// 全量重载上游表(启动装载 / 批量变更后)。返回装载条数。
|
||
///
|
||
/// 清 `up:` / `upa:` / `uac:` / `upe:` 四类前缀(**不**清 `ukb:` 粘性绑定——
|
||
/// 重启后重新绑定本就是预期语义)。
|
||
pub fn reload_shm() -> usize {
|
||
state::clear_prefix(KEY_UP_PREFIX);
|
||
state::clear_prefix(KEY_UPA_PREFIX);
|
||
state::clear_prefix(KEY_UAC_PREFIX);
|
||
state::clear_prefix(KEY_UPE_PREFIX);
|
||
let mut expected = 0;
|
||
let mut loaded = 0;
|
||
for (slot, up) in store::read_upstreams() {
|
||
if !up.enabled {
|
||
continue;
|
||
}
|
||
expected += 1;
|
||
let accts = up.effective_accounts();
|
||
if state::put(
|
||
KEY_UP_PREFIX,
|
||
slot.as_bytes(),
|
||
up_payload(&up.base, accts.len()).as_bytes(),
|
||
0,
|
||
) {
|
||
loaded += 1;
|
||
}
|
||
write_upe(&slot, &up);
|
||
for (i, a) in accts.iter().enumerate() {
|
||
let ak = format!("{slot}:{i}");
|
||
state::put(
|
||
KEY_UPA_PREFIX,
|
||
ak.as_bytes(),
|
||
upa_payload(&a.auth, &a.resets).as_bytes(),
|
||
0,
|
||
);
|
||
}
|
||
}
|
||
if loaded != expected {
|
||
util::log_err(&format!(
|
||
"[upstreams] 上游装载不全:{loaded}/{expected} —— 有上游会 404"
|
||
));
|
||
}
|
||
loaded
|
||
}
|
||
|
||
/// 读 `up:<slot>`:`(base, 账号数)`。
|
||
pub fn read_up(slot: &str) -> Option<(String, usize)> {
|
||
let (payload, _) = state::get(KEY_UP_PREFIX, slot.as_bytes())?;
|
||
let (base, nstr) = payload.split_once('\n').unwrap_or((&payload, "0"));
|
||
let n = nstr.trim().parse::<usize>().unwrap_or(0);
|
||
Some((base.to_owned(), n))
|
||
}
|
||
|
||
/// 读 `upa:<slot>:<i>`:`(auth, resets)`。
|
||
pub fn read_upa(slot: &str, i: usize) -> Option<(String, Vec<i64>)> {
|
||
let (payload, _) = state::get(KEY_UPA_PREFIX, format!("{slot}:{i}").as_bytes())?;
|
||
let (auth, rest) = payload.split_once('\n').unwrap_or((&payload, ""));
|
||
let resets = if rest.trim().is_empty() {
|
||
Vec::new()
|
||
} else {
|
||
rest.split(',')
|
||
.filter_map(|s| s.trim().parse::<i64>().ok())
|
||
.collect()
|
||
};
|
||
Some((auth.to_owned(), resets))
|
||
}
|
||
|
||
/// 读 `upe:<slot>`:`(status 列表, markers 列表)`。
|
||
pub fn read_upe(slot: &str) -> (Vec<i64>, Vec<String>) {
|
||
let (payload, _) = match state::get(KEY_UPE_PREFIX, slot.as_bytes()) {
|
||
Some(p) => p,
|
||
None => return (EXHAUST_STATUS_DEFAULT.to_vec(), Vec::new()),
|
||
};
|
||
let (status_str, markers_str) = payload.split_once('\n').unwrap_or((&payload, "[]"));
|
||
let status = if status_str.trim().is_empty() {
|
||
EXHAUST_STATUS_DEFAULT.to_vec()
|
||
} else {
|
||
status_str
|
||
.split(',')
|
||
.filter_map(|s| s.trim().parse::<i64>().ok())
|
||
.collect()
|
||
};
|
||
let markers = serde_json::from_str::<Vec<String>>(markers_str.trim())
|
||
.unwrap_or_else(|_| Vec::new());
|
||
(status, markers)
|
||
}
|
||
|
||
/// 某账号当前是否在「额度耗尽」冷却中(冷却键带 TTL,到期自动不再冷却)。
|
||
pub fn is_cooled(slot: &str, i: usize, now: i64) -> bool {
|
||
state::get_live(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes(), now).is_some()
|
||
}
|
||
|
||
/// 标记某账号额度耗尽,进入冷却直到「下一个重置边界」。
|
||
///
|
||
/// 重置窗口**锚定到「天」边界**(不是从 `now` 起的滚动窗口):MiniMax 这类厂商的
|
||
/// 5 小时额度是「从当天 0 点起每 5 小时」清零,而一天 24 小时不能被 5 整除
|
||
/// (24 = 5×4 + 4),所以最后一段窗口(20:00–24:00)只有 4 小时,到点随「天」一起重置。
|
||
/// 因此冷却边界 = 当天 0 点 + ceil(已过秒数 / 窗口) × 窗口,且**不超过「下一天 0 点」**
|
||
/// (否则会跨到次日 01:00 之类,与厂商口径不符)。多窗口取最早边界(先到先恢复)。
|
||
/// `resets` 全空 → 兜底 `ACCT_COOLDOWN_DEFAULT`(滚动 4 小时,非天锚定)。
|
||
///
|
||
/// 写入 `expires_at = until`,共享内存自然到期即视为恢复——无需额外清扫。
|
||
pub fn mark_exhausted(slot: &str, i: usize, resets: &[i64], now: i64) {
|
||
let until = if resets.is_empty() {
|
||
now + ACCT_COOLDOWN_DEFAULT
|
||
} else {
|
||
cool_until_until(resets, now)
|
||
};
|
||
if !state::put(
|
||
KEY_UAC_PREFIX,
|
||
format!("{slot}:{i}").as_bytes(),
|
||
until.to_string().as_bytes(),
|
||
until,
|
||
) {
|
||
util::log_err(&format!(
|
||
"[upstreams] 账号冷却写共享内存失败 slot={slot}#{i} —— 该账号不会被自动跳过"
|
||
));
|
||
} else {
|
||
util::log_warn(&format!(
|
||
"[upstreams] slot={slot} 账号#{i} 额度耗尽,冷却至 {}(约 {}s 后)",
|
||
util::fmt_time(until),
|
||
until.saturating_sub(now)
|
||
));
|
||
}
|
||
}
|
||
|
||
/// 计算「额度耗尽后冷却到哪个时刻」(天锚定,末窗封顶到次日 0 点)。
|
||
///
|
||
/// 见 `mark_exhausted` 注释:窗口从「天 0 点」(按 `RESET_DAY_OFFSET_SEC` 偏移,
|
||
/// 默认北京时间)起算,一天内的末段窗口因不能被整除而随「天」重置。
|
||
fn cool_until_until(resets: &[i64], now: i64) -> i64 {
|
||
const DAY: i64 = 86400;
|
||
let off = RESET_DAY_OFFSET_SEC;
|
||
// 最近一个「天 0 点」:t ≤ now 且 (t - off) 是 DAY 的整数倍
|
||
let k = (now - off).div_euclid(DAY);
|
||
let day0 = off + k * DAY;
|
||
let elapsed = now - day0;
|
||
let mut best = i64::MAX;
|
||
for &w in resets {
|
||
if w <= 0 {
|
||
continue;
|
||
}
|
||
// 下一个整周期边界;末段窗口封顶到「下一天 0 点」(与厂商天重置对齐)
|
||
let boundary = (day0 + (elapsed / w + 1) * w).min(day0 + DAY);
|
||
best = best.min(boundary);
|
||
}
|
||
best
|
||
}
|
||
|
||
/// 粘性绑定 TTL:取该账号最长重置周期,空则兜底 7 天。
|
||
fn affinity_ttl(resets: &[i64]) -> i64 {
|
||
if resets.is_empty() {
|
||
AFFINITY_TTL_DEFAULT
|
||
} else {
|
||
*resets.iter().max().unwrap()
|
||
}
|
||
}
|
||
|
||
/// 冷分配(无粘性绑定时)按下流 key 选一个「可用」账号下标。
|
||
///
|
||
/// 用 **FNV-1a 哈希(key) % n** 做确定性分散——同时满足了两件事:
|
||
/// * **均匀铺开**:不同下游 key 哈希值不同 → 落到不同上游账号,避免所有请求都压在
|
||
/// `account#0` 触发 MiniMax 这类厂商的「agent 并发上限」;
|
||
/// * **分配后保持**:同一 key 哈希值固定 → 永远落到同一账号(粘性绑定的前提),
|
||
/// 于是同一用户的请求始终由同一个上游账号处理,**prompt / token 缓存得以命中**
|
||
/// (否则同一会话的请求被轮到不同账号,缓存前缀对不上 → 命中率暴跌、等于白缓存)。
|
||
///
|
||
/// 下流 key 不存在(内部「测试」按钮 location 不带 Bearer)→ 退化为 nginx 自带伪随机
|
||
/// `ngx_random()`,仅用于分散探测/压测流量,不要求粘性。
|
||
fn cold_index(key: Option<&str>, n: usize) -> usize {
|
||
if n == 0 {
|
||
return 0;
|
||
}
|
||
let r = match key {
|
||
Some(k) => {
|
||
// FNV-1a 64:快、无依赖、同 key 同值(偏移 0xcbf29ce484232325 / 素数 0x100000001b3)。
|
||
// 选它是因为确定性可复现——本机回归能用同一段哈希精确预测首次落点,
|
||
// 既验证「分散」又验证「分配后保持」而不依赖全局随机源。
|
||
let mut h: u64 = 0xcbf2_9ce4_8423_2325;
|
||
for &b in k.as_bytes() {
|
||
h ^= b as u64;
|
||
h = h.wrapping_mul(0x100_0000_01b3);
|
||
}
|
||
h
|
||
}
|
||
None => nginx_sys::ngx_random() as u64,
|
||
};
|
||
(r % n as u64) as usize
|
||
}
|
||
|
||
/// 选上游账号:实现「用户 key → 上游账号」粘性 + 跳过冷却中账号 + 全冷却 best-effort。
|
||
///
|
||
/// 返回 `(选中账号下标, 该账号 auth, 上游 base)`。选不到返回 `None`(上游不可用)。
|
||
///
|
||
/// 决策顺序:
|
||
/// 1. 枚举该 slot 全部账号,区分「可用」(未冷却)与「冷却中」(带 `exhausted_until`);
|
||
/// 2. 有可用账号:
|
||
/// * 已粘性绑定 → 用绑定的那个(若该账号已不可用则按下流 key 重新分散);
|
||
/// * 未绑定 → 按下流 key 的 FNV-1a 哈希**分散**选一个(`cold_index`):
|
||
/// 把不同用户铺到不同上游账号,避免全部压在 `account#0` 触发 MiniMax 这类厂商的
|
||
/// 「agent 并发上限」;同时同一 key 哈希固定 → 永远落同一账号(粘性前提),
|
||
/// 于是同一用户的请求始终由同一上游账号处理,**prompt / token 缓存得以命中**;
|
||
/// 3. 全部冷却 → 挑 `exhausted_until` 最早的一个 best-effort 继续转发
|
||
/// (让上游回真实错误,而不是网关发明一个 5xx;冷却到期后会自动恢复);
|
||
/// 4. 真正选了账号且拿到下行 key 时,写 `ukb:` 粘性绑定(变化才写,避免每请求写)。
|
||
///
|
||
/// ⚠️ 只读 `up:` / `upa:` / `uac:` / `ukb:`,**不回源读文件**;未命中即视为不可用。
|
||
pub fn pick_account(
|
||
slot: &str,
|
||
key: Option<&str>,
|
||
now: i64,
|
||
) -> Option<(usize, String, String)> {
|
||
let (base, n) = read_up(slot)?;
|
||
if n == 0 {
|
||
return None;
|
||
}
|
||
|
||
let mut avail: Vec<(usize, String, Vec<i64>)> = Vec::new();
|
||
let mut cooled: Vec<(usize, String, i64, Vec<i64>)> = Vec::new();
|
||
for i in 0..n {
|
||
let (auth, resets) = read_upa(slot, i)?;
|
||
if is_cooled(slot, i, now) {
|
||
let eu = state::get(KEY_UAC_PREFIX, format!("{slot}:{i}").as_bytes())
|
||
.and_then(|(v, _)| v.trim().parse::<i64>().ok())
|
||
.unwrap_or(0);
|
||
cooled.push((i, auth, eu, resets));
|
||
} else {
|
||
avail.push((i, auth, resets));
|
||
}
|
||
}
|
||
|
||
let chosen: (usize, String, Vec<i64>) = if !avail.is_empty() {
|
||
// 粘性绑定优先
|
||
let bound = key.and_then(|k| {
|
||
state::get(KEY_UKB_PREFIX, k.as_bytes())
|
||
.and_then(|(v, _)| v.trim().parse::<usize>().ok())
|
||
});
|
||
if let Some(b) = bound {
|
||
if let Some(a) = avail.iter().find(|(i, _, _)| *i == b) {
|
||
(a.0, a.1.clone(), a.2.clone())
|
||
} else {
|
||
// 绑定的账号已被删/减:按下流 key 重新分散(不退化成永远 acct0)
|
||
let a = &avail[cold_index(key, avail.len())];
|
||
(a.0, a.1.clone(), a.2.clone())
|
||
}
|
||
} else {
|
||
// 无绑定:按下流 key 哈希分散选一个(均匀铺开 + 粘性前提)
|
||
let a = &avail[cold_index(key, avail.len())];
|
||
(a.0, a.1.clone(), a.2.clone())
|
||
}
|
||
} else if !cooled.is_empty() {
|
||
// 全冷却:挑最快恢复的一个
|
||
let c = cooled
|
||
.into_iter()
|
||
.min_by_key(|(_, _, eu, _)| *eu)
|
||
.map(|(i, auth, _, resets)| (i, auth, resets))
|
||
.unwrap();
|
||
(c.0, c.1, c.2)
|
||
} else {
|
||
return None;
|
||
};
|
||
|
||
// 写粘性绑定(仅当下行 key 存在且绑定变化)
|
||
if let Some(k) = key {
|
||
let cur = state::get(KEY_UKB_PREFIX, k.as_bytes()).map(|(v, _)| v.trim().to_owned());
|
||
if cur.as_deref() != Some(&chosen.0.to_string()) {
|
||
let ttl = affinity_ttl(&chosen.2);
|
||
state::put(
|
||
KEY_UKB_PREFIX,
|
||
k.as_bytes(),
|
||
chosen.0.to_string().as_bytes(),
|
||
now + ttl,
|
||
);
|
||
}
|
||
}
|
||
|
||
Some((chosen.0, chosen.1, base))
|
||
}
|
||
|
||
// ===========================================================================
|
||
// 账号级负载统计(shm 日桶,无数据库;与 uds:/udu: 同构)
|
||
// ===========================================================================
|
||
|
||
/// 账号级日桶键 = `<slot>:<idx>:<日窗id>`
|
||
fn acct_day_key(slot: &str, idx: usize, day: i64) -> String {
|
||
format!("{slot}:{idx}:{day}")
|
||
}
|
||
|
||
/// 记一次转发落到 `<slot>#<idx>`(请求数 +1)。log 阶段每真实转发调用一次。
|
||
///
|
||
/// ⚠️ 只在这里记——`pick_account` 会被 `$llm_target/$llm_auth/$llm_acct` 三个变量
|
||
/// 各触发一次,若在里面记会三倍计数;log 阶段经 `read_llm_acct` 取一次下标即可。
|
||
pub fn bump_acct_load(slot: &str, idx: usize, now: i64) {
|
||
let d = usage::DayBucket { requests: 1, ..Default::default() };
|
||
usage::bump_day(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, util::day_id(now)), &d, TREND_KEEP_SECS);
|
||
}
|
||
|
||
/// 账号级 token 负载(来源:body filter 从上游响应抓到的 usage)。log 阶段入账。
|
||
pub fn add_acct_tokens(slot: &str, idx: usize, tin: i64, tout: i64, now: i64) {
|
||
let d = usage::DayBucket { tin, tout, ..Default::default() };
|
||
usage::bump_day(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, util::day_id(now)), &d, TREND_KEEP_SECS);
|
||
}
|
||
|
||
/// 账号级额度耗尽次数 +1(仅指标,不参与路由)。
|
||
pub fn bump_acct_exhaust(slot: &str, idx: usize, now: i64) {
|
||
let d = usage::DayBucket { requests: 1, ..Default::default() };
|
||
usage::bump_day(KEY_UEX_PREFIX, &acct_day_key(slot, idx, util::day_id(now)), &d, TREND_KEEP_SECS);
|
||
}
|
||
|
||
/// 读某账号今日负载:`(requests, tin, tout, exhausts)`。
|
||
pub fn read_acct_load(slot: &str, idx: usize, now: i64) -> (i64, i64, i64, i64) {
|
||
let day = util::day_id(now);
|
||
let b = usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, day));
|
||
let e = usage::day_bucket(KEY_UEX_PREFIX, &acct_day_key(slot, idx, day));
|
||
(b.requests, b.tin, b.tout, e.requests)
|
||
}
|
||
|
||
/// 最近 `days` 天的日期标签(`MM-DD`),与 [`account_trend`] 的序列**逐位对齐**。
|
||
///
|
||
/// 由后端算而不是前端 `Date` 推导:日窗口径(`util::day_id` 的本地自然日)
|
||
/// 只应有一处定义,前端各算一份迟早会在跨时区/跨零点时对不上。
|
||
pub fn trend_labels(now: i64, days_req: i64) -> Vec<String> {
|
||
let days = days_req.clamp(1, TREND_DAYS_MAX);
|
||
(0..days).rev().map(|i| util::fmt_day(now - i * 86400)).collect()
|
||
}
|
||
|
||
/// 某 slot 各账号最近 `days` 天的负载序列(图表数据源,默认 14 天)。
|
||
///
|
||
/// 每个账号一条:`requests / in / out / exhausts` 四个等长数组,键精确取、
|
||
/// 不随历史增长。前端用 `requests` 画迷你趋势,一眼看出「哪把 Key 哪天扛了多少」。
|
||
pub fn account_trend(slot: &str, n: usize, now: i64, days_req: i64) -> Vec<Value> {
|
||
let days = days_req.clamp(1, TREND_DAYS_MAX);
|
||
let stamps: Vec<i64> = (0..days).rev().map(|i| now - i * 86400).collect();
|
||
let ids: Vec<i64> = stamps.iter().map(|t| util::day_id(*t)).collect();
|
||
let mut out = Vec::with_capacity(n);
|
||
for idx in 0..n {
|
||
let req: Vec<i64> = ids
|
||
.iter()
|
||
.map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).requests)
|
||
.collect();
|
||
let tin: Vec<i64> = ids
|
||
.iter()
|
||
.map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).tin)
|
||
.collect();
|
||
let tout: Vec<i64> = ids
|
||
.iter()
|
||
.map(|d| usage::day_bucket(KEY_UDAY_ACCT_PREFIX, &acct_day_key(slot, idx, *d)).tout)
|
||
.collect();
|
||
let ex: Vec<i64> = ids
|
||
.iter()
|
||
.map(|d| usage::day_bucket(KEY_UEX_PREFIX, &acct_day_key(slot, idx, *d)).requests)
|
||
.collect();
|
||
out.push(json!({
|
||
"idx": idx,
|
||
"requests": req,
|
||
"in": tin,
|
||
"out": tout,
|
||
"exhausts": ex,
|
||
}));
|
||
}
|
||
out
|
||
}
|
||
|
||
// ===========================================================================
|
||
// 查询
|
||
// ===========================================================================
|
||
|
||
/// 全部上游,按 slot 升序
|
||
pub fn all() -> Vec<(String, Upstream)> {
|
||
store::read_upstreams().into_iter().collect()
|
||
}
|
||
|
||
pub fn get(slot: &str) -> Option<Upstream> {
|
||
store::read_upstreams().remove(slot)
|
||
}
|
||
|
||
/// 某账号**可用**的上游(已启用,且在白名单内;`allowed` 为空 = 不限)。
|
||
///
|
||
/// 账号态接口与模型发现都用它,避免"能看见但不能用"或反之的两套判定。
|
||
pub fn available(allowed: &[String]) -> Vec<(String, Upstream)> {
|
||
all()
|
||
.into_iter()
|
||
.filter(|(slot, up)| {
|
||
up.enabled && (allowed.is_empty() || allowed.iter().any(|s| s == slot))
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// 客户端应当使用的 base_url。
|
||
///
|
||
/// 规则:**把上游 base 的 scheme+host 换成网关域名,路径原样保留**——
|
||
/// 这样它才真的能和厂商文档里的 base_url 逐个字符替换:
|
||
///
|
||
/// ```text
|
||
/// https://api.deepseek.com/v1 → https://lm.mayishangshu.cn:88/deepseek/v1
|
||
/// https://api.openai.com → https://lm.mayishangshu.cn:88/openai
|
||
/// ```
|
||
///
|
||
/// `port` 由调用方从请求 Host 头取(`http::host_port`),**不要写死**:
|
||
/// 部署在 88 时客户端必须带 `:88` 才连得到,而放在 443 反代后面时又必须不带端口。
|
||
/// 写死任何一种,都会在另一种部署里给出一个「看着对、实际打不通」的地址。
|
||
///
|
||
/// 反过来(不管上游 base 的路径、一律拼 `/v1`)会让「base 自带 /v1」的上游
|
||
/// 变成 `/v1/v1/chat/completions` → 上游 404,且客户端拿到的是空响应体,
|
||
/// 排查起来完全看不出是网关拼错了。**实测踩过,别再改回去。**
|
||
pub fn base_url(slot: &str, up: &Upstream, port: &str) -> String {
|
||
let rest = up.base.split("://").nth(1).unwrap_or("");
|
||
let path = match rest.find('/') {
|
||
Some(i) => &rest[i..],
|
||
None => "",
|
||
};
|
||
format!("https://{LLM_PUBLIC_HOST}{port}/{slot}{path}")
|
||
}
|
||
|
||
/// Anthropic 客户端(Claude Code / Claude SDK)应当使用的 `ANTHROPIC_BASE_URL`。
|
||
///
|
||
/// 协议段由**客户端**负责表达(网关不猜协议),但这段路径是网关替客户端拼好的,
|
||
/// 所以要处理重合:上游 `base` 若已钉在 `…/anthropic`(协议钉死型记录),其
|
||
/// `base_url` 末尾已经带 `/anthropic`,再无脑追加会得到 `…/anthropic/anthropic`。
|
||
pub fn anthropic_base_url(slot: &str, up: &Upstream, port: &str) -> String {
|
||
let b = base_url(slot, up, port);
|
||
if b.ends_with("/anthropic") {
|
||
b
|
||
} else {
|
||
format!("{b}/anthropic")
|
||
}
|
||
}
|
||
|
||
/// 模型发现:把可用上游挂载的模型摊平成 `(模型名, slot)` 列表。
|
||
///
|
||
/// 没登记 `models` 的上游不产出任何条目(清单未知 ≠ 有 0 个模型),
|
||
/// 但它的转发能力不受影响——模型发现只是"告诉你有什么",
|
||
/// 不是"允许你用什么"。
|
||
pub fn models_flat(allowed: &[String]) -> Vec<(String, String)> {
|
||
let mut out = Vec::new();
|
||
for (slot, up) in available(allowed) {
|
||
for model in &up.models {
|
||
out.push((model.clone(), slot.clone()));
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
// ===========================================================================
|
||
// 写入
|
||
// ===========================================================================
|
||
|
||
/// 新增或覆盖一个上游。
|
||
///
|
||
/// 参数语义(兼容旧调用方,同时支持多账号):
|
||
/// * `models = None` / `auth_raw = None` / `note = None` 都表示**保持原值**;
|
||
/// `Some("")` 表示显式清空。
|
||
/// * `accounts = Some(..)` 表示用多账号列表**整体替换**(此时顶层 `auth` 不再生效,
|
||
/// 写入时被清为 `""`,避免 `auth` 与 `accounts[0]` 重复);`None` 表示沿用旧逻辑
|
||
/// —— 用 `auth_raw` 维护单账号(legacy `auth` 字段)。
|
||
/// * `exhaust_status` / `exhaust_markers` 同理:`Some` 覆盖,`None` 保持原值。
|
||
///
|
||
/// `enabled = false` 会立刻从共享内存摘除。
|
||
pub fn upsert(
|
||
slot_raw: &str,
|
||
base_raw: &str,
|
||
models: Option<Vec<String>>,
|
||
auth_raw: Option<&String>,
|
||
accounts: Option<Vec<UpstreamAccount>>,
|
||
exhaust_status: Option<Vec<i64>>,
|
||
exhaust_markers: Option<Vec<String>>,
|
||
enabled: bool,
|
||
note: Option<&String>,
|
||
) -> Result<Upstream, String> {
|
||
let slot = validate_slot(slot_raw)?;
|
||
let base = validate_base(base_raw)?;
|
||
let models = match models {
|
||
Some(list) => Some(check_models(&list)?),
|
||
None => None,
|
||
};
|
||
|
||
let key = slot.clone();
|
||
let up = store::update_upstreams(move |table| {
|
||
// 先克隆出来:下面 insert 需要可变借用,不能与这里的不可变借用并存
|
||
let existing = table.get(&key).cloned();
|
||
|
||
// 多账号:整体替换(清掉顶层 auth,避免重复);否则走 legacy 单 auth
|
||
let (accounts, legacy_auth) = match accounts {
|
||
Some(list) => {
|
||
let existing_accounts = existing
|
||
.as_ref()
|
||
.map(|e| e.effective_accounts())
|
||
.unwrap_or_default();
|
||
// 账号 auth 留空 = 保留该下标原账号的密钥(编辑时前端只发掩码外的空串)
|
||
let merged: Vec<UpstreamAccount> = list
|
||
.into_iter()
|
||
.enumerate()
|
||
.map(|(i, mut a)| {
|
||
if a.auth.trim().is_empty() {
|
||
if let Some(old) = existing_accounts.get(i) {
|
||
a.auth = old.auth.clone();
|
||
}
|
||
}
|
||
a
|
||
})
|
||
.collect();
|
||
(merged, String::new())
|
||
}
|
||
None => (
|
||
Vec::new(),
|
||
match auth_raw {
|
||
Some(a) => util::trim(a).to_owned(),
|
||
None => existing.as_ref().map(|e| e.auth.clone()).unwrap_or_default(),
|
||
},
|
||
),
|
||
};
|
||
|
||
let note = match note {
|
||
Some(n) => util::trim(n).to_owned(),
|
||
None => existing.as_ref().map(|e| e.note.clone()).unwrap_or_default(),
|
||
};
|
||
let models = match models {
|
||
Some(m) => m,
|
||
None => existing.as_ref().map(|e| e.models.clone()).unwrap_or_default(),
|
||
};
|
||
let exhaust_status = match exhaust_status {
|
||
Some(s) => s,
|
||
None => existing
|
||
.as_ref()
|
||
.map(|e| e.exhaust_status.clone())
|
||
.unwrap_or_default(),
|
||
};
|
||
let exhaust_markers = match exhaust_markers {
|
||
Some(m) => m,
|
||
None => existing
|
||
.as_ref()
|
||
.map(|e| e.exhaust_markers.clone())
|
||
.unwrap_or_default(),
|
||
};
|
||
let created_at = existing
|
||
.as_ref()
|
||
.map(|e| e.created_at)
|
||
.filter(|&t| t > 0)
|
||
.unwrap_or_else(util::now);
|
||
|
||
let item = Upstream {
|
||
base,
|
||
models,
|
||
enabled,
|
||
note,
|
||
created_at,
|
||
accounts,
|
||
exhaust_status,
|
||
exhaust_markers,
|
||
auth: legacy_auth,
|
||
};
|
||
table.insert(key.clone(), item.clone());
|
||
Ok(item)
|
||
})?;
|
||
|
||
sync_shm(&slot, &up);
|
||
Ok(up)
|
||
}
|
||
|
||
/// 删除上游,并立刻从共享内存摘掉
|
||
pub fn remove(slot_raw: &str) -> Result<String, String> {
|
||
let slot = validate_slot(slot_raw)?;
|
||
let key = slot.clone();
|
||
|
||
store::update_upstreams(move |table| {
|
||
if table.remove(&key).is_none() {
|
||
return Err(format!("上游 {key} 不存在"));
|
||
}
|
||
Ok(())
|
||
})?;
|
||
|
||
state::remove(KEY_UP_PREFIX, slot.as_bytes());
|
||
Ok(slot)
|
||
}
|
||
|
||
// ===========================================================================
|
||
// 对外投影
|
||
// ===========================================================================
|
||
|
||
/// 转成管理台可见的字段。
|
||
///
|
||
/// **绝不回显完整 auth**——管理台页面会被截图、被浏览器插件读取,
|
||
/// 回显上游真 Key 等于把公司所有厂商密钥摆在一个 HTML 里。
|
||
///
|
||
/// 多账号:列出每个账号的掩码 auth / 备注 / 重置周期 / 当前是否冷却,
|
||
/// 便于运维直观看到「哪把 Key 在额度耗尽冷却中」。
|
||
pub fn view(slot: &str, up: &Upstream, port: &str) -> Value {
|
||
let (status, code, checked_at) = match health(slot) {
|
||
Some((ok, c, ts)) => (if ok { "ok" } else { "failed" }, c, ts),
|
||
None => ("unknown", 0, 0),
|
||
};
|
||
let now = util::now();
|
||
let accounts: Vec<Value> = up
|
||
.effective_accounts()
|
||
.into_iter()
|
||
.enumerate()
|
||
.map(|(i, a)| {
|
||
let (lr, lin, lout, lex) = read_acct_load(slot, i, now);
|
||
json!({
|
||
"idx": i,
|
||
"auth_set": !a.auth.is_empty(),
|
||
"auth_mask": if a.auth.is_empty() { "-".to_owned() } else { util::mask_key(&a.auth) },
|
||
"note": a.note,
|
||
"resets": a.resets,
|
||
"resets_text": resets_text(&a.resets),
|
||
"cooled": is_cooled(slot, i, now),
|
||
"load": {
|
||
"requests": lr,
|
||
"tokens_in": lin,
|
||
"tokens_out": lout,
|
||
"exhausts": lex,
|
||
},
|
||
})
|
||
})
|
||
.collect();
|
||
let has_auth = accounts.iter().any(|a| a["auth_set"] == Value::Bool(true));
|
||
// 各账号最近 14 天负载序列(图表数据源):用于管理台展示「哪把 Key 哪天扛了多少」
|
||
let acct_trend = account_trend(slot, accounts.len(), now, ACCT_TREND_DAYS);
|
||
let labels = trend_labels(now, ACCT_TREND_DAYS);
|
||
json!({
|
||
"slot": slot,
|
||
"base": up.base,
|
||
"base_url": base_url(slot, up, port),
|
||
"anthropic_base_url": anthropic_base_url(slot, up, port),
|
||
"models": up.models,
|
||
"model_count": up.models.len(),
|
||
"account_count": accounts.len(),
|
||
"auth_set": has_auth,
|
||
"enabled": up.enabled,
|
||
"note": up.note,
|
||
"exhaust_status": up.effective_exhaust_status(),
|
||
"exhaust_markers": up.exhaust_markers,
|
||
"accounts": accounts,
|
||
"account_trend": acct_trend,
|
||
"trend_labels": labels,
|
||
"created_at": up.created_at,
|
||
"created_at_text": util::fmt_time(up.created_at),
|
||
"status": status,
|
||
"status_code": if code > 0 { json!(code) } else { Value::Null },
|
||
"checked_at": checked_at,
|
||
"checked_at_text": if checked_at > 0 { util::fmt_time(checked_at) } else { String::new() },
|
||
})
|
||
}
|
||
|
||
/// 把重置周期数组渲染成人类可读文本,如 `[604800, 14400]` → "每周, 每4小时"。
|
||
fn resets_text(resets: &[i64]) -> String {
|
||
const H1: i64 = 3600;
|
||
const H2: i64 = 2 * 3600;
|
||
const H4: i64 = 4 * 3600;
|
||
const H6: i64 = 6 * 3600;
|
||
const H12: i64 = 12 * 3600;
|
||
const D1: i64 = 86400;
|
||
const W1: i64 = 7 * 86400;
|
||
resets
|
||
.iter()
|
||
.map(|&s| match s {
|
||
H1 => "每1小时".to_owned(),
|
||
H2 => "每2小时".to_owned(),
|
||
H4 => "每4小时".to_owned(),
|
||
H6 => "每6小时".to_owned(),
|
||
H12 => "每12小时".to_owned(),
|
||
D1 => "每天".to_owned(),
|
||
W1 => "每周".to_owned(),
|
||
_ => format!("每{}秒", s),
|
||
})
|
||
.collect::<Vec<_>>()
|
||
.join(", ")
|
||
}
|
||
|
||
pub fn view_all(list: &[(String, Upstream)], port: &str) -> Vec<Value> {
|
||
list.iter().map(|(slot, up)| view(slot, up, port)).collect()
|
||
}
|
||
|
||
// ===========================================================================
|
||
// 上游健康缓存(uh:)
|
||
// ===========================================================================
|
||
|
||
/// 记录一次上游真实响应结果。**只读端不会用它做任何决策**——转发路径
|
||
/// 从不查这份缓存,所以误标最多影响展示,不会误杀请求。
|
||
///
|
||
/// 写失败必须出声(热路径无回源兜底是转发侧的事,这里出声是为了
|
||
/// 别让「列表永远显示未探测」这种静默怪象无人解释)。
|
||
pub fn mark_health(slot: &str, ok: bool, code: i64) {
|
||
let ts = util::now();
|
||
let payload = format!("{}\n{}\n{}", if ok { 1 } else { 0 }, code, ts);
|
||
if !state::put(
|
||
KEY_UH_PREFIX,
|
||
slot.as_bytes(),
|
||
payload.as_bytes(),
|
||
ts + 30 * 86400,
|
||
) {
|
||
util::log_err(&format!("[upstreams] 健康状态写共享内存失败 slot={slot}"));
|
||
}
|
||
}
|
||
|
||
/// 读健康缓存:`Some((是否正常, 上游状态码, 记录时刻))`,没探测过 = `None`。
|
||
pub fn health(slot: &str) -> Option<(bool, i64, i64)> {
|
||
let (payload, _) = state::get(KEY_UH_PREFIX, slot.as_bytes())?;
|
||
let mut it = payload.split('\n');
|
||
let ok = it.next().unwrap_or("0").trim() == "1";
|
||
let code = it
|
||
.next()
|
||
.and_then(|s| s.trim().parse::<i64>().ok())
|
||
.unwrap_or(0);
|
||
let ts = it
|
||
.next()
|
||
.and_then(|s| s.trim().parse::<i64>().ok())
|
||
.unwrap_or(0);
|
||
Some((ok, code, ts))
|
||
}
|