use crate::dao::GarrisonDao;
use crate::error::GarrisonResult;
use async_trait::async_trait;
use parking_lot::RwLock;
use std::collections::HashMap;
use std::sync::Arc;
pub struct AloneCache {
inner: Arc<dyn GarrisonDao>,
key_prefix: String,
}
impl AloneCache {
pub fn new(dao: Arc<dyn GarrisonDao>, key_prefix: &str) -> Self {
Self {
inner: dao,
key_prefix: key_prefix.to_string(),
}
}
fn prefixed_key(&self, key: &str) -> String {
format!("{}{}", self.key_prefix, key)
}
}
#[async_trait]
impl GarrisonDao for AloneCache {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
self.inner.get(&self.prefixed_key(key)).await
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.inner
.set(&self.prefixed_key(key), value, ttl_seconds)
.await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
self.inner.update(&self.prefixed_key(key), value).await
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
self.inner.expire(&self.prefixed_key(key), seconds).await
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.inner.delete(&self.prefixed_key(key)).await
}
async fn get_and_delete(&self, key: &str) -> GarrisonResult<Option<String>> {
self.inner.get_and_delete(&self.prefixed_key(key)).await
}
async fn get_timeout(&self, key: &str) -> GarrisonResult<Option<std::time::Duration>> {
self.inner.get_timeout(&self.prefixed_key(key)).await
}
async fn get_with_ttl(
&self,
key: &str,
) -> GarrisonResult<Option<(String, Option<std::time::Duration>)>> {
self.inner.get_with_ttl(&self.prefixed_key(key)).await
}
async fn set_if_absent(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner
.set_if_absent(&self.prefixed_key(key), value, ttl_seconds)
.await
}
async fn rename(&self, old_key: &str, new_key: &str) -> GarrisonResult<()> {
self.inner
.rename(&self.prefixed_key(old_key), &self.prefixed_key(new_key))
.await
}
async fn incr(&self, key: &str, ttl_seconds: u64) -> GarrisonResult<u64> {
self.inner.incr(&self.prefixed_key(key), ttl_seconds).await
}
async fn compare_and_update_if_greater(
&self,
key: &str,
new_value: u64,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner
.compare_and_update_if_greater(&self.prefixed_key(key), new_value, ttl_seconds)
.await
}
async fn decr(&self, key: &str) -> GarrisonResult<u64> {
self.inner.decr(&self.prefixed_key(key)).await
}
async fn compare_and_swap(
&self,
key: &str,
expected: Option<&str>,
new_value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner
.compare_and_swap(&self.prefixed_key(key), expected, new_value, ttl_seconds)
.await
}
}
pub struct AloneCacheManager {
caches: RwLock<HashMap<String, Arc<AloneCache>>>,
}
impl AloneCacheManager {
pub fn new() -> Self {
Self {
caches: RwLock::new(HashMap::new()),
}
}
pub fn register(&self, name: &str, cache: AloneCache) {
self.caches
.write()
.insert(name.to_string(), Arc::new(cache));
}
pub fn get(&self, name: &str) -> Option<Arc<AloneCache>> {
self.caches.read().get(name).cloned()
}
pub fn unregister(&self, name: &str) -> Option<Arc<AloneCache>> {
self.caches.write().remove(name)
}
}
impl Default for AloneCacheManager {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::MockDao;
#[tokio::test]
async fn alone_cache_set_adds_prefix() {
let mock = Arc::new(MockDao::new());
let cache = AloneCache::new(mock.clone(), "perm:");
cache.set("user:1001", "value", 3600).await.unwrap();
let got = mock.get("perm:user:1001").await.unwrap();
assert_eq!(got, Some("value".to_string()));
let not_got = mock.get("user:1001").await.unwrap();
assert!(not_got.is_none(), "无 prefix 的 key 不应存在");
}
#[tokio::test]
async fn alone_cache_get_adds_prefix() {
let mock = Arc::new(MockDao::new());
mock.set("perm:user:1001", "value", 3600).await.unwrap();
let cache = AloneCache::new(mock.clone(), "perm:");
let got = cache.get("user:1001").await.unwrap();
assert_eq!(got, Some("value".to_string()));
let not_got = cache.get("perm:user:1001").await.unwrap();
assert!(not_got.is_none(), "双重 prefix 的 key 不应存在");
}
#[tokio::test]
async fn alone_cache_delete_adds_prefix() {
let mock = Arc::new(MockDao::new());
mock.set("perm:k", "v", 3600).await.unwrap();
let cache = AloneCache::new(mock.clone(), "perm:");
cache.delete("k").await.unwrap();
let got = mock.get("perm:k").await.unwrap();
assert!(got.is_none(), "delete 应删除带 prefix 的 key");
}
#[tokio::test]
async fn alone_cache_update_adds_prefix() {
let mock = Arc::new(MockDao::new());
mock.set("perm:k", "v1", 3600).await.unwrap();
let cache = AloneCache::new(mock.clone(), "perm:");
cache.update("k", "v2").await.unwrap();
let got = mock.get("perm:k").await.unwrap();
assert_eq!(got, Some("v2".to_string()));
}
#[tokio::test]
async fn alone_cache_expire_adds_prefix() {
let mock = Arc::new(MockDao::new());
mock.set("perm:k", "v", 1).await.unwrap();
let cache = AloneCache::new(mock.clone(), "perm:");
cache.expire("k", 3600).await.unwrap();
tokio::time::sleep(std::time::Duration::from_secs(2)).await;
let got = cache.get("k").await.unwrap();
assert_eq!(
got,
Some("v".to_string()),
"expire 应重置带 prefix 的 key 的 TTL"
);
}
#[tokio::test]
async fn alone_cache_transparent_delegation() {
let mock = Arc::new(MockDao::new());
let cache = AloneCache::new(mock.clone(), "prefix:");
let r1 = cache.set("k", "v", 100).await;
let r2 = mock.set("prefix:k", "v2", 100).await;
assert!(r1.is_ok());
assert!(r2.is_ok());
let via_cache = cache.get("k").await.unwrap();
let via_mock = mock.get("prefix:k").await.unwrap();
assert_eq!(via_cache, via_mock);
let r4 = cache.expire("missing", 100).await;
let r5 = mock.expire("prefix:missing", 100).await;
assert!(r4.is_err(), "cache.expire 不存在的键应返回 Err");
assert!(r5.is_err(), "mock.expire 不存在的键应返回 Err");
}
#[tokio::test]
async fn alone_cache_manager_register_and_get() {
let manager = AloneCacheManager::new();
manager.register(
"permission",
AloneCache::new(Arc::new(MockDao::new()), "perm:"),
);
manager.register(
"business",
AloneCache::new(Arc::new(MockDao::new()), "biz:"),
);
let perm = manager.get("permission");
let biz = manager.get("business");
assert!(perm.is_some(), "permission 实例应存在");
assert!(biz.is_some(), "business 实例应存在");
}
#[tokio::test]
async fn alone_cache_manager_unregistered_returns_none() {
let manager = AloneCacheManager::new();
let got = manager.get("unregistered");
assert!(got.is_none(), "未注册的 name 应返回 None");
}
#[tokio::test]
async fn alone_cache_manager_multiple_different_dao() {
let redis1 = Arc::new(MockDao::new());
let redis2 = Arc::new(MockDao::new());
let manager = AloneCacheManager::new();
manager.register("permission", AloneCache::new(redis1.clone(), "perm:"));
manager.register("business", AloneCache::new(redis2.clone(), "biz:"));
let perm_cache = manager.get("permission").unwrap();
let biz_cache = manager.get("business").unwrap();
perm_cache.set("user:1", "p", 3600).await.unwrap();
biz_cache.set("user:1", "b", 3600).await.unwrap();
let p = redis1.get("perm:user:1").await.unwrap();
let b = redis2.get("biz:user:1").await.unwrap();
assert_eq!(p, Some("p".to_string()));
assert_eq!(b, Some("b".to_string()));
assert!(
redis1.get("biz:user:1").await.unwrap().is_none(),
"redis1 不应包含 biz: 命名空间"
);
assert!(
redis2.get("perm:user:1").await.unwrap().is_none(),
"redis2 不应包含 perm: 命名空间"
);
}
#[tokio::test]
async fn alone_cache_manager_unregister() {
let manager = AloneCacheManager::new();
manager.register("temp", AloneCache::new(Arc::new(MockDao::new()), "t:"));
assert!(manager.get("temp").is_some());
let removed = manager.unregister("temp");
assert!(removed.is_some(), "unregister 应返回被移除的实例");
assert!(
manager.get("temp").is_none(),
"unregister 后 get 应返回 None"
);
}
#[tokio::test]
async fn alone_cache_empty_prefix_passthrough() {
let mock = Arc::new(MockDao::new());
let cache = AloneCache::new(mock.clone(), "");
cache.set("k", "v", 3600).await.unwrap();
let got = mock.get("k").await.unwrap();
assert_eq!(got, Some("v".to_string()));
}
#[tokio::test]
async fn alone_cache_delete_nonexistent_is_ok() {
let mock = Arc::new(MockDao::new());
let cache = AloneCache::new(mock, "perm:");
let result = cache.delete("never_exists").await;
assert!(
result.is_ok(),
"delete 不存在的键应返回 Ok(与 MockDao 一致)"
);
}
#[tokio::test]
async fn alone_cache_decr_delegates_to_inner_with_prefix() {
let mock = Arc::new(MockDao::new());
let cache = AloneCache::new(mock.clone(), "perm:");
mock.set("perm:counter", "3", 3600).await.unwrap();
let r1 = cache.decr("counter").await.unwrap();
assert_eq!(r1, 2, "第一次 decr 应返回 2");
let v1 = mock.get("perm:counter").await.unwrap();
assert_eq!(v1.as_deref(), Some("2"), "decr 后内部 dao 应为 '2'");
let r2 = cache.decr("counter").await.unwrap();
assert_eq!(r2, 1, "第二次 decr 应返回 1");
let r3 = cache.decr("counter").await.unwrap();
assert_eq!(r3, 0, "第三次 decr 应返回 0");
let v3 = mock.get("perm:counter").await.unwrap();
assert!(v3.is_none(), "decr 到 0 时 key 应被删除");
let r4 = cache.decr("counter").await.unwrap();
assert_eq!(r4, 0, "key 不存在时 decr 应返回 0");
let v4 = mock.get("perm:counter").await.unwrap();
assert!(v4.is_none(), "key 不存在时 decr 不应创建 key");
}
#[tokio::test]
async fn alone_cache_decr_missing_key_returns_zero() {
let mock = Arc::new(MockDao::new());
let cache = AloneCache::new(mock.clone(), "perm:");
let r = cache.decr("never").await.unwrap();
assert_eq!(r, 0, "不存在的 key decr 应返回 0");
let v = mock.get("perm:never").await.unwrap();
assert!(v.is_none(), "inner dao 上 'perm:never' 不应存在");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn alone_cache_decr_concurrent_atomic() {
let mock = Arc::new(MockDao::new());
let cache = Arc::new(AloneCache::new(mock.clone(), "perm:"));
mock.set("perm:counter", "5", 3600).await.unwrap();
let mut handles = Vec::with_capacity(10);
for _ in 0..10 {
let c = cache.clone();
handles.push(tokio::spawn(
async move { c.decr("counter").await.unwrap() },
));
}
let mut results = Vec::with_capacity(10);
for h in handles {
results.push(h.await.expect("task join failed"));
}
let nonzero_count = results.iter().filter(|&&v| v > 0).count();
let zero_count = results.iter().filter(|&&v| v == 0).count();
assert_eq!(
nonzero_count, 4,
"应恰好 4 个非 0 返回值(4, 3, 2, 1),实际: {:?}",
results
);
assert_eq!(
zero_count, 6,
"应恰好 6 个 0 返回值(第 5 次 decr + key 删除后 5 次),实际: {:?}",
results
);
let mut nonzero_vals: Vec<u64> = results.iter().copied().filter(|&v| v > 0).collect();
nonzero_vals.sort_unstable();
assert_eq!(
nonzero_vals,
vec![1, 2, 3, 4],
"非 0 返回值应恰好为 {{1, 2, 3, 4}},实际: {:?}",
nonzero_vals
);
let v = mock.get("perm:counter").await.unwrap();
assert!(v.is_none(), "并发 decr 后 key 应被删除");
}
}