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 MockDao {
store: Mutex<HashMap<String, (String, Option<Instant>)>>,
}
impl Default for MockDao {
fn default() -> Self {
Self::new()
}
}
impl MockDao {
pub fn new() -> Self {
Self {
store: Mutex::new(HashMap::new()),
}
}
}
#[async_trait]
impl GarrisonDao for MockDao {
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();
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();
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 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 new_val = val_str.parse::<u64>().unwrap_or(0) + 1;
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 eval_lua(
&self,
script: &str,
keys: Vec<String>,
args: Vec<String>,
) -> GarrisonResult<Vec<String>> {
if script.contains("INCR") && script.contains("EXPIRE") {
let key = keys.first().ok_or_else(|| {
GarrisonError::InvalidParam("dao-eval-lua-missing-keys-1".to_string())
})?;
let ttl: u64 = args
.get(1)
.ok_or_else(|| {
GarrisonError::InvalidParam("dao-eval-lua-missing-argv-2-ttl".to_string())
})?
.parse()
.map_err(|e| {
GarrisonError::InvalidParam(format!("dao-eval-lua-argv-2-parse-failed::{}", e))
})?;
let count = self.incr(key, ttl).await?;
return Ok(vec![count.to_string()]);
}
if script.contains("rate_limit_sliding_window") {
let key = keys.first().ok_or_else(|| {
GarrisonError::InvalidParam("dao-eval-lua-rl-missing-keys-1".to_string())
})?;
let now_ms: u64 = args
.first()
.ok_or_else(|| {
GarrisonError::InvalidParam("dao-eval-lua-rl-missing-argv-1-now-ms".to_string())
})?
.parse()
.map_err(|e| {
GarrisonError::InvalidParam(format!(
"dao-eval-lua-rl-argv-1-parse-failed::{}",
e
))
})?;
let window_start_ms: u64 = args
.get(1)
.ok_or_else(|| {
GarrisonError::InvalidParam(
"dao-eval-lua-rl-missing-argv-2-window-start".to_string(),
)
})?
.parse()
.map_err(|e| {
GarrisonError::InvalidParam(format!(
"dao-eval-lua-rl-argv-2-parse-failed::{}",
e
))
})?;
let threshold: usize = args
.get(2)
.ok_or_else(|| {
GarrisonError::InvalidParam(
"dao-eval-lua-rl-missing-argv-3-threshold".to_string(),
)
})?
.parse()
.map_err(|e| {
GarrisonError::InvalidParam(format!(
"dao-eval-lua-rl-argv-3-parse-failed::{}",
e
))
})?;
let ttl_seconds: u64 = args
.get(3)
.ok_or_else(|| {
GarrisonError::InvalidParam("dao-eval-lua-rl-missing-argv-4-ttl".to_string())
})?
.parse()
.map_err(|e| {
GarrisonError::InvalidParam(format!(
"dao-eval-lua-rl-argv-4-parse-failed::{}",
e
))
})?;
let mut store = self.store.lock();
let now = Instant::now();
let mut timestamps: Vec<u64> = match store.get(key) {
Some((raw, Some(deadline))) if *deadline > now => raw
.split(',')
.filter(|s| !s.is_empty())
.filter_map(|s| s.parse::<u64>().ok())
.filter(|&t| t > window_start_ms)
.collect(),
Some((raw, None)) => raw
.split(',')
.filter(|s| !s.is_empty())
.filter_map(|s| s.parse::<u64>().ok())
.filter(|&t| t > window_start_ms)
.collect(),
_ => Vec::new(),
};
if timestamps.len() >= threshold {
return Ok(vec!["0".to_string()]);
}
timestamps.push(now_ms);
let new_raw = timestamps
.iter()
.map(|t| t.to_string())
.collect::<Vec<_>>()
.join(",");
let expire_at = if ttl_seconds == 0 {
None
} else {
Some(now + Duration::from_secs(ttl_seconds))
};
store.insert(key.to_string(), (new_raw, expire_at));
return Ok(vec!["1".to_string()]);
}
Err(GarrisonError::NotImplemented(format!(
"dao-eval-lua-unsupported-script::{}",
script
)))
}
}
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()
}