use crate::constants::DaoKeyPrefix;
use crate::error::GarrisonResult;
use std::sync::Arc;
use crate::dao::GarrisonDao;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct WarmupStats {
pub roles_loaded: u32,
pub tenants_loaded: u32,
}
pub struct CacheWarmupService {
dao: Arc<dyn GarrisonDao>,
}
impl CacheWarmupService {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self { dao }
}
pub async fn warmup(&self) -> GarrisonResult<WarmupStats> {
let role_pattern = format!("{}*", DaoKeyPrefix::Role.as_str());
let tenant_pattern = format!("{}*", DaoKeyPrefix::Tenant.as_str());
let role_keys = match self.dao.keys(&role_pattern).await {
Ok(keys) => keys,
Err(crate::error::GarrisonError::NotImplemented(_)) => {
tracing::warn!(
"DAO backend does not support role keys(), role warmup skipped (tenants still warmed)"
);
Vec::new()
},
Err(e) => return Err(e),
};
let tenant_keys = match self.dao.keys(&tenant_pattern).await {
Ok(keys) => keys,
Err(crate::error::GarrisonError::NotImplemented(_)) => {
tracing::warn!(
"DAO backend does not support tenant keys(), tenant warmup skipped (roles still warmed)"
);
Vec::new()
},
Err(e) => return Err(e),
};
let mut roles_loaded: u32 = 0;
for key in &role_keys {
if self.dao.get(key).await?.is_some() {
roles_loaded += 1;
}
}
let mut tenants_loaded: u32 = 0;
for key in &tenant_keys {
if self.dao.get(key).await?.is_some() {
tenants_loaded += 1;
}
}
Ok(WarmupStats {
roles_loaded,
tenants_loaded,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn warmup_loads_role_permissions() {
let dao = Arc::new(crate::dao::InMemoryDao::new());
dao.set("role:admin", "perm1,perm2", 3600).await.unwrap();
dao.set("role:user", "perm3", 3600).await.unwrap();
dao.set("role:guest", "", 3600).await.unwrap();
let service = CacheWarmupService::new(dao);
let stats = service.warmup().await.unwrap();
assert_eq!(stats.roles_loaded, 3);
assert_eq!(stats.tenants_loaded, 0);
}
#[tokio::test]
async fn warmup_loads_tenant_configs() {
let dao = Arc::new(crate::dao::InMemoryDao::new());
dao.set("tenant:acme", "config1", 3600).await.unwrap();
dao.set("tenant:globex", "config2", 3600).await.unwrap();
let service = CacheWarmupService::new(dao);
let stats = service.warmup().await.unwrap();
assert_eq!(stats.roles_loaded, 0);
assert_eq!(stats.tenants_loaded, 2);
}
#[tokio::test]
async fn warmup_empty_db_returns_zero_stats() {
let dao = Arc::new(crate::dao::InMemoryDao::new());
let service = CacheWarmupService::new(dao);
let stats = service.warmup().await.unwrap();
assert_eq!(
stats,
WarmupStats {
roles_loaded: 0,
tenants_loaded: 0,
}
);
}
#[tokio::test]
async fn warmup_skips_expired_keys() {
let dao = Arc::new(ExpiredKeyMockDao::new(vec![
"role:expired1".to_string(),
"role:expired2".to_string(),
]));
let service = CacheWarmupService::new(dao);
let stats = service.warmup().await.unwrap();
assert_eq!(stats.roles_loaded, 0, "过期 key 不应计入统计");
}
struct ExpiredKeyMockDao {
keys: Vec<String>,
}
impl ExpiredKeyMockDao {
fn new(keys: Vec<String>) -> Self {
Self { keys }
}
}
#[async_trait::async_trait]
impl GarrisonDao for ExpiredKeyMockDao {
async fn get(&self, _key: &str) -> GarrisonResult<Option<String>> {
Ok(None)
}
async fn set(&self, _key: &str, _value: &str, _ttl_seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn update(&self, _key: &str, _value: &str) -> GarrisonResult<()> {
Ok(())
}
async fn expire(&self, _key: &str, _seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn delete(&self, _key: &str) -> GarrisonResult<()> {
Ok(())
}
async fn keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
let prefix = pattern.trim_end_matches('*');
Ok(self
.keys
.iter()
.filter(|k| k.starts_with(prefix))
.cloned()
.collect())
}
crate::atomic_test_fallback!();
}
struct NoKeysDao;
impl NoKeysDao {
fn new() -> Self {
Self
}
}
#[async_trait::async_trait]
impl GarrisonDao for NoKeysDao {
async fn get(&self, _key: &str) -> GarrisonResult<Option<String>> {
Ok(None)
}
async fn set(&self, _key: &str, _value: &str, _ttl_seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn update(&self, _key: &str, _value: &str) -> GarrisonResult<()> {
Ok(())
}
async fn expire(&self, _key: &str, _seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn delete(&self, _key: &str) -> GarrisonResult<()> {
Ok(())
}
async fn keys(&self, _pattern: &str) -> GarrisonResult<Vec<String>> {
Err(crate::error::GarrisonError::NotImplemented(
"keys 未实现:NoKeysDao 后端不支持 key scan".to_string(),
))
}
crate::atomic_test_fallback!();
}
#[tokio::test]
async fn warmup_returns_zero_stats_when_keys_not_implemented() {
let dao = Arc::new(NoKeysDao::new());
let service = CacheWarmupService::new(dao);
let stats = service
.warmup()
.await
.expect("NotImplemented 应被捕获,不应传播");
assert_eq!(
stats,
WarmupStats {
roles_loaded: 0,
tenants_loaded: 0,
},
"keys() NotImplemented 时应返回零统计"
);
}
struct ErrorKeysDao;
impl ErrorKeysDao {
fn new() -> Self {
Self
}
}
#[async_trait::async_trait]
impl GarrisonDao for ErrorKeysDao {
async fn get(&self, _key: &str) -> GarrisonResult<Option<String>> {
Ok(None)
}
async fn set(&self, _key: &str, _value: &str, _ttl_seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn update(&self, _key: &str, _value: &str) -> GarrisonResult<()> {
Ok(())
}
async fn expire(&self, _key: &str, _seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn delete(&self, _key: &str) -> GarrisonResult<()> {
Ok(())
}
async fn keys(&self, _pattern: &str) -> GarrisonResult<Vec<String>> {
Err(crate::error::GarrisonError::Dao(
"模拟 keys() 数据库连接失败".to_string(),
))
}
crate::atomic_test_fallback!();
}
#[tokio::test]
async fn warmup_propagates_non_not_implemented_keys_error() {
let dao = Arc::new(ErrorKeysDao::new());
let service = CacheWarmupService::new(dao);
let result = service.warmup().await;
assert!(result.is_err(), "非 NotImplemented 错误应传播");
match result {
Err(crate::error::GarrisonError::Dao(msg)) => {
assert!(
msg.contains("模拟 keys() 数据库连接失败"),
"错误消息应包含原始错误描述,实际: {}",
msg
);
},
Err(other) => panic!("期望 Dao 错误,实际: {:?}", other),
Ok(_) => panic!("期望错误传播,实际返回 Ok"),
}
}
struct ErrorGetDao {
keys: Vec<String>,
}
impl ErrorGetDao {
fn new(keys: Vec<String>) -> Self {
Self { keys }
}
}
#[async_trait::async_trait]
impl GarrisonDao for ErrorGetDao {
async fn get(&self, _key: &str) -> GarrisonResult<Option<String>> {
Err(crate::error::GarrisonError::Dao(
"模拟 get() 读取失败".to_string(),
))
}
async fn set(&self, _key: &str, _value: &str, _ttl_seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn update(&self, _key: &str, _value: &str) -> GarrisonResult<()> {
Ok(())
}
async fn expire(&self, _key: &str, _seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn delete(&self, _key: &str) -> GarrisonResult<()> {
Ok(())
}
async fn keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
let prefix = pattern.trim_end_matches('*');
Ok(self
.keys
.iter()
.filter(|k| k.starts_with(prefix))
.cloned()
.collect())
}
crate::atomic_test_fallback!();
}
#[tokio::test]
async fn warmup_propagates_get_error() {
let dao = Arc::new(ErrorGetDao::new(vec!["role:admin".to_string()]));
let service = CacheWarmupService::new(dao);
let result = service.warmup().await;
assert!(result.is_err(), "get() 错误应传播");
match result {
Err(crate::error::GarrisonError::Dao(msg)) => {
assert!(
msg.contains("模拟 get() 读取失败"),
"错误消息应包含 get() 错误描述,实际: {}",
msg
);
},
Err(other) => panic!("期望 Dao 错误,实际: {:?}", other),
Ok(_) => panic!("期望错误传播,实际返回 Ok"),
}
}
struct PartialNotImplDao {
role_keys: Vec<String>,
}
impl PartialNotImplDao {
fn new(role_keys: Vec<String>) -> Self {
Self { role_keys }
}
}
#[async_trait::async_trait]
impl GarrisonDao for PartialNotImplDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
if self.role_keys.contains(&key.to_string()) {
Ok(Some("value".to_string()))
} else {
Ok(None)
}
}
async fn set(&self, _key: &str, _value: &str, _ttl_seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn update(&self, _key: &str, _value: &str) -> GarrisonResult<()> {
Ok(())
}
async fn expire(&self, _key: &str, _seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn delete(&self, _key: &str) -> GarrisonResult<()> {
Ok(())
}
async fn keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
if pattern.starts_with("role:") {
Ok(self
.role_keys
.iter()
.filter(|k| k.starts_with("role:"))
.cloned()
.collect())
} else {
Err(crate::error::GarrisonError::NotImplemented(
"tenant keys 不支持".to_string(),
))
}
}
crate::atomic_test_fallback!();
}
#[tokio::test]
async fn warmup_tenant_keys_not_implemented_still_loads_roles() {
let dao = Arc::new(PartialNotImplDao::new(vec![
"role:admin".to_string(),
"role:user".to_string(),
]));
let service = CacheWarmupService::new(dao);
let result = service.warmup().await;
assert!(
result.is_ok(),
"NotImplemented 应被捕获: {:?}",
result.err()
);
let stats = result.unwrap();
assert_eq!(
stats.roles_loaded, 2,
"tenant NotImplemented 时已获取的 role keys 应继续加载"
);
assert_eq!(stats.tenants_loaded, 0);
}
#[test]
fn warmup_stats_derives_work_correctly() {
let stats1 = WarmupStats {
roles_loaded: 5,
tenants_loaded: 3,
};
let stats2 = stats1.clone();
assert_eq!(stats1, stats2, "Clone 后应相等");
let stats3 = WarmupStats {
roles_loaded: 5,
tenants_loaded: 3,
};
assert_eq!(stats1, stats3, "相同值应相等");
let stats4 = WarmupStats {
roles_loaded: 0,
tenants_loaded: 3,
};
assert_ne!(stats1, stats4, "不同值应不等");
let debug_str = format!("{:?}", stats1);
assert!(debug_str.contains("WarmupStats"));
assert!(debug_str.contains("roles_loaded"));
assert!(debug_str.contains("5"));
assert!(debug_str.contains("tenants_loaded"));
assert!(debug_str.contains("3"));
}
#[tokio::test]
async fn expired_key_mock_dao_all_methods_return_ok() {
let dao = ExpiredKeyMockDao::new(vec!["role:test".to_string()]);
dao.set("k", "v", 60).await.unwrap();
dao.update("k", "v2").await.unwrap();
dao.expire("k", 30).await.unwrap();
dao.delete("k").await.unwrap();
assert!(dao.get("k").await.unwrap().is_none());
let keys = dao.keys("role:*").await.unwrap();
assert_eq!(keys.len(), 1);
let empty = dao.keys("tenant:*").await.unwrap();
assert!(empty.is_empty());
let _ = dao.set_if_absent("a", "v", 60).await;
let _ = dao.get_and_delete("a").await;
let _ = dao.incr("c", 60).await;
let _ = dao.decr("c").await;
let _ = dao.rename("a", "b").await;
let _ = dao.compare_and_swap("b", None, "v", 60).await;
let _ = dao.set_permanent("p", "v").await;
let _ = dao.get_timeout("k").await;
let _ = dao.find_social_binding(0, "w", "o").await;
let _ = dao.insert_social_binding(0, "u", "w", "o", None, 0).await;
let _ = dao.compare_and_update_if_greater("k", 1, 60).await;
let _ = dao.eval_lua("r", vec![], vec![]).await;
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
{
let _ = dao.insert_credit_consumption(0, "r", 1, 1, 1, 0).await;
let _ = dao.query_credit_consumption(0, 0, 0).await;
let _ = dao.query_role_hierarchy_edges(0).await;
let _ = dao.insert_role_hierarchy_edge(0, "c", "p").await;
let _ = dao.delete_role_hierarchy_edge(0, "c", "p").await;
}
}
#[tokio::test]
async fn no_keys_dao_all_methods_return_ok() {
let dao = NoKeysDao::new();
assert!(dao.get("k").await.unwrap().is_none());
dao.set("k", "v", 60).await.unwrap();
dao.update("k", "v2").await.unwrap();
dao.expire("k", 30).await.unwrap();
dao.delete("k").await.unwrap();
assert!(dao.keys("any:*").await.is_err());
let _ = dao.set_if_absent("a", "v", 60).await;
let _ = dao.get_and_delete("a").await;
let _ = dao.incr("c", 60).await;
let _ = dao.decr("c").await;
let _ = dao.rename("a", "b").await;
let _ = dao.compare_and_swap("b", None, "v", 60).await;
let _ = dao.set_permanent("p", "v").await;
let _ = dao.get_timeout("k").await;
let _ = dao.get_with_ttl("k").await;
let _ = dao.find_social_binding(0, "w", "o").await;
let _ = dao.insert_social_binding(0, "u", "w", "o", None, 0).await;
let _ = dao.compare_and_update_if_greater("k", 1, 60).await;
let _ = dao.eval_lua("r", vec![], vec![]).await;
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
{
let _ = dao.insert_credit_consumption(0, "r", 1, 1, 1, 0).await;
let _ = dao.query_credit_consumption(0, 0, 0).await;
let _ = dao.query_role_hierarchy_edges(0).await;
let _ = dao.insert_role_hierarchy_edge(0, "c", "p").await;
let _ = dao.delete_role_hierarchy_edge(0, "c", "p").await;
}
}
#[tokio::test]
async fn error_keys_dao_all_methods_return_ok() {
let dao = ErrorKeysDao::new();
assert!(dao.get("k").await.unwrap().is_none());
dao.set("k", "v", 60).await.unwrap();
dao.update("k", "v2").await.unwrap();
dao.expire("k", 30).await.unwrap();
dao.delete("k").await.unwrap();
assert!(dao.keys("any:*").await.is_err());
let _ = dao.set_if_absent("a", "v", 60).await;
let _ = dao.get_and_delete("a").await;
let _ = dao.incr("c", 60).await;
let _ = dao.decr("c").await;
let _ = dao.rename("a", "b").await;
let _ = dao.compare_and_swap("b", None, "v", 60).await;
let _ = dao.set_permanent("p", "v").await;
let _ = dao.get_timeout("k").await;
let _ = dao.get_with_ttl("k").await;
let _ = dao.find_social_binding(0, "w", "o").await;
let _ = dao.insert_social_binding(0, "u", "w", "o", None, 0).await;
let _ = dao.compare_and_update_if_greater("k", 1, 60).await;
let _ = dao.eval_lua("r", vec![], vec![]).await;
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
{
let _ = dao.insert_credit_consumption(0, "r", 1, 1, 1, 0).await;
let _ = dao.query_credit_consumption(0, 0, 0).await;
let _ = dao.query_role_hierarchy_edges(0).await;
let _ = dao.insert_role_hierarchy_edge(0, "c", "p").await;
let _ = dao.delete_role_hierarchy_edge(0, "c", "p").await;
}
}
#[tokio::test]
async fn error_get_dao_non_get_methods_return_ok() {
let dao = ErrorGetDao::new(vec!["role:test".to_string()]);
dao.set("k", "v", 60).await.unwrap();
dao.update("k", "v2").await.unwrap();
dao.expire("k", 30).await.unwrap();
dao.delete("k").await.unwrap();
assert!(dao.get("k").await.is_err());
let keys = dao.keys("role:*").await.unwrap();
assert_eq!(keys.len(), 1);
let _ = dao.set_if_absent("a", "v", 60).await;
let _ = dao.get_and_delete("a").await;
let _ = dao.incr("c", 60).await;
let _ = dao.decr("c").await;
let _ = dao.rename("a", "b").await;
let _ = dao.compare_and_swap("b", None, "v", 60).await;
let _ = dao.set_permanent("p", "v").await;
let _ = dao.get_timeout("k").await;
let _ = dao.find_social_binding(0, "w", "o").await;
let _ = dao.insert_social_binding(0, "u", "w", "o", None, 0).await;
let _ = dao.compare_and_update_if_greater("k", 1, 60).await;
let _ = dao.eval_lua("r", vec![], vec![]).await;
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
{
let _ = dao.insert_credit_consumption(0, "r", 1, 1, 1, 0).await;
let _ = dao.query_credit_consumption(0, 0, 0).await;
let _ = dao.query_role_hierarchy_edges(0).await;
let _ = dao.insert_role_hierarchy_edge(0, "c", "p").await;
let _ = dao.delete_role_hierarchy_edge(0, "c", "p").await;
}
}
#[tokio::test]
async fn partial_not_impl_dao_non_keys_methods_return_ok() {
let dao = PartialNotImplDao::new(vec!["role:test".to_string()]);
dao.set("k", "v", 60).await.unwrap();
dao.update("k", "v2").await.unwrap();
dao.expire("k", 30).await.unwrap();
dao.delete("k").await.unwrap();
assert_eq!(
dao.get("role:test").await.unwrap().as_deref(),
Some("value")
);
assert!(dao.get("unknown").await.unwrap().is_none());
let keys = dao.keys("role:*").await.unwrap();
assert_eq!(keys.len(), 1);
assert!(dao.keys("tenant:*").await.is_err());
let _ = dao.set_if_absent("a", "v", 60).await;
let _ = dao.get_and_delete("a").await;
let _ = dao.incr("c", 60).await;
let _ = dao.decr("c").await;
let _ = dao.rename("a", "b").await;
let _ = dao.compare_and_swap("b", None, "v", 60).await;
let _ = dao.set_permanent("p", "v").await;
let _ = dao.get_timeout("k").await;
let _ = dao.find_social_binding(0, "w", "o").await;
let _ = dao.insert_social_binding(0, "u", "w", "o", None, 0).await;
let _ = dao.compare_and_update_if_greater("k", 1, 60).await;
let _ = dao.eval_lua("r", vec![], vec![]).await;
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
{
let _ = dao.insert_credit_consumption(0, "r", 1, 1, 1, 0).await;
let _ = dao.query_credit_consumption(0, 0, 0).await;
let _ = dao.query_role_hierarchy_edges(0).await;
let _ = dao.insert_role_hierarchy_edge(0, "c", "p").await;
let _ = dao.delete_role_hierarchy_edge(0, "c", "p").await;
}
}
struct TenantErrorDao {
role_keys: Vec<String>,
}
impl TenantErrorDao {
fn new(role_keys: Vec<String>) -> Self {
Self { role_keys }
}
}
#[async_trait::async_trait]
impl GarrisonDao for TenantErrorDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
if self.role_keys.contains(&key.to_string()) {
Ok(Some("value".to_string()))
} else {
Ok(None)
}
}
async fn set(&self, _key: &str, _value: &str, _ttl_seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn update(&self, _key: &str, _value: &str) -> GarrisonResult<()> {
Ok(())
}
async fn expire(&self, _key: &str, _seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn delete(&self, _key: &str) -> GarrisonResult<()> {
Ok(())
}
async fn keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
if pattern.starts_with("role:") {
Ok(self
.role_keys
.iter()
.filter(|k| k.starts_with("role:"))
.cloned()
.collect())
} else {
Err(crate::error::GarrisonError::Dao(
"tenant keys() 数据库连接断开".to_string(),
))
}
}
crate::atomic_test_fallback!();
}
#[tokio::test]
async fn warmup_propagates_tenant_keys_non_not_implemented_error() {
let dao = Arc::new(TenantErrorDao::new(vec![
"role:admin".to_string(),
"role:user".to_string(),
]));
let _ = dao.set_if_absent("a", "v", 60).await;
let _ = dao.get_and_delete("a").await;
let _ = dao.incr("c", 60).await;
let _ = dao.decr("c").await;
let _ = dao.rename("a", "b").await;
let _ = dao.compare_and_swap("b", None, "v", 60).await;
let _ = dao.set_permanent("p", "v").await;
let _ = dao.get_timeout("k").await;
let _ = dao.get_with_ttl("k").await;
let _ = dao.find_social_binding(0, "w", "o").await;
let _ = dao.insert_social_binding(0, "u", "w", "o", None, 0).await;
let _ = dao.compare_and_update_if_greater("k", 1, 60).await;
let _ = dao.eval_lua("r", vec![], vec![]).await;
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
{
let _ = dao.insert_credit_consumption(0, "r", 1, 1, 1, 0).await;
let _ = dao.query_credit_consumption(0, 0, 0).await;
let _ = dao.query_role_hierarchy_edges(0).await;
let _ = dao.insert_role_hierarchy_edge(0, "c", "p").await;
let _ = dao.delete_role_hierarchy_edge(0, "c", "p").await;
}
let service = CacheWarmupService::new(dao);
let result = service.warmup().await;
assert!(result.is_err(), "tenant keys 非 NotImplemented 错误应传播");
match result {
Err(crate::error::GarrisonError::Dao(msg)) => {
assert!(
msg.contains("tenant keys() 数据库连接断开"),
"错误消息应包含 tenant keys 错误描述,实际: {}",
msg
);
},
Err(other) => panic!("期望 Dao 错误,实际: {:?}", other),
Ok(_) => panic!("期望错误传播,实际返回 Ok"),
}
}
#[tokio::test]
async fn warmup_loads_both_roles_and_tenants() {
let dao = Arc::new(crate::dao::InMemoryDao::new());
dao.set("role:admin", "perm1", 3600).await.unwrap();
dao.set("role:user", "perm2", 3600).await.unwrap();
dao.set("tenant:acme", "config1", 3600).await.unwrap();
dao.set("tenant:globex", "config2", 3600).await.unwrap();
let service = CacheWarmupService::new(dao);
let stats = service.warmup().await.unwrap();
assert_eq!(stats.roles_loaded, 2);
assert_eq!(stats.tenants_loaded, 2);
}
}