use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use parking_lot::Mutex;
use std::collections::HashMap;
use std::time::{Duration, Instant};
pub struct InMemoryDao {
store: Mutex<HashMap<String, (String, Option<Instant>)>>,
}
impl Default for InMemoryDao {
fn default() -> Self {
Self::new()
}
}
impl InMemoryDao {
pub fn new() -> Self {
Self {
store: Mutex::new(HashMap::new()),
}
}
}
#[async_trait]
impl GarrisonDao for InMemoryDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
let mut store = self.store.lock();
match store.get(key) {
Some((value, expire_at)) => {
if let Some(deadline) = expire_at {
if Instant::now() >= *deadline {
store.remove(key);
return Ok(None);
}
}
Ok(Some(value.clone()))
},
None => Ok(None),
}
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
let expire_at = if ttl_seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(ttl_seconds))
};
self.store
.lock()
.insert(key.to_string(), (value.to_string(), expire_at));
Ok(())
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
let mut store = self.store.lock();
let expired = match store.get(key) {
Some((_, Some(deadline))) => Instant::now() >= *deadline,
_ => false,
};
if expired {
store.remove(key);
return Err(GarrisonError::Dao(format!("dao-key-missing::{}", key)));
}
match store.get_mut(key) {
Some((existing, _)) => {
*existing = value.to_string();
Ok(())
},
None => Err(GarrisonError::Dao(format!("dao-key-missing::{}", key))),
}
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
let mut store = self.store.lock();
let expired = match store.get(key) {
Some((_, Some(deadline))) => Instant::now() >= *deadline,
_ => false,
};
if expired {
store.remove(key);
return Err(GarrisonError::Dao(format!("dao-key-missing::{}", key)));
}
match store.get_mut(key) {
Some((_, expire_at)) => {
*expire_at = if seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(seconds))
};
Ok(())
},
None => Err(GarrisonError::Dao(format!("dao-key-missing::{}", key))),
}
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.store.lock().remove(key);
Ok(())
}
async fn set_permanent(&self, key: &str, value: &str) -> GarrisonResult<()> {
self.store
.lock()
.insert(key.to_string(), (value.to_string(), None));
Ok(())
}
async fn get_timeout(&self, key: &str) -> GarrisonResult<Option<Duration>> {
let store = self.store.lock();
match store.get(key) {
Some((_, Some(deadline))) => {
let now = Instant::now();
if *deadline <= now {
Ok(None)
} else {
Ok(Some(*deadline - now))
}
},
_ => Ok(None),
}
}
async fn keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
let mut result = Vec::new();
let now = Instant::now();
let store = self.store.lock();
for (key, (_, expire_at)) in store.iter() {
if let Some(deadline) = expire_at {
if *deadline <= now {
continue;
}
}
if glob_match(pattern, key) {
result.push(key.clone());
}
}
Ok(result)
}
async fn rename(&self, old_key: &str, new_key: &str) -> GarrisonResult<()> {
let mut store = self.store.lock();
match store.get(old_key).cloned() {
Some((value, expire_at)) => {
store.insert(new_key.to_string(), (value, expire_at));
store.remove(old_key);
Ok(())
},
None => Err(GarrisonError::InvalidParam(format!(
"dao-key-not-found::{}",
old_key
))),
}
}
async fn get_and_delete(&self, key: &str) -> GarrisonResult<Option<String>> {
let mut store = self.store.lock();
match store.remove(key) {
Some((_value, Some(deadline))) if Instant::now() >= deadline => {
Ok(None)
},
Some((value, _)) => Ok(Some(value)),
None => Ok(None),
}
}
async fn set_if_absent(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
let mut store = self.store.lock();
let now = Instant::now();
let exists = match store.get(key) {
Some((_, Some(deadline))) if *deadline <= now => {
store.remove(key);
false
},
Some(_) => true,
None => false,
};
if exists {
return Ok(false);
}
let expire_at = if ttl_seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(ttl_seconds))
};
store.insert(key.to_string(), (value.to_string(), expire_at));
Ok(true)
}
async fn incr(&self, key: &str, ttl_seconds: u64) -> GarrisonResult<u64> {
let mut store = self.store.lock();
let now = Instant::now();
let should_init = match store.get(key) {
Some((_, Some(deadline))) => *deadline <= now, Some((_, None)) => false, None => true, };
if should_init {
let expire_at = if ttl_seconds == 0 {
None
} else {
Some(now + Duration::from_secs(ttl_seconds))
};
store.insert(key.to_string(), ("1".to_string(), expire_at));
Ok(1)
} else {
let (val_str, _) = store.get(key).cloned().unwrap();
let cur_val: u64 = val_str.parse().map_err(|_| {
GarrisonError::Dao(format!("dao-incr-parse-u64::{}::{}", key, val_str))
})?;
let new_val = cur_val
.checked_add(1)
.ok_or_else(|| GarrisonError::Dao(format!("dao-incr-overflow-u64::{}", key)))?;
let expire_at = store.get(key).and_then(|(_, e)| *e);
store.insert(key.to_string(), (new_val.to_string(), expire_at));
Ok(new_val)
}
}
async fn decr(&self, key: &str) -> GarrisonResult<u64> {
let mut store = self.store.lock();
let now = Instant::now();
let (cur_val, expire_at) = match store.get(key) {
Some((v, Some(deadline))) => {
if *deadline <= now {
store.remove(key);
return Ok(0);
}
let val: u64 = v.parse().map_err(|_| {
GarrisonError::Dao(format!("dao-decr-parse-u64::{}::{}", key, v))
})?;
(val, Some(*deadline))
},
Some((v, None)) => {
let val: u64 = v.parse().map_err(|_| {
GarrisonError::Dao(format!("dao-decr-parse-u64::{}::{}", key, v))
})?;
(val, None)
},
None => return Ok(0),
};
if cur_val == 0 {
return Ok(0);
}
let new_val = cur_val - 1;
if new_val == 0 {
store.remove(key);
} else {
store.insert(key.to_string(), (new_val.to_string(), expire_at));
}
Ok(new_val)
}
async fn compare_and_update_if_greater(
&self,
key: &str,
new_value: u64,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
let mut store = self.store.lock();
let now = Instant::now();
let (current_val, existing_expire_at) = match store.get(key) {
Some((v, Some(deadline))) if *deadline > now => (
v.parse::<u64>().map_err(|_| {
GarrisonError::Dao(format!("dao-compare-and-update-parse-u64::{}::{}", key, v))
})?,
Some(*deadline),
),
Some((v, None)) => (
v.parse::<u64>().map_err(|_| {
GarrisonError::Dao(format!("dao-compare-and-update-parse-u64::{}::{}", key, v))
})?,
None,
),
_ => (0, None),
};
if new_value > current_val {
let expire_at = if existing_expire_at.is_some() {
existing_expire_at
} else if ttl_seconds == 0 {
None
} else {
Some(now + Duration::from_secs(ttl_seconds))
};
store.insert(key.to_string(), (new_value.to_string(), expire_at));
Ok(true)
} else {
Ok(false)
}
}
async fn compare_and_swap(
&self,
key: &str,
expected: Option<&str>,
new_value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
let mut store = self.store.lock();
let now = Instant::now();
let current = match store.get(key) {
Some((v, Some(deadline))) if *deadline <= now => {
store.remove(key);
None
},
Some((v, _)) => Some(v.as_str()),
None => None,
};
if current == expected {
let expire_at = if ttl_seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(ttl_seconds))
};
store.insert(key.to_string(), (new_value.to_string(), expire_at));
Ok(true)
} else {
Ok(false)
}
}
async fn eval_lua(
&self,
script: &str,
keys: Vec<String>,
args: Vec<String>,
) -> GarrisonResult<Vec<String>> {
if script.contains("ZREMRANGEBYSCORE") {
return self.eval_lua_sliding_window_mode(&keys, &args).await;
}
if script.contains("INCR") && script.contains("EXPIRE") {
return self.eval_lua_incr_mode(&keys, &args).await;
}
Err(GarrisonError::NotImplemented(format!(
"dao-eval-lua-unsupported-script::{}",
script
)))
}
}
impl InMemoryDao {
async fn eval_lua_incr_mode(
&self,
keys: &[String],
args: &[String],
) -> GarrisonResult<Vec<String>> {
let key = keys.first().ok_or_else(|| {
GarrisonError::InvalidParam("dao-eval-lua-missing-keys-1".to_string())
})?;
let ttl: u64 = parse_lua_arg(args, 1, "dao-eval-lua-argv-2-ttl")?;
let count = self.incr(key, ttl).await?;
Ok(vec![count.to_string()])
}
async fn eval_lua_sliding_window_mode(
&self,
keys: &[String],
args: &[String],
) -> GarrisonResult<Vec<String>> {
let key = keys.first().ok_or_else(|| {
GarrisonError::InvalidParam("dao-eval-lua-rl-missing-keys-1".to_string())
})?;
if keys.len() < 2 {
return Err(GarrisonError::InvalidParam(
"dao-eval-lua-rl-missing-keys-2-seq".to_string(),
));
}
let window_ms: u64 = parse_lua_arg(args, 0, "dao-eval-lua-rl-argv-1-window-ms")?;
let max_requests: usize = parse_lua_arg(args, 1, "dao-eval-lua-rl-argv-2-max")?;
let now_ms: u64 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as u64)
.unwrap_or(0);
let window_start_ms = now_ms.saturating_sub(window_ms);
let mut store = self.store.lock();
let now = Instant::now();
let mut members: Vec<u64> = match store.get(key) {
Some((raw, Some(deadline))) if *deadline > now => {
parse_timestamps(raw, window_start_ms)
},
Some((raw, None)) => parse_timestamps(raw, window_start_ms),
_ => Vec::new(),
};
let current_count = members.len();
let allowed = current_count < max_requests;
if allowed {
members.push(now_ms);
let ttl_secs = window_ms.div_ceil(1000) + 1;
let expire_at = Some(now + Duration::from_secs(ttl_secs));
let new_raw = members
.iter()
.map(|t| t.to_string())
.collect::<Vec<_>>()
.join(",");
store.insert(key.to_string(), (new_raw, expire_at));
}
let reset_time = window_start_ms + window_ms;
Ok(vec![
if allowed { "1" } else { "0" }.to_string(),
current_count.to_string(),
reset_time.to_string(),
])
}
}
fn parse_lua_arg<T: std::str::FromStr>(
args: &[String],
index: usize,
name: &str,
) -> GarrisonResult<T>
where
T::Err: std::fmt::Display,
{
let val = args
.get(index)
.ok_or_else(|| GarrisonError::InvalidParam(format!("dao-eval-lua-missing-{}", name)))?;
val.parse().map_err(|e: T::Err| {
GarrisonError::InvalidParam(format!("dao-eval-lua-{}-parse-failed::{}", name, e))
})
}
fn parse_timestamps(raw: &str, window_start_ms: u64) -> Vec<u64> {
raw.split(',')
.filter(|s| !s.is_empty())
.filter_map(|s| s.parse::<u64>().ok())
.filter(|&t| t > window_start_ms)
.collect()
}
pub(crate) fn glob_match(pattern: &str, text: &str) -> bool {
let pattern: Vec<char> = pattern.chars().collect();
let text: Vec<char> = text.chars().collect();
let mut p = 0; let mut t = 0; let mut star_p: Option<usize> = None; let mut star_t = 0;
while t < text.len() {
if p < pattern.len() && (pattern[p] == '?' || pattern[p] == text[t]) {
p += 1;
t += 1;
} else if p < pattern.len() && pattern[p] == '*' {
star_p = Some(p);
star_t = t;
p += 1;
} else if let Some(sp) = star_p {
p = sp + 1;
star_t += 1;
t = star_t;
} else {
return false;
}
}
while p < pattern.len() && pattern[p] == '*' {
p += 1;
}
p == pattern.len()
}
#[cfg(test)]
mod glob_match_tests {
use super::glob_match;
#[test]
fn glob_match_exact() {
assert!(glob_match("abc", "abc"));
assert!(!glob_match("abc", "xyz"));
assert!(!glob_match("abcdef", "abc"));
}
#[test]
fn glob_match_star_variants() {
assert!(glob_match("*", "anything"));
assert!(glob_match("*", ""));
assert!(glob_match("garrison:*", "garrison:apikey:abc"));
assert!(glob_match("*:abc", "garrison:apikey:abc"));
assert!(glob_match("a*bc", "abc")); assert!(glob_match("a*bc", "aXXXbc")); assert!(!glob_match("a*bc", "aXXXbd")); }
#[test]
fn glob_match_star_backtracking() {
assert!(glob_match("ab*cd", "abXXcd"));
assert!(glob_match("*aab", "xaab"));
assert!(!glob_match("ab*cd", "abXXce"));
}
#[test]
fn glob_match_multiple_stars() {
assert!(glob_match("a**b", "aXXb"));
assert!(glob_match("**", "whatever"));
assert!(glob_match("a*b*c", "a1b2c"));
assert!(!glob_match("a*b*c", "a1b2d"));
}
#[test]
fn glob_match_question_mark() {
assert!(glob_match("key?", "key1"));
assert!(!glob_match("key?", "key")); assert!(!glob_match("key?", "key12")); assert!(glob_match("??", "ab"));
}
#[test]
fn glob_match_trailing_star_after_text_exhausted() {
assert!(glob_match("abc*", "abc"));
assert!(glob_match("a*", "a"));
}
#[test]
fn glob_match_empty_inputs() {
assert!(glob_match("", ""));
assert!(!glob_match("", "a"));
assert!(glob_match("*", ""));
}
#[test]
fn glob_match_unicode_chars() {
assert!(glob_match("用户?", "用户A"));
assert!(glob_match("*:租户:*", "garrison:租户:42"));
assert!(!glob_match("用户?", "用户AB"));
}
}
#[cfg(test)]
mod ttl_semantics_tests {
use super::*;
#[tokio::test]
async fn update_expired_key_returns_missing_without_reviving() {
let dao = InMemoryDao::new();
dao.set("upd_expired", "old", 1).await.unwrap();
tokio::time::sleep(Duration::from_secs(2)).await;
let result = dao.update("upd_expired", "new").await;
assert!(
matches!(result, Err(GarrisonError::Dao(ref msg)) if msg.contains("dao-key-missing")),
"已过期 key 的 update 应返回 dao-key-missing,实际: {:?}",
result
);
assert!(
dao.get("upd_expired").await.unwrap().is_none(),
"update 过期键后键应保持不存在(不得复活)"
);
}
#[tokio::test]
async fn expire_expired_key_returns_missing_without_reviving() {
let dao = InMemoryDao::new();
dao.set("exp_expired", "v", 1).await.unwrap();
tokio::time::sleep(Duration::from_secs(2)).await;
let result = dao.expire("exp_expired", 3600).await;
assert!(
matches!(result, Err(GarrisonError::Dao(ref msg)) if msg.contains("dao-key-missing")),
"已过期 key 的 expire 应返回 dao-key-missing,实际: {:?}",
result
);
assert!(
dao.get("exp_expired").await.unwrap().is_none(),
"expire 过期键后键应保持不存在(不得复活)"
);
}
#[tokio::test]
async fn update_and_expire_still_work_for_alive_keys() {
let dao = InMemoryDao::new();
dao.set("alive", "old", 3600).await.unwrap();
dao.update("alive", "new").await.unwrap();
assert_eq!(dao.get("alive").await.unwrap().as_deref(), Some("new"));
dao.expire("alive", 120).await.unwrap();
let ttl = dao.get_timeout("alive").await.unwrap();
assert!(
ttl.is_some() && ttl.unwrap() <= Duration::from_secs(120),
"expire 应重置存活键 TTL"
);
}
}