use crate::error::{GarrisonError, GarrisonResult};
use limiteron::storage::QuotaStorage;
use std::time::Duration;
const RESOURCE_HOUR: &str = "hour";
const RESOURCE_DAY: &str = "day";
const HOUR_WINDOW: Duration = Duration::from_secs(3600);
const DAY_WINDOW: Duration = Duration::from_secs(86400);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum DualWindowExceeded {
Hourly,
Daily,
}
impl DualWindowExceeded {
pub(crate) fn as_str(self) -> &'static str {
match self {
Self::Hourly => "hourly",
Self::Daily => "daily",
}
}
}
#[derive(Debug)]
pub(crate) enum DualWindowError {
Exceeded(DualWindowExceeded),
Storage(String),
}
pub(crate) struct DualWindowQuota<S: QuotaStorage> {
storage: S,
hourly_limit: u64,
daily_limit: u64,
}
impl<S: QuotaStorage> DualWindowQuota<S> {
pub(crate) fn new(storage: S, hourly_limit: u32, daily_limit: u32) -> Self {
Self {
storage,
hourly_limit: u64::from(hourly_limit),
daily_limit: u64::from(daily_limit),
}
}
pub(crate) async fn consume_and_check(&self, identity: &str) -> Result<(), DualWindowError> {
let hour = self
.storage
.consume(identity, RESOURCE_HOUR, 1, self.hourly_limit, HOUR_WINDOW)
.await
.map_err(|e| DualWindowError::Storage(format!("secure-limiter-incr::{e}")))?;
if !hour.allowed {
return Err(DualWindowError::Exceeded(DualWindowExceeded::Hourly));
}
let day = self
.storage
.consume(identity, RESOURCE_DAY, 1, self.daily_limit, DAY_WINDOW)
.await;
let day = match day {
Ok(r) => r,
Err(e) => {
self.refund_quiet(identity, RESOURCE_HOUR, "hourly").await;
return Err(DualWindowError::Storage(format!(
"secure-limiter-incr::{e}"
)));
},
};
if !day.allowed {
self.refund_quiet(identity, RESOURCE_HOUR, "hourly").await;
return Err(DualWindowError::Exceeded(DualWindowExceeded::Daily));
}
Ok(())
}
pub(crate) async fn refund_windows(&self, identity: &str) -> GarrisonResult<()> {
let mut first_err: Option<GarrisonError> = None;
if let Err(e) = self.refund_mapped(identity, RESOURCE_HOUR).await {
tracing::warn!(
error = %e,
key = %ledger_key(RESOURCE_HOUR, identity),
"{}", crate::i18n::translate_detail("logs-secure-rollback-hourly-window-counter-failed", &[])
);
first_err.get_or_insert(e);
}
if let Err(e) = self.refund_mapped(identity, RESOURCE_DAY).await {
tracing::warn!(
error = %e,
key = %ledger_key(RESOURCE_DAY, identity),
"{}", crate::i18n::translate_detail("logs-secure-rollback-daily-window-counter-failed", &[])
);
first_err.get_or_insert(e);
}
match first_err {
Some(e) => Err(e),
None => Ok(()),
}
}
async fn refund_quiet(&self, identity: &str, resource: &str, label: &str) {
if let Err(e) = self.refund_mapped(identity, resource).await {
tracing::warn!(
error = %e,
key = %ledger_key(resource, identity),
"{}",
crate::i18n::translate_detail(
"logs-secure-rollback-window-counter-failed",
&[("label", label)]
)
);
}
}
async fn refund_mapped(&self, identity: &str, resource: &str) -> GarrisonResult<()> {
self.storage
.refund(identity, resource, 1, 0, Duration::ZERO)
.await
.map(|_| ())
.map_err(|e| GarrisonError::Dao(format!("secure-limiter-refund::{e}")))
}
}
fn ledger_key(resource: &str, identity: &str) -> String {
format!("quota:{resource}:{identity}")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::MockDao;
use crate::limiteron::storage::GarrisonDaoQuotaStorage;
use std::sync::Arc;
fn make_kernel(hourly: u32, daily: u32) -> DualWindowQuota<GarrisonDaoQuotaStorage> {
let dao = Arc::new(MockDao::new());
DualWindowQuota::new(GarrisonDaoQuotaStorage::new(dao), hourly, daily)
}
#[tokio::test]
async fn kernel_hourly_exceed_rejects_without_leak() {
let kernel = make_kernel(2, 100);
kernel.consume_and_check("ns:id").await.unwrap();
kernel.consume_and_check("ns:id").await.unwrap();
let err = kernel.consume_and_check("ns:id").await.unwrap_err();
assert!(
matches!(err, DualWindowError::Exceeded(DualWindowExceeded::Hourly)),
"第 3 次应返回 Hourly 超限"
);
assert!(
matches!(
kernel.consume_and_check("ns:id").await.unwrap_err(),
DualWindowError::Exceeded(DualWindowExceeded::Hourly)
),
"超限请求不应消耗配额(账本回滚后仍为 2)"
);
assert_eq!(DualWindowExceeded::Hourly.as_str(), "hourly");
assert_eq!(DualWindowExceeded::Daily.as_str(), "daily");
}
#[tokio::test]
async fn kernel_daily_exceed_refunds_hour() {
let kernel = make_kernel(100, 1);
kernel.consume_and_check("ns:id2").await.unwrap();
let err = kernel.consume_and_check("ns:id2").await.unwrap_err();
assert!(
matches!(err, DualWindowError::Exceeded(DualWindowExceeded::Daily)),
"第 2 次应返回 Daily 超限"
);
for _ in 0..100 {
let _ = kernel.consume_and_check("ns:id2").await;
}
kernel.refund_windows("ns:id2").await.unwrap();
kernel.refund_windows("ns:id2").await.unwrap();
}
#[tokio::test]
async fn kernel_refund_windows_clears_both() {
let dao = Arc::new(MockDao::new());
let kernel = DualWindowQuota::new(GarrisonDaoQuotaStorage::new(dao.clone()), 100, 100);
kernel.consume_and_check("ns:id3").await.unwrap();
kernel.refund_windows("ns:id3").await.unwrap();
let quota = GarrisonDaoQuotaStorage::new(dao);
assert!(
quota
.get_quota("ns:id3", RESOURCE_HOUR)
.await
.unwrap()
.is_none(),
"refund 后 hour 账本应归零删除"
);
assert!(
quota
.get_quota("ns:id3", RESOURCE_DAY)
.await
.unwrap()
.is_none(),
"refund 后 day 账本应归零删除"
);
kernel.refund_windows("ns:id3").await.unwrap();
}
#[tokio::test]
async fn kernel_ledger_key_is_time_independent() {
let dao = Arc::new(MockDao::new());
let kernel = DualWindowQuota::new(GarrisonDaoQuotaStorage::new(dao.clone()), 5, 5);
kernel.consume_and_check("ns:id4").await.unwrap();
let quota = GarrisonDaoQuotaStorage::new(dao);
let before = quota
.get_quota("ns:id4", RESOURCE_HOUR)
.await
.unwrap()
.unwrap();
assert_eq!(before.consumed, 1);
let again = quota
.get_quota("ns:id4", RESOURCE_HOUR)
.await
.unwrap()
.unwrap();
assert_eq!(again.consumed, 1);
}
}