use std::collections::HashMap;
use std::sync::Mutex;
use std::time::{Duration, Instant};
use crate::error::GuardAgentError;
use async_trait::async_trait;
pub const NAMESPACE_EVENTS: &str = "agent_events";
pub const NAMESPACE_METRICS: &str = "agent_metrics";
pub const PERSIST_TTL_SECONDS: u64 = 3600;
#[async_trait]
pub trait RedisHandler: Send + Sync + 'static {
async fn set_key(
&self,
namespace: &str,
key: &str,
value: &str,
ttl_seconds: u64,
) -> Result<(), GuardAgentError>;
async fn get_key(&self, namespace: &str, key: &str) -> Result<Option<String>, GuardAgentError>;
async fn delete_keys(&self, namespace: &str, keys: &[String]) -> Result<(), GuardAgentError>;
async fn list_keys(&self, namespace: &str) -> Result<Vec<String>, GuardAgentError>;
async fn clear_namespace(&self, namespace: &str) -> Result<(), GuardAgentError>;
}
fn namespaced_key(namespace: &str, key: &str) -> String {
format!("{namespace}:{key}")
}
#[derive(Debug)]
struct Entry {
value: String,
expires_at: Option<Instant>,
}
impl Entry {
fn is_expired(&self, now: Instant) -> bool {
self.expires_at.is_some_and(|expires_at| now >= expires_at)
}
}
#[derive(Debug, Default)]
pub struct InMemoryRedisStore {
entries: Mutex<HashMap<String, Entry>>,
}
impl InMemoryRedisStore {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn len(&self) -> usize {
let now = Instant::now();
let mut entries = self.entries.lock().expect("store mutex not poisoned");
entries.retain(|_, entry| !entry.is_expired(now));
entries.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
#[must_use]
pub fn peek(&self, namespace: &str, key: &str) -> Option<String> {
let entries = self.entries.lock().expect("store mutex not poisoned");
entries
.get(&namespaced_key(namespace, key))
.map(|entry| entry.value.clone())
}
#[must_use]
pub fn keys(&self, namespace: &str) -> Vec<String> {
let prefix = format!("{namespace}:");
let entries = self.entries.lock().expect("store mutex not poisoned");
let mut keys: Vec<String> = entries
.keys()
.filter_map(|key| key.strip_prefix(&prefix).map(str::to_owned))
.collect();
keys.sort();
keys
}
}
#[async_trait]
impl RedisHandler for InMemoryRedisStore {
async fn set_key(
&self,
namespace: &str,
key: &str,
value: &str,
ttl_seconds: u64,
) -> Result<(), GuardAgentError> {
let expires_at = if ttl_seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(ttl_seconds))
};
let mut entries = self.entries.lock().expect("store mutex not poisoned");
entries.insert(
namespaced_key(namespace, key),
Entry {
value: value.to_owned(),
expires_at,
},
);
Ok(())
}
async fn get_key(&self, namespace: &str, key: &str) -> Result<Option<String>, GuardAgentError> {
let now = Instant::now();
let full_key = namespaced_key(namespace, key);
let mut entries = self.entries.lock().expect("store mutex not poisoned");
if entries
.get(&full_key)
.is_some_and(|entry| entry.is_expired(now))
{
entries.remove(&full_key);
}
Ok(entries.get(&full_key).map(|entry| entry.value.clone()))
}
async fn delete_keys(&self, namespace: &str, keys: &[String]) -> Result<(), GuardAgentError> {
let mut entries = self.entries.lock().expect("store mutex not poisoned");
for key in keys {
entries.remove(&namespaced_key(namespace, key));
}
Ok(())
}
async fn list_keys(&self, namespace: &str) -> Result<Vec<String>, GuardAgentError> {
let now = Instant::now();
let prefix = format!("{namespace}:");
let mut entries = self.entries.lock().expect("store mutex not poisoned");
entries.retain(|_, entry| !entry.is_expired(now));
let mut keys: Vec<String> = entries
.keys()
.filter_map(|key| key.strip_prefix(&prefix).map(str::to_owned))
.collect();
keys.sort();
Ok(keys)
}
async fn clear_namespace(&self, namespace: &str) -> Result<(), GuardAgentError> {
let prefix = format!("{namespace}:");
let mut entries = self.entries.lock().expect("store mutex not poisoned");
entries.retain(|key, _| !key.starts_with(&prefix));
Ok(())
}
}
#[cfg(feature = "persistence")]
#[derive(Debug, Clone)]
pub struct RedisClientHandler {
connection: redis::aio::MultiplexedConnection,
key_prefix: String,
command_timeout: Duration,
}
#[cfg(feature = "persistence")]
impl RedisClientHandler {
pub async fn connect(config: &crate::config::RedisConfig) -> Result<Self, GuardAgentError> {
let client = redis::Client::open(config.url.as_str())
.map_err(|error| GuardAgentError::Redis(error.to_string()))?;
let connection = client
.get_multiplexed_async_connection()
.await
.map_err(|error| GuardAgentError::Redis(error.to_string()))?;
Ok(Self {
connection,
key_prefix: config.key_prefix.clone(),
command_timeout: Duration::from_millis(config.command_timeout_ms),
})
}
fn full_key(&self, namespace: &str, key: &str) -> String {
format!("{}:{namespace}:{key}", self.key_prefix)
}
async fn query<T: redis::FromRedisValue>(
&self,
cmd: &redis::Cmd,
) -> Result<T, GuardAgentError> {
let mut connection = self.connection.clone();
let pending = cmd.query_async::<T>(&mut connection);
tokio::time::timeout(self.command_timeout, pending)
.await
.map_err(|_| GuardAgentError::Redis("command timed out".to_owned()))?
.map_err(|error| GuardAgentError::Redis(error.to_string()))
}
}
#[cfg(feature = "persistence")]
#[async_trait]
impl RedisHandler for RedisClientHandler {
async fn set_key(
&self,
namespace: &str,
key: &str,
value: &str,
ttl_seconds: u64,
) -> Result<(), GuardAgentError> {
let mut cmd = redis::cmd("SET");
cmd.arg(self.full_key(namespace, key))
.arg(value)
.arg("EX")
.arg(ttl_seconds);
let _: () = self.query(&cmd).await?;
Ok(())
}
async fn get_key(&self, namespace: &str, key: &str) -> Result<Option<String>, GuardAgentError> {
let mut cmd = redis::cmd("GET");
cmd.arg(self.full_key(namespace, key));
self.query(&cmd).await
}
async fn delete_keys(&self, namespace: &str, keys: &[String]) -> Result<(), GuardAgentError> {
if keys.is_empty() {
return Ok(());
}
let mut cmd = redis::cmd("DEL");
for key in keys {
cmd.arg(self.full_key(namespace, key));
}
let _: () = self.query(&cmd).await?;
Ok(())
}
async fn list_keys(&self, namespace: &str) -> Result<Vec<String>, GuardAgentError> {
let prefix = format!("{}:{namespace}:", self.key_prefix);
let mut cmd = redis::cmd("KEYS");
cmd.arg(format!("{prefix}*"));
let full_keys: Vec<String> = self.query(&cmd).await?;
let mut short_keys: Vec<String> = full_keys
.iter()
.filter_map(|key| key.strip_prefix(&prefix).map(str::to_owned))
.collect();
short_keys.sort();
Ok(short_keys)
}
async fn clear_namespace(&self, namespace: &str) -> Result<(), GuardAgentError> {
let keys = self.list_keys(namespace).await?;
self.delete_keys(namespace, &keys).await
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(feature = "persistence")]
#[tokio::test]
async fn connect_rejects_malformed_urls_without_io() {
let config = crate::config::RedisConfig {
url: "not-a-redis-url".to_owned(),
key_prefix: "guard".to_owned(),
command_timeout_ms: 1_000,
};
let outcome = RedisClientHandler::connect(&config).await;
assert!(matches!(outcome, Err(GuardAgentError::Redis(_))));
}
#[cfg(feature = "persistence")]
#[tokio::test]
async fn query_times_out_against_a_silent_server() {
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
std::thread::spawn(move || {
use std::io::{Read as _, Write as _};
let (mut stream, _) = listener.accept().expect("the client connects");
let mut buffer = [0u8; 1024];
loop {
let read = stream.read(&mut buffer).expect("socket read");
let handshake = buffer[..read]
.windows(7)
.filter(|w| w == b"SETINFO")
.count();
if handshake == 0 {
break;
}
for _ in 0..handshake {
let _ = stream.write_all(b"-ERR unknown command\r\n");
}
let _ = stream.flush();
}
std::thread::sleep(std::time::Duration::from_secs(10));
});
let config = crate::config::RedisConfig {
url: format!("redis://{addr}"),
key_prefix: "guard".to_owned(),
command_timeout_ms: 50,
};
let handler = RedisClientHandler::connect(&config)
.await
.expect("the handshake completes");
let outcome = handler.get_key(NAMESPACE_EVENTS, "slow").await;
assert!(
matches!(&outcome, Err(GuardAgentError::Redis(message)) if message.contains("timed out")),
"{outcome:?}"
);
}
#[cfg(feature = "persistence")]
#[tokio::test]
async fn query_surfaces_resp_errors_from_the_server() {
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
std::thread::spawn(move || {
use std::io::{Read as _, Write as _};
let (mut stream, _) = listener.accept().expect("the client connects");
let mut buffer = [0u8; 1024];
loop {
let read = stream.read(&mut buffer).expect("socket read");
let handshake = buffer[..read]
.windows(7)
.filter(|w| w == b"SETINFO")
.count();
for _ in 0..handshake {
let _ = stream.write_all(b"-ERR unknown command\r\n");
}
if handshake == 0 {
let _ = stream.write_all(b"-ERR mocked failure\r\n");
let _ = stream.flush();
std::thread::sleep(std::time::Duration::from_secs(5));
} else {
let _ = stream.flush();
}
}
});
let config = crate::config::RedisConfig {
url: format!("redis://{addr}"),
key_prefix: "guard".to_owned(),
command_timeout_ms: 2_000,
};
let handler = RedisClientHandler::connect(&config)
.await
.expect("the handshake completes");
let outcome = handler.get_key(NAMESPACE_EVENTS, "boom").await;
assert!(
matches!(outcome, Err(GuardAgentError::Redis(_))),
"{outcome:?}"
);
}
async fn stored_keys(store: &InMemoryRedisStore, namespace: &str) -> Vec<String> {
store.list_keys(namespace).await.unwrap()
}
#[tokio::test]
async fn peek_reads_stored_values_regardless_of_expiry() {
let store = InMemoryRedisStore::new();
store
.set_key(
NAMESPACE_EVENTS,
"event_peek",
"{\"b\":2}",
PERSIST_TTL_SECONDS,
)
.await
.unwrap();
assert_eq!(
store.peek(NAMESPACE_EVENTS, "event_peek").as_deref(),
Some("{\"b\":2}")
);
assert_eq!(store.peek(NAMESPACE_EVENTS, "missing"), None);
}
#[tokio::test]
async fn set_and_get_round_trip() {
let store = InMemoryRedisStore::new();
store
.set_key(
NAMESPACE_EVENTS,
"event_1",
"{\"a\":1}",
PERSIST_TTL_SECONDS,
)
.await
.unwrap();
let loaded = store.get_key(NAMESPACE_EVENTS, "event_1").await.unwrap();
assert_eq!(loaded.as_deref(), Some("{\"a\":1}"));
assert!(
store
.get_key(NAMESPACE_EVENTS, "missing")
.await
.unwrap()
.is_none()
);
}
#[tokio::test]
async fn namespaces_are_isolated() {
let store = InMemoryRedisStore::new();
store
.set_key(NAMESPACE_EVENTS, "shared", "event", PERSIST_TTL_SECONDS)
.await
.unwrap();
store
.set_key(NAMESPACE_METRICS, "shared", "metric", PERSIST_TTL_SECONDS)
.await
.unwrap();
assert_eq!(
stored_keys(&store, NAMESPACE_EVENTS).await,
vec!["shared".to_owned()]
);
assert_eq!(
stored_keys(&store, NAMESPACE_METRICS).await,
vec!["shared".to_owned()]
);
assert_eq!(
store
.get_key(NAMESPACE_EVENTS, "shared")
.await
.unwrap()
.as_deref(),
Some("event")
);
}
#[tokio::test]
async fn delete_removes_records_and_ignores_missing() {
let store = InMemoryRedisStore::new();
store
.set_key(NAMESPACE_EVENTS, "a", "1", PERSIST_TTL_SECONDS)
.await
.unwrap();
store
.set_key(NAMESPACE_EVENTS, "b", "2", PERSIST_TTL_SECONDS)
.await
.unwrap();
store
.delete_keys(NAMESPACE_EVENTS, &["a".to_owned(), "missing".to_owned()])
.await
.unwrap();
assert_eq!(
stored_keys(&store, NAMESPACE_EVENTS).await,
vec!["b".to_owned()]
);
}
#[tokio::test]
async fn clear_namespace_wipes_only_that_namespace() {
let store = InMemoryRedisStore::new();
store
.set_key(NAMESPACE_EVENTS, "a", "1", PERSIST_TTL_SECONDS)
.await
.unwrap();
store
.set_key(NAMESPACE_METRICS, "b", "2", PERSIST_TTL_SECONDS)
.await
.unwrap();
store.clear_namespace(NAMESPACE_EVENTS).await.unwrap();
assert_eq!(
stored_keys(&store, NAMESPACE_EVENTS).await,
Vec::<String>::new()
);
assert_eq!(
stored_keys(&store, NAMESPACE_METRICS).await,
vec!["b".to_owned()]
);
}
#[tokio::test]
async fn expired_records_disappear() {
let store = InMemoryRedisStore::new();
store
.set_key(NAMESPACE_EVENTS, "short_lived", "1", 1)
.await
.unwrap();
assert!(
store
.get_key(NAMESPACE_EVENTS, "short_lived")
.await
.unwrap()
.is_some()
);
tokio::time::sleep(Duration::from_millis(1100)).await;
assert!(
store
.get_key(NAMESPACE_EVENTS, "short_lived")
.await
.unwrap()
.is_none()
);
assert_eq!(
stored_keys(&store, NAMESPACE_EVENTS).await,
Vec::<String>::new()
);
assert_eq!(store.len(), 0);
assert!(store.is_empty());
}
#[tokio::test]
async fn ttl_zero_never_expires() {
let store = InMemoryRedisStore::new();
store
.set_key(NAMESPACE_EVENTS, "forever", "1", 0)
.await
.unwrap();
assert!(
store
.get_key(NAMESPACE_EVENTS, "forever")
.await
.unwrap()
.is_some()
);
}
#[test]
fn namespaced_keys_are_prefixed() {
assert_eq!(
namespaced_key(NAMESPACE_EVENTS, "event_1"),
"agent_events:event_1"
);
}
}