use crate::credit::cycle::CreditCycle;
use crate::credit::error::{CreditError, CreditResult};
use crate::dao::GarrisonDao;
use std::sync::Arc;
const CREDIT_KEY_PREFIX: &str = "credit";
fn credit_consumed_key(tenant_id: i64) -> String {
format!("{}:{}:consumed", CREDIT_KEY_PREFIX, tenant_id)
}
fn credit_meta_key(tenant_id: i64) -> String {
format!("{}:{}:meta", CREDIT_KEY_PREFIX, tenant_id)
}
fn credit_window_start_key(tenant_id: i64) -> String {
format!("{}:{}:window_start", CREDIT_KEY_PREFIX, tenant_id)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CreditMeta {
pub consumed: u64,
pub limit: u64,
pub window_start: i64,
pub window_end: i64,
pub cycle: CreditCycle,
}
pub struct CreditMeterStorage {
dao: Arc<dyn GarrisonDao>,
}
impl CreditMeterStorage {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self { dao }
}
pub async fn get_consumed(&self, tenant_id: i64) -> CreditResult<Option<u64>> {
let key = credit_consumed_key(tenant_id);
let val = self
.dao
.get(&key)
.await
.map_err(|e| CreditError::Dao(format!("credit-get-consumed::{}", e)))?;
match val {
Some(s) => {
let count: u64 = s.parse().map_err(|e| {
CreditError::Dao(format!(
"credit-consumed-parse-failed::{}::{}::{}",
key, s, e
))
})?;
Ok(Some(count))
},
None => Ok(None),
}
}
pub async fn incr_consumed(&self, tenant_id: i64, credits: u64, ttl: u64) -> CreditResult<u64> {
let key = credit_consumed_key(tenant_id);
let mut new_count = 0u64;
for _ in 0..credits {
new_count = self
.dao
.incr(&key, ttl)
.await
.map_err(|e| CreditError::Dao(format!("credit-incr-failed::{}", e)))?;
}
Ok(new_count)
}
pub async fn decr_consumed(&self, tenant_id: i64, times: u64) -> u64 {
let key = credit_consumed_key(tenant_id);
let mut count = 0u64;
for _ in 0..times {
match self.dao.decr(&key).await {
Ok(v) => count = v,
Err(e) => {
tracing::warn!(
tenant_id,
error = %e,
"{}",
crate::i18n::translate_detail("logs-credit-decr-rollback-failed", &[])
);
},
}
}
count
}
pub async fn get_meta(&self, tenant_id: i64) -> CreditResult<Option<CreditMeta>> {
let key = credit_meta_key(tenant_id);
let val = self
.dao
.get(&key)
.await
.map_err(|e| CreditError::Dao(format!("credit-get-meta::{}", e)))?;
match val {
Some(s) => {
let parts: Vec<&str> = s.split('|').collect();
if parts.len() != 6 {
return Err(CreditError::Dao(format!(
"credit-meta-format-error::{}::{}::expected 6 parts, got {}",
key,
s,
parts.len()
)));
}
let consumed: u64 = parts[0].parse().map_err(|e| {
CreditError::Dao(format!(
"credit-meta-consumed-parse-failed::{}::{}::{}",
key, parts[0], e
))
})?;
let limit: u64 = parts[1].parse().map_err(|e| {
CreditError::Dao(format!(
"credit-meta-limit-parse-failed::{}::{}::{}",
key, parts[1], e
))
})?;
let window_start: i64 = parts[2].parse().map_err(|e| {
CreditError::Dao(format!(
"credit-meta-window-start-parse-failed::{}::{}::{}",
key, parts[2], e
))
})?;
let window_end: i64 = parts[3].parse().map_err(|e| {
CreditError::Dao(format!(
"credit-meta-window-end-parse-failed::{}::{}::{}",
key, parts[3], e
))
})?;
let cycle_type = parts[4];
let cycle_param: u32 = parts[5].parse().map_err(|e| {
CreditError::Dao(format!(
"credit-meta-cycle-param-parse-failed::{}::{}::{}",
key, parts[5], e
))
})?;
let cycle = CreditCycle::from_tag(cycle_type, cycle_param).ok_or_else(|| {
CreditError::Dao(format!(
"credit-meta-unknown-cycle-type::{}::{}",
key, cycle_type
))
})?;
Ok(Some(CreditMeta {
consumed,
limit,
window_start,
window_end,
cycle,
}))
},
None => Ok(None),
}
}
pub async fn set_meta(&self, tenant_id: i64, meta: &CreditMeta, ttl: u64) -> CreditResult<()> {
let key = credit_meta_key(tenant_id);
let val = format!(
"{}|{}|{}|{}|{}|{}",
meta.consumed,
meta.limit,
meta.window_start,
meta.window_end,
meta.cycle.type_tag(),
meta.cycle.param()
);
self.dao
.set(&key, &val, ttl)
.await
.map_err(|e| CreditError::Dao(format!("credit-set-meta-failed::{}", e)))
}
pub async fn reset(&self, tenant_id: i64) -> CreditResult<()> {
let consumed_key = credit_consumed_key(tenant_id);
let meta_key = credit_meta_key(tenant_id);
let ws_key = credit_window_start_key(tenant_id);
if let Err(e) = self.dao.delete(&consumed_key).await {
tracing::warn!(
tenant_id,
error = %e,
"{}",
crate::i18n::translate_detail("logs-credit-reset-consumed-delete-failed", &[])
);
return Err(CreditError::Dao(format!("credit-reset-consumed::{}", e)));
}
if let Err(e) = self.dao.delete(&meta_key).await {
tracing::warn!(
tenant_id,
error = %e,
"{}",
crate::i18n::translate_detail("logs-credit-reset-meta-delete-failed", &[])
);
return Err(CreditError::Dao(format!("credit-reset-meta::{}", e)));
}
self.dao
.delete(&ws_key)
.await
.map_err(|e| CreditError::Dao(format!("credit-reset-window-start::{}", e)))?;
Ok(())
}
pub async fn get_window_start(&self, tenant_id: i64) -> CreditResult<Option<i64>> {
let key = credit_window_start_key(tenant_id);
let val = self
.dao
.get(&key)
.await
.map_err(|e| CreditError::Dao(format!("credit-get-window-start::{}", e)))?;
match val {
Some(s) => {
let ts: i64 = s.parse().map_err(|e| {
CreditError::Dao(format!(
"credit-window-start-parse-failed::{}::{}::{}",
key, s, e
))
})?;
Ok(Some(ts))
},
None => Ok(None),
}
}
pub async fn set_window_start(&self, tenant_id: i64, ts: i64, ttl: u64) -> CreditResult<()> {
let key = credit_window_start_key(tenant_id);
self.dao
.set(&key, &ts.to_string(), ttl)
.await
.map_err(|e| CreditError::Dao(format!("credit-set-window-start::{}", e)))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::MockDao;
fn make_dao() -> Arc<dyn GarrisonDao> {
Arc::new(MockDao::new())
}
#[tokio::test]
async fn test_incr_consumed_returns_new_count() {
let storage = CreditMeterStorage::new(make_dao());
let count = storage.incr_consumed(42, 3, 3600).await.unwrap();
assert_eq!(count, 3);
let count2 = storage.incr_consumed(42, 2, 3600).await.unwrap();
assert_eq!(count2, 5);
}
#[tokio::test]
async fn test_get_meta_parse_success() {
let storage = CreditMeterStorage::new(make_dao());
let meta = CreditMeta {
consumed: 100,
limit: 1000,
window_start: 1_700_000_000,
window_end: 1_702_592_000,
cycle: CreditCycle::Fixed { day_of_month: 1 },
};
storage.set_meta(42, &meta, 86400).await.unwrap();
let loaded = storage.get_meta(42).await.unwrap().unwrap();
assert_eq!(loaded.consumed, 100);
assert_eq!(loaded.limit, 1000);
assert_eq!(loaded.cycle, CreditCycle::Fixed { day_of_month: 1 });
}
#[tokio::test]
async fn test_get_meta_dirty_data_returns_err() {
let storage = CreditMeterStorage::new(make_dao());
storage
.dao
.set("credit:42:meta", "100|1000|bad", 0)
.await
.unwrap();
let result = storage.get_meta(42).await;
assert!(result.is_err(), "脏 meta 应返回 Err");
}
#[tokio::test]
async fn test_reset_clears_all_keys() {
let storage = CreditMeterStorage::new(make_dao());
storage.incr_consumed(42, 5, 3600).await.unwrap();
let meta = CreditMeta {
consumed: 5,
limit: 100,
window_start: 1_700_000_000,
window_end: 1_702_592_000,
cycle: CreditCycle::Fixed { day_of_month: 1 },
};
storage.set_meta(42, &meta, 3600).await.unwrap();
storage.reset(42).await.unwrap();
assert!(storage.get_consumed(42).await.unwrap().is_none());
assert!(storage.get_meta(42).await.unwrap().is_none());
}
#[tokio::test]
async fn test_get_consumed_missing_returns_none() {
let storage = CreditMeterStorage::new(make_dao());
assert!(storage.get_consumed(999).await.unwrap().is_none());
}
#[tokio::test]
async fn test_get_consumed_dirty_data_returns_err() {
let storage = CreditMeterStorage::new(make_dao());
storage
.dao
.set("credit:42:consumed", "not-a-number", 0)
.await
.unwrap();
let result = storage.get_consumed(42).await;
let err = result.unwrap_err();
assert!(
format!("{}", err).contains("consumed-parse-failed"),
"应报 consumed 解析错误: {}",
err
);
}
#[tokio::test]
async fn test_get_consumed_negative_value_returns_err() {
let storage = CreditMeterStorage::new(make_dao());
storage.dao.set("credit:7:consumed", "-5", 0).await.unwrap();
assert!(storage.get_consumed(7).await.is_err());
}
#[tokio::test]
async fn test_get_meta_missing_returns_none() {
let storage = CreditMeterStorage::new(make_dao());
assert!(storage.get_meta(12345).await.unwrap().is_none());
}
#[tokio::test]
async fn test_get_meta_consumed_parse_failed() {
let storage = CreditMeterStorage::new(make_dao());
storage
.dao
.set("credit:42:meta", "abc|100|1|2|fixed|1", 0)
.await
.unwrap();
let err = storage.get_meta(42).await.unwrap_err();
assert!(
format!("{}", err).contains("consumed-parse-failed"),
"实际: {}",
err
);
}
#[tokio::test]
async fn test_get_meta_limit_parse_failed() {
let storage = CreditMeterStorage::new(make_dao());
storage
.dao
.set("credit:42:meta", "1|abc|1|2|fixed|1", 0)
.await
.unwrap();
let err = storage.get_meta(42).await.unwrap_err();
assert!(
format!("{}", err).contains("limit-parse-failed"),
"实际: {}",
err
);
}
#[tokio::test]
async fn test_get_meta_window_start_parse_failed() {
let storage = CreditMeterStorage::new(make_dao());
storage
.dao
.set("credit:42:meta", "1|100|abc|2|fixed|1", 0)
.await
.unwrap();
let err = storage.get_meta(42).await.unwrap_err();
assert!(
format!("{}", err).contains("window-start-parse-failed"),
"实际: {}",
err
);
}
#[tokio::test]
async fn test_get_meta_window_end_parse_failed() {
let storage = CreditMeterStorage::new(make_dao());
storage
.dao
.set("credit:42:meta", "1|100|1|abc|fixed|1", 0)
.await
.unwrap();
let err = storage.get_meta(42).await.unwrap_err();
assert!(
format!("{}", err).contains("window-end-parse-failed"),
"实际: {}",
err
);
}
#[tokio::test]
async fn test_get_meta_cycle_param_parse_failed() {
let storage = CreditMeterStorage::new(make_dao());
storage
.dao
.set("credit:42:meta", "1|100|1|2|fixed|abc", 0)
.await
.unwrap();
let err = storage.get_meta(42).await.unwrap_err();
assert!(
format!("{}", err).contains("cycle-param-parse-failed"),
"实际: {}",
err
);
}
#[tokio::test]
async fn test_get_meta_unknown_cycle_type() {
let storage = CreditMeterStorage::new(make_dao());
storage
.dao
.set("credit:42:meta", "1|100|1|2|biweekly|14", 0)
.await
.unwrap();
let err = storage.get_meta(42).await.unwrap_err();
assert!(
format!("{}", err).contains("unknown-cycle-type"),
"实际: {}",
err
);
}
#[tokio::test]
async fn test_get_meta_rolling_roundtrip() {
let storage = CreditMeterStorage::new(make_dao());
let meta = CreditMeta {
consumed: 7,
limit: 0,
window_start: 1_700_000_000,
window_end: 1_702_592_000,
cycle: CreditCycle::Rolling { days: 14 },
};
storage.set_meta(9, &meta, 86400).await.unwrap();
let loaded = storage.get_meta(9).await.unwrap().unwrap();
assert_eq!(loaded, meta);
}
#[tokio::test]
async fn test_get_window_start_missing_returns_none() {
let storage = CreditMeterStorage::new(make_dao());
assert!(storage.get_window_start(42).await.unwrap().is_none());
}
#[tokio::test]
async fn test_set_then_get_window_start_roundtrip() {
let storage = CreditMeterStorage::new(make_dao());
storage
.set_window_start(42, 1_700_000_000, 3600)
.await
.unwrap();
assert_eq!(
storage.get_window_start(42).await.unwrap(),
Some(1_700_000_000)
);
}
#[tokio::test]
async fn test_get_window_start_dirty_data_returns_err() {
let storage = CreditMeterStorage::new(make_dao());
storage
.dao
.set("credit:42:window_start", "oops", 0)
.await
.unwrap();
let err = storage.get_window_start(42).await.unwrap_err();
assert!(
format!("{}", err).contains("window-start-parse-failed"),
"实际: {}",
err
);
}
#[tokio::test]
async fn test_reset_clears_window_start() {
let storage = CreditMeterStorage::new(make_dao());
storage
.set_window_start(42, 1_700_000_000, 3600)
.await
.unwrap();
storage.reset(42).await.unwrap();
assert!(storage.get_window_start(42).await.unwrap().is_none());
}
#[tokio::test]
async fn test_incr_consumed_zero_credits() {
let storage = CreditMeterStorage::new(make_dao());
let count = storage.incr_consumed(42, 0, 3600).await.unwrap();
assert_eq!(count, 0, "credits=0 应返回 0");
assert!(storage.get_consumed(42).await.unwrap().is_none());
}
#[tokio::test]
async fn test_incr_consumed_accumulates() {
let storage = CreditMeterStorage::new(make_dao());
storage.incr_consumed(42, 600, 3600).await.unwrap();
let count = storage.incr_consumed(42, 400, 3600).await.unwrap();
assert_eq!(count, 1000);
assert_eq!(storage.get_consumed(42).await.unwrap(), Some(1000));
}
#[tokio::test]
async fn test_tenant_isolation_between_counters() {
let storage = CreditMeterStorage::new(make_dao());
storage.incr_consumed(1, 5, 3600).await.unwrap();
storage.incr_consumed(2, 10, 3600).await.unwrap();
assert_eq!(storage.get_consumed(1).await.unwrap(), Some(5));
assert_eq!(storage.get_consumed(2).await.unwrap(), Some(10));
storage.incr_consumed(-1, 3, 3600).await.unwrap();
assert_eq!(storage.get_consumed(-1).await.unwrap(), Some(3));
assert_eq!(storage.get_consumed(1).await.unwrap(), Some(5));
}
#[tokio::test]
async fn test_key_format_uses_credit_prefix() {
let storage = CreditMeterStorage::new(make_dao());
storage.incr_consumed(42, 1, 3600).await.unwrap();
let consumed = storage.dao.get("credit:42:consumed").await.unwrap();
assert_eq!(
consumed,
Some("1".to_string()),
"consumed 键应为 credit:42:consumed"
);
let meta = CreditMeta {
consumed: 1,
limit: 100,
window_start: 1,
window_end: 2,
cycle: CreditCycle::Fixed { day_of_month: 1 },
};
storage.set_meta(42, &meta, 3600).await.unwrap();
let raw_meta = storage.dao.get("credit:42:meta").await.unwrap().unwrap();
assert_eq!(
raw_meta, "1|100|1|2|fixed|1",
"meta 序列化格式应为 6 段管道分隔"
);
storage.set_window_start(42, 77, 3600).await.unwrap();
let ws = storage.dao.get("credit:42:window_start").await.unwrap();
assert_eq!(
ws,
Some("77".to_string()),
"window_start 键应为 credit:42:window_start"
);
}
}