use dashmap::DashMap;
use std::time::{Duration, Instant};
#[derive(Debug)]
struct FailureRecord {
count: u32,
window_start: Instant,
}
#[derive(Debug, Clone, Copy)]
pub struct FailureOutcome {
pub count: u32,
pub locked: bool,
pub retry_after_secs: u64,
}
#[derive(Debug)]
pub struct ApiKeyLockout {
records: DashMap<String, FailureRecord>,
threshold: u32,
window: Duration,
max_entries: usize,
}
const DEFAULT_MAX_ENTRIES: usize = 100_000;
impl ApiKeyLockout {
pub fn new(threshold: u32, window_secs: u64) -> Self {
Self {
records: DashMap::with_capacity(64),
threshold,
window: Duration::from_secs(window_secs),
max_entries: DEFAULT_MAX_ENTRIES,
}
}
pub fn threshold(&self) -> u32 {
self.threshold
}
pub fn check_locked(&self, source: &str) -> Option<u64> {
if self.threshold == 0 {
return None;
}
let record = self.records.get(source)?;
let elapsed = record.window_start.elapsed();
if elapsed >= self.window {
drop(record);
self.records.remove(source);
return None;
}
if record.count >= self.threshold {
Some(self.window.saturating_sub(elapsed).as_secs().max(1))
} else {
None
}
}
pub fn record_failure(&self, source: &str) -> FailureOutcome {
if self.threshold == 0 {
return FailureOutcome {
count: 0,
locked: false,
retry_after_secs: 0,
};
}
let outcome = {
let mut entry = self
.records
.entry(source.to_string())
.or_insert(FailureRecord {
count: 0,
window_start: Instant::now(),
});
if entry.window_start.elapsed() >= self.window {
entry.count = 0;
entry.window_start = Instant::now();
}
entry.count += 1;
FailureOutcome {
count: entry.count,
locked: entry.count >= self.threshold,
retry_after_secs: self.window.as_secs().max(1),
}
};
self.evict_if_over_capacity(source);
outcome
}
pub fn record_success(&self, source: &str) {
self.records.remove(source);
}
fn evict_if_over_capacity(&self, current: &str) {
if self.records.len() <= self.max_entries {
return;
}
let expired: Vec<String> = self
.records
.iter()
.filter(|e| e.value().window_start.elapsed() >= self.window)
.map(|e| e.key().clone())
.collect();
for key in expired {
self.records.remove(&key);
}
if self.records.len() <= self.max_entries {
return;
}
if let Some(oldest) = self
.records
.iter()
.filter(|e| e.key() != current)
.min_by_key(|e| e.value().window_start)
.map(|e| e.key().clone())
{
self.records.remove(&oldest);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn below_threshold_never_locks() {
let lockout = ApiKeyLockout::new(3, 300);
assert!(lockout.check_locked("1.2.3.4").is_none());
lockout.record_failure("1.2.3.4");
lockout.record_failure("1.2.3.4");
assert!(lockout.check_locked("1.2.3.4").is_none(), "2 < 3 不应锁定");
}
#[test]
fn reaches_threshold_locks_with_retry_after() {
let lockout = ApiKeyLockout::new(2, 300);
assert!(!lockout.record_failure("ip-a").locked);
let outcome = lockout.record_failure("ip-a");
assert!(outcome.locked, "第 2 次失败应触发锁定");
assert_eq!(outcome.retry_after_secs, 300);
let retry = lockout.check_locked("ip-a").expect("达阈值后应处于锁定中");
assert!(
(1..=300).contains(&retry),
"Retry-After 应在 1..=300,实际 {retry}"
);
}
#[test]
fn success_resets_count() {
let lockout = ApiKeyLockout::new(2, 300);
lockout.record_failure("ip-b");
lockout.record_success("ip-b");
let outcome = lockout.record_failure("ip-b");
assert!(!outcome.locked, "成功清零后重新计数,count=1 不应锁定");
assert!(lockout.check_locked("ip-b").is_none());
}
#[test]
fn window_expiry_unlocks_and_restarts() {
let lockout = ApiKeyLockout::new(1, 1);
assert!(lockout.record_failure("ip-c").locked);
assert!(lockout.check_locked("ip-c").is_some());
std::thread::sleep(Duration::from_millis(1100));
assert!(lockout.check_locked("ip-c").is_none(), "窗口过期应解除锁定");
let outcome = lockout.record_failure("ip-c");
assert!(outcome.locked, "过期后重新开窗,第 1 次失败即达阈值 1");
}
#[test]
fn zero_threshold_disables() {
let lockout = ApiKeyLockout::new(0, 300);
for _ in 0..100 {
let outcome = lockout.record_failure("ip-d");
assert!(!outcome.locked);
assert_eq!(outcome.count, 0, "禁用态不应记账");
}
assert!(lockout.check_locked("ip-d").is_none());
}
#[test]
fn sources_are_isolated() {
let lockout = ApiKeyLockout::new(2, 300);
lockout.record_failure("ip-e");
lockout.record_failure("ip-e");
assert!(lockout.check_locked("ip-e").is_some());
assert!(lockout.check_locked("ip-f").is_none());
}
fn lockout_with_capacity(
threshold: u32,
window_secs: u64,
max_entries: usize,
) -> ApiKeyLockout {
ApiKeyLockout {
records: DashMap::with_capacity(8),
threshold,
window: Duration::from_secs(window_secs),
max_entries,
}
}
#[test]
fn eviction_clears_expired_records_over_capacity() {
let lockout = lockout_with_capacity(3, 0, 2);
lockout.record_failure("ip-a");
lockout.record_failure("ip-b");
assert_eq!(lockout.records.len(), 2, "未超容量不应淘汰");
lockout.record_failure("ip-c");
assert_eq!(
lockout.records.len(),
0,
"超容量且全部过期时应清出过期记录,实际 {}",
lockout.records.len()
);
}
#[test]
fn eviction_drops_oldest_record_keeps_current() {
let lockout = lockout_with_capacity(3, 300, 2);
lockout.record_failure("ip-oldest");
std::thread::sleep(Duration::from_millis(2));
lockout.record_failure("ip-newer");
lockout.record_failure("ip-current");
assert_eq!(lockout.records.len(), 2, "超容量后应回落到容量内");
assert!(
!lockout.records.contains_key("ip-oldest"),
"最旧记录应被淘汰"
);
assert!(lockout.records.contains_key("ip-newer"), "较新记录应保留");
assert!(
lockout.records.contains_key("ip-current"),
"当前源 IP 不得被淘汰(本次记账语义正确性)"
);
}
}