use crate::dao::GarrisonDao;
use async_trait::async_trait;
use chrono::{DateTime, Utc};
use limiteron::error::StorageError;
use limiteron::storage::{BanHistory, BanRecord, BanStorage, BanTarget};
use std::sync::Arc;
use std::time::Duration;
use super::errors::map_to_storage_err;
const BAN_KEY_PREFIX: &str = "limiteron:ban";
const BAN_TIMES_KEY_PREFIX: &str = "limiteron:ban:times";
const BAN_HISTORY_KEY_PREFIX: &str = "limiteron:ban:history";
fn target_to_key_fragment(target: &BanTarget) -> String {
match target {
BanTarget::Ip(ip) => format!("ip:{}", ip),
BanTarget::UserId(uid) => format!("user:{}", uid),
BanTarget::Mac(mac) => format!("mac:{}", mac),
BanTarget::Geo { country_code } => format!("geo:{}", country_code),
BanTarget::Cidr(cidr) => format!("cidr:{}", cidr),
}
}
fn ban_record_key(target: &BanTarget) -> String {
format!("{}:{}", BAN_KEY_PREFIX, target_to_key_fragment(target))
}
fn ban_times_key(target: &BanTarget) -> String {
format!(
"{}:{}",
BAN_TIMES_KEY_PREFIX,
target_to_key_fragment(target)
)
}
fn ban_history_key(target: &BanTarget) -> String {
format!(
"{}:{}",
BAN_HISTORY_KEY_PREFIX,
target_to_key_fragment(target)
)
}
fn serialize_ban_record(record: &BanRecord) -> String {
format!(
"{}|{}|{}|{}|{}",
record.expires_at.timestamp(),
record.ban_times,
record.is_manual,
record.duration.as_secs(),
record.reason
)
}
fn deserialize_ban_record(target: &BanTarget, val: &str) -> Option<BanRecord> {
let parts: Vec<&str> = val.splitn(5, '|').collect();
let target_id = target_to_key_fragment(target);
if parts.len() != 5 {
tracing::warn!(
target = %target_id,
value = %val,
parts = parts.len(),
"{}",
crate::i18n::translate_detail("logs-limiteron-ban-record-parts-mismatch", &[])
);
return None;
}
let duration_secs: u64 = match parts[3].parse() {
Ok(v) => v,
Err(e) => {
tracing::warn!(
target = %target_id,
value = %val,
error = %e,
"{}",
crate::i18n::translate_detail("logs-limiteron-ban-duration-parse-failed", &[])
);
return None;
},
};
let expires_at_ts: i64 = match parts[0].parse() {
Ok(v) => v,
Err(e) => {
tracing::warn!(
target = %target_id,
value = %val,
error = %e,
"{}",
crate::i18n::translate_detail(
"logs-limiteron-ban-expires-at-parse-failed",
&[]
)
);
return None;
},
};
let ban_times: u32 = match parts[1].parse() {
Ok(v) => v,
Err(e) => {
tracing::warn!(
target = %target_id,
value = %val,
error = %e,
"{}",
crate::i18n::translate_detail("logs-limiteron-ban-times-parse-failed", &[])
);
return None;
},
};
let is_manual = parts[2] == "true";
let expires_at = match DateTime::from_timestamp(expires_at_ts, 0) {
Some(v) => v,
None => {
tracing::warn!(
target = %target_id,
expires_at_ts,
"{}",
crate::i18n::translate_detail("logs-limiteron-ban-timestamp-invalid", &[])
);
return None;
},
};
let duration = Duration::from_secs(duration_secs);
let banned_at = expires_at
- chrono::Duration::from_std(duration).unwrap_or_else(|_| chrono::Duration::seconds(0));
Some(BanRecord {
target: target.clone(),
ban_times,
duration,
banned_at,
expires_at,
is_manual,
reason: parts[4].to_string(),
})
}
pub struct GarrisonDaoBanStorage {
pub(super) dao: Arc<dyn GarrisonDao>,
}
impl GarrisonDaoBanStorage {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self { dao }
}
}
#[async_trait]
impl BanStorage for GarrisonDaoBanStorage {
async fn is_banned(&self, target: &BanTarget) -> Result<Option<BanRecord>, StorageError> {
let key = ban_record_key(target);
match self.dao.get(&key).await.map_err(map_to_storage_err)? {
None => Ok(None),
Some(val) => {
let record = deserialize_ban_record(target, &val);
if let Some(ref r) = record {
if r.expires_at <= Utc::now() {
return Ok(None);
}
}
Ok(record)
},
}
}
async fn save(&self, record: &BanRecord) -> Result<(), StorageError> {
let key = ban_record_key(&record.target);
let val = serialize_ban_record(record);
let ttl = (record.expires_at - Utc::now()).num_seconds().max(0) as u64;
self.dao
.set(&key, &val, ttl)
.await
.map_err(map_to_storage_err)?;
let times_key = ban_times_key(&record.target);
if let Err(e) = self
.dao
.set(×_key, &record.ban_times.to_string(), ttl)
.await
{
tracing::warn!(
ban_key = %key,
error = %e,
"{}",
crate::i18n::translate_detail("logs-limiteron-ban-times-key-write-failed", &[])
);
let _ = self.dao.delete(&key).await;
return Err(map_to_storage_err(e));
}
let history_key = ban_history_key(&record.target);
let history_val = format!("{}|{}", record.ban_times, Utc::now().timestamp());
if let Err(e) = self.dao.set(&history_key, &history_val, ttl).await {
tracing::warn!(
ban_key = %key,
error = %e,
"{}",
crate::i18n::translate_detail(
"logs-limiteron-ban-history-key-write-failed",
&[]
)
);
let _ = self.dao.delete(&key).await;
let _ = self.dao.delete(×_key).await;
return Err(map_to_storage_err(e));
}
Ok(())
}
async fn get_history(&self, target: &BanTarget) -> Result<Option<BanHistory>, StorageError> {
let key = ban_history_key(target);
match self.dao.get(&key).await.map_err(map_to_storage_err)? {
None => Ok(None),
Some(val) => {
let parts: Vec<&str> = val.splitn(2, '|').collect();
if parts.len() != 2 {
return Err(StorageError::QueryError(format!(
"limiteron-ban-history-format-error::{}::{}::{}",
key,
val,
parts.len()
)));
}
let ban_times: u32 = parts[0].parse().map_err(|e| {
StorageError::QueryError(format!(
"limiteron-ban-history-parse-ban-times::{}::{}::{}",
key, parts[0], e
))
})?;
let last_banned_at_ts: i64 = parts[1].parse().map_err(|e| {
StorageError::QueryError(format!(
"limiteron-ban-history-parse-last-banned::{}::{}::{}",
key, parts[1], e
))
})?;
let last_banned_at =
DateTime::from_timestamp(last_banned_at_ts, 0).unwrap_or_else(Utc::now);
Ok(Some(BanHistory {
ban_times,
last_banned_at,
}))
},
}
}
async fn increment_ban_times(&self, target: &BanTarget) -> Result<u64, StorageError> {
let key = ban_times_key(target);
let record_key = ban_record_key(target);
let ttl = match self
.dao
.get(&record_key)
.await
.map_err(map_to_storage_err)?
{
Some(val) => match deserialize_ban_record(target, &val) {
Some(record) if record.expires_at > Utc::now() => {
(record.expires_at - Utc::now()).num_seconds().max(1) as u64
},
_ => 0,
},
None => 0,
};
self.dao.incr(&key, ttl).await.map_err(map_to_storage_err)
}
async fn get_ban_times(&self, target: &BanTarget) -> Result<u64, StorageError> {
let key = ban_times_key(target);
match self.dao.get(&key).await.map_err(map_to_storage_err)? {
None => Ok(0),
Some(val) => val.parse::<u64>().map_err(|e| {
StorageError::QueryError(format!(
"limiteron-ban-times-parse-failed::{}::{}::{}",
key, val, e
))
}),
}
}
async fn remove_ban(&self, target: &BanTarget) -> Result<(), StorageError> {
let record_key = ban_record_key(target);
let times_key = ban_times_key(target);
let history_key = ban_history_key(target);
self.dao
.delete(&record_key)
.await
.map_err(map_to_storage_err)?;
self.dao
.delete(×_key)
.await
.map_err(map_to_storage_err)?;
self.dao
.delete(&history_key)
.await
.map_err(map_to_storage_err)
}
async fn cleanup_expired_bans(&self) -> Result<u64, StorageError> {
tracing::warn!(
"{}",
crate::i18n::translate_detail("logs-limiteron-ban-cleanup-unimplemented", &[])
);
Ok(0)
}
async fn list_bans(
&self,
_active_only: bool,
_offset: u64,
_limit: u64,
) -> Result<Vec<BanRecord>, StorageError> {
tracing::warn!(
"{}",
crate::i18n::translate_detail("logs-limiteron-ban-list-unimplemented", &[])
);
Ok(Vec::new())
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}
#[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 ban_save_and_is_banned() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::Ip("192.168.1.1".to_string());
assert!(storage.is_banned(&target).await.unwrap().is_none());
let record = BanRecord {
target: target.clone(),
ban_times: 1,
duration: Duration::from_secs(300),
banned_at: Utc::now(),
expires_at: Utc::now() + chrono::Duration::seconds(300),
is_manual: false,
reason: "bruteforce".to_string(),
};
storage.save(&record).await.unwrap();
let banned = storage.is_banned(&target).await.unwrap();
assert!(banned.is_some());
assert_eq!(banned.unwrap().ban_times, 1);
}
#[tokio::test]
async fn ban_expired_returns_none() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::Ip("10.0.0.1".to_string());
let record = BanRecord {
target: target.clone(),
ban_times: 1,
duration: Duration::from_secs(1),
banned_at: Utc::now() - chrono::Duration::seconds(10),
expires_at: Utc::now() - chrono::Duration::seconds(5), is_manual: false,
reason: "test".to_string(),
};
let key = ban_record_key(&target);
let val = serialize_ban_record(&record);
storage.dao.set(&key, &val, 0).await.unwrap();
assert!(storage.is_banned(&target).await.unwrap().is_none());
}
#[tokio::test]
async fn ban_increment_and_get_times() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::UserId("user123".to_string());
assert_eq!(storage.get_ban_times(&target).await.unwrap(), 0);
let t1 = storage.increment_ban_times(&target).await.unwrap();
assert_eq!(t1, 1);
let t2 = storage.increment_ban_times(&target).await.unwrap();
assert_eq!(t2, 2);
assert_eq!(storage.get_ban_times(&target).await.unwrap(), 2);
}
#[tokio::test]
async fn ban_increment_times_with_active_record() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::Ip("6.6.6.6".to_string());
let record = BanRecord {
target: target.clone(),
ban_times: 1,
duration: Duration::from_secs(300),
banned_at: Utc::now(),
expires_at: Utc::now() + chrono::Duration::seconds(300),
is_manual: false,
reason: "t".to_string(),
};
storage.save(&record).await.unwrap();
assert_eq!(
storage.get_ban_times(&target).await.unwrap(),
1,
"save 应以 record.ban_times 播种 times 计数"
);
assert_eq!(storage.increment_ban_times(&target).await.unwrap(), 2);
assert_eq!(storage.get_ban_times(&target).await.unwrap(), 2);
}
#[tokio::test]
async fn ban_save_rolls_back_on_history_failure() {
use crate::error::GarrisonError;
struct FailingHistoryDao {
inner: MockDao,
}
#[async_trait]
impl GarrisonDao for FailingHistoryDao {
async fn get(&self, key: &str) -> crate::error::GarrisonResult<Option<String>> {
self.inner.get(key).await
}
async fn set(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> crate::error::GarrisonResult<()> {
if key.starts_with("limiteron:ban:history:") {
return Err(GarrisonError::Dao("injected history failure".to_string()));
}
self.inner.set(key, value, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> crate::error::GarrisonResult<()> {
self.inner.update(key, value).await
}
async fn expire(&self, key: &str, seconds: u64) -> crate::error::GarrisonResult<()> {
self.inner.expire(key, seconds).await
}
async fn delete(&self, key: &str) -> crate::error::GarrisonResult<()> {
self.inner.delete(key).await
}
async fn incr(&self, key: &str, ttl_seconds: u64) -> crate::error::GarrisonResult<u64> {
self.inner.incr(key, ttl_seconds).await
}
async fn decr(&self, key: &str) -> crate::error::GarrisonResult<u64> {
self.inner.decr(key).await
}
async fn set_if_absent(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> crate::error::GarrisonResult<bool> {
self.inner.set_if_absent(key, value, ttl_seconds).await
}
async fn rename(
&self,
old_key: &str,
new_key: &str,
) -> crate::error::GarrisonResult<()> {
self.inner.rename(old_key, new_key).await
}
async fn get_and_delete(
&self,
key: &str,
) -> crate::error::GarrisonResult<Option<String>> {
self.inner.get_and_delete(key).await
}
async fn compare_and_swap(
&self,
key: &str,
expected: Option<&str>,
new_value: &str,
ttl_seconds: u64,
) -> crate::error::GarrisonResult<bool> {
self.inner
.compare_and_swap(key, expected, new_value, ttl_seconds)
.await
}
}
let storage = GarrisonDaoBanStorage::new(Arc::new(FailingHistoryDao {
inner: MockDao::new(),
}));
let target = BanTarget::Ip("5.5.5.5".to_string());
let record = BanRecord {
target: target.clone(),
ban_times: 1,
duration: Duration::from_secs(300),
banned_at: Utc::now(),
expires_at: Utc::now() + chrono::Duration::seconds(300),
is_manual: false,
reason: "t".to_string(),
};
let result = storage.save(&record).await;
assert!(result.is_err(), "history 写入失败时 save 应返回错误");
assert!(
storage.is_banned(&target).await.unwrap().is_none(),
"回滚后主记录不应残留"
);
assert!(
storage
.dao
.get(&ban_times_key(&target))
.await
.unwrap()
.is_none(),
"回滚后 times key 不应残留"
);
}
#[tokio::test]
async fn ban_remove() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::Ip("172.16.0.1".to_string());
let record = BanRecord {
target: target.clone(),
ban_times: 1,
duration: Duration::from_secs(300),
banned_at: Utc::now(),
expires_at: Utc::now() + chrono::Duration::seconds(300),
is_manual: true,
reason: "manual".to_string(),
};
storage.save(&record).await.unwrap();
assert!(storage.is_banned(&target).await.unwrap().is_some());
storage.remove_ban(&target).await.unwrap();
assert!(storage.is_banned(&target).await.unwrap().is_none());
assert_eq!(storage.get_ban_times(&target).await.unwrap(), 0);
}
#[tokio::test]
async fn ban_get_history() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::Mac("AA:BB:CC:DD:EE:FF".to_string());
let record = BanRecord {
target: target.clone(),
ban_times: 3,
duration: Duration::from_secs(900),
banned_at: Utc::now(),
expires_at: Utc::now() + chrono::Duration::seconds(900),
is_manual: false,
reason: "repeat".to_string(),
};
storage.save(&record).await.unwrap();
let history = storage.get_history(&target).await.unwrap();
assert!(history.is_some());
assert_eq!(history.unwrap().ban_times, 3);
}
#[tokio::test]
async fn ban_list_bans_returns_empty() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let bans = storage.list_bans(true, 0, 10).await.unwrap();
assert!(
bans.is_empty(),
"list_bans 应返回空 Vec(GarrisonDao 无 iter API)"
);
}
#[tokio::test]
async fn ban_cleanup_returns_zero() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let count = storage.cleanup_expired_bans().await.unwrap();
assert_eq!(
count, 0,
"cleanup_expired_bans 应返回 0(GarrisonDao 无 iter API)"
);
}
#[tokio::test]
async fn m3_ban_get_ban_times_dirty_data_returns_err() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::Ip("1.2.3.4".to_string());
let key = ban_times_key(&target);
storage.dao.set(&key, "not-a-number", 0).await.unwrap();
let result = storage.get_ban_times(&target).await;
assert!(result.is_err(), "脏数据应返回错误,实际: {:?}", result);
let err_msg = format!("{}", result.unwrap_err());
assert!(
err_msg.contains("limiteron-ban-times-parse-failed"),
"错误消息应包含 'limiteron-ban-times-parse-failed',实际: {}",
err_msg
);
}
#[tokio::test]
async fn m3_ban_get_history_dirty_data_returns_err() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::Ip("5.6.7.8".to_string());
let key = ban_history_key(&target);
storage.dao.set(&key, "not-number|1000", 0).await.unwrap();
let result = storage.get_history(&target).await;
assert!(result.is_err(), "脏数据应返回错误,实际: {:?}", result);
let err_msg = format!("{}", result.unwrap_err());
assert!(
err_msg.contains("limiteron-ban-history-parse-ban-times"),
"错误消息应包含 'limiteron-ban-history-parse-ban-times',实际: {}",
err_msg
);
}
#[test]
fn target_to_key_fragment_all_variants() {
assert_eq!(
target_to_key_fragment(&BanTarget::Ip("1.2.3.4".into())),
"ip:1.2.3.4"
);
assert_eq!(
target_to_key_fragment(&BanTarget::UserId("u123".into())),
"user:u123"
);
assert_eq!(
target_to_key_fragment(&BanTarget::Mac("AA:BB:CC".into())),
"mac:AA:BB:CC"
);
assert_eq!(
target_to_key_fragment(&BanTarget::Geo {
country_code: "CN".into()
}),
"geo:CN"
);
}
#[test]
fn ban_key_functions_correct_format() {
let target = BanTarget::Ip("10.0.0.1".to_string());
assert_eq!(ban_record_key(&target), "limiteron:ban:ip:10.0.0.1");
assert_eq!(ban_times_key(&target), "limiteron:ban:times:ip:10.0.0.1");
assert_eq!(
ban_history_key(&target),
"limiteron:ban:history:ip:10.0.0.1"
);
}
#[tokio::test]
async fn ban_serialize_deserialize_round_trip() {
let target = BanTarget::UserId("round_trip_user".to_string());
let original = BanRecord {
target: target.clone(),
ban_times: 3,
duration: Duration::from_secs(1234), banned_at: Utc::now(),
expires_at: Utc::now() + chrono::Duration::seconds(3600),
is_manual: true,
reason: "test_reason".to_string(),
};
let serialized = serialize_ban_record(&original);
let deserialized = deserialize_ban_record(&target, &serialized);
assert!(deserialized.is_some(), "反序列化应返回 Some");
let deserialized = deserialized.unwrap();
assert_eq!(deserialized.ban_times, 3);
assert!(deserialized.is_manual);
assert_eq!(deserialized.reason, "test_reason");
assert_eq!(deserialized.target, target);
assert_eq!(
deserialized.duration,
Duration::from_secs(1234),
"duration 应落盘恢复,而非被 ban_times*300 重算覆盖"
);
}
#[test]
fn ban_deserialize_4_part_corrupted_data_returns_none() {
let target = BanTarget::Ip("7.7.7.7".to_string());
let rec = deserialize_ban_record(&target, "1799999999|2|false|old_format_reason");
assert!(rec.is_none(), "4 段旧格式应视为损坏数据返回 None");
}
#[test]
fn ban_serialize_reason_with_delimiter_round_trip() {
let target = BanTarget::Ip("7.7.8.8".to_string());
let original = BanRecord {
target: target.clone(),
ban_times: 1,
duration: Duration::from_secs(300),
banned_at: Utc::now(),
expires_at: Utc::now() + chrono::Duration::seconds(300),
is_manual: false,
reason: "brute|force".to_string(),
};
let rec = deserialize_ban_record(&target, &serialize_ban_record(&original)).unwrap();
assert_eq!(rec.reason, "brute|force", "reason 中的 '|' 不应截断");
}
#[test]
fn ban_deserialize_malformed_data_returns_none() {
let target = BanTarget::Ip("1.1.1.1".to_string());
assert!(deserialize_ban_record(&target, "100|5").is_none());
assert!(deserialize_ban_record(&target, "100|5|true|reason").is_none());
assert!(deserialize_ban_record(&target, "100").is_none());
assert!(deserialize_ban_record(&target, "").is_none());
}
#[test]
fn ban_deserialize_non_numeric_returns_none() {
let target = BanTarget::Ip("2.2.2.2".to_string());
assert!(deserialize_ban_record(&target, "not_num|5|true|300|reason").is_none());
assert!(deserialize_ban_record(&target, "1000|not_num|true|300|reason").is_none());
assert!(deserialize_ban_record(&target, "1000|5|true|not_num|reason").is_none());
}
#[tokio::test]
async fn ban_get_history_wrong_parts_returns_err() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::Ip("9.9.9.9".to_string());
let key = ban_history_key(&target);
storage.dao.set(&key, "only_one_segment", 0).await.unwrap();
let result = storage.get_history(&target).await;
assert!(result.is_err(), "段数不对应返回错误");
let err_msg = format!("{}", result.unwrap_err());
assert!(
err_msg.contains("limiteron-ban-history-format-error"),
"错误消息应包含 'limiteron-ban-history-format-error',实际: {}",
err_msg
);
}
#[tokio::test]
async fn ban_get_history_non_numeric_ts_returns_err() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::Ip("8.8.8.8".to_string());
let key = ban_history_key(&target);
storage.dao.set(&key, "3|not_a_number", 0).await.unwrap();
let result = storage.get_history(&target).await;
assert!(result.is_err(), "非数字 ts 应返回错误");
}
#[tokio::test]
async fn ban_get_history_non_numeric_ban_times_returns_err() {
let storage = GarrisonDaoBanStorage::new(make_dao());
let target = BanTarget::Mac("AA:BB".to_string());
let key = ban_history_key(&target);
storage.dao.set(&key, "not_num|1000", 0).await.unwrap();
let result = storage.get_history(&target).await;
assert!(result.is_err(), "非数字 ban_times 应返回错误");
}
}