use moka::future::Cache;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::time::Duration;
use tracing::debug;
const _DEFAULT_TTL_SECS: u64 = 3600;
const _DEFAULT_MAX_ENTRIES: u64 = 1000;
const MAX_ENTRY_BYTES: usize = 10 * 1024 * 1024;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CachedEntry {
pub value: serde_json::Value,
pub created_at: u64,
pub key: String,
}
#[derive(Clone)]
pub struct MemoryCache {
inner: Arc<Cache<String, CachedEntry>>,
enabled: bool,
ttl: Duration,
}
impl MemoryCache {
pub fn new(max_entries: u64, ttl_secs: u64, enabled: bool) -> Self {
let ttl = Duration::from_secs(ttl_secs);
let inner = Cache::builder()
.max_capacity(max_entries)
.time_to_live(ttl)
.time_to_idle(Duration::from_secs(ttl_secs / 2))
.build();
Self {
inner: Arc::new(inner),
enabled,
ttl,
}
}
pub fn from_config(config: &crate::config::CacheConfig) -> Self {
Self::new(config.memory_max_entries, config.ttl_secs, config.enabled)
}
pub async fn get<T: for<'de> Deserialize<'de>>(&self, key: &str) -> Option<T> {
if !self.enabled {
return None;
}
let entry = self.inner.get(key).await?;
debug!("Cache HIT: {key}");
serde_json::from_value(entry.value).ok()
}
pub async fn set<T: Serialize>(&self, key: &str, value: &T) {
if !self.enabled {
return;
}
let json_str = match serde_json::to_string(value) {
Ok(s) => s,
Err(e) => {
debug!("Cache: failed to serialize for key {key}: {e}");
return;
}
};
let size = json_str.len();
if size > MAX_ENTRY_BYTES {
debug!("Cache: skipping oversized entry for {key} ({size} bytes)");
return;
}
let json = match serde_json::from_str(&json_str) {
Ok(v) => v,
Err(e) => {
debug!("Cache: failed to re-parse for key {key}: {e}");
return;
}
};
let entry = CachedEntry {
value: json,
created_at: unix_now(),
key: key.to_string(),
};
self.inner.insert(key.to_string(), entry).await;
debug!("Cache SET: {key} ({size} bytes)");
}
pub async fn invalidate(&self, key: &str) {
self.inner.invalidate(key).await;
debug!("Cache INVALIDATE: {key}");
}
pub async fn clear(&self) {
self.inner.invalidate_all();
debug!("Cache CLEAR: all entries removed");
}
pub fn stats(&self) -> CacheStats {
CacheStats {
entry_count: self.inner.entry_count(),
weighted_size: self.inner.weighted_size(),
ttl_secs: self.ttl.as_secs(),
enabled: self.enabled,
}
}
pub fn is_enabled(&self) -> bool {
self.enabled
}
}
impl std::fmt::Debug for MemoryCache {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MemoryCache")
.field("enabled", &self.enabled)
.field("entry_count", &self.inner.entry_count())
.finish()
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CacheStats {
pub entry_count: u64,
pub weighted_size: u64,
pub ttl_secs: u64,
pub enabled: bool,
}
fn hash_component(input: &str) -> String {
use sha2::{Digest, Sha256};
let hash = Sha256::digest(input.as_bytes());
format!("{:x}", hash)[..16].to_string()
}
pub fn fetch_key(url: &str) -> String {
format!("fetch:{}", hash_component(url))
}
pub fn search_key(query: &str, backend: &str, max_results: u32) -> String {
let input = format!("{query}:{backend}:{max_results}");
format!("search:{}", hash_component(&input))
}
pub fn qatbe_key(url: &str, query: &str, budget: u32) -> String {
let input = format!("{url}:{query}:{budget}");
format!("qatbe:{}", hash_component(&input))
}
fn unix_now() -> u64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_secs()
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn cache_set_and_get() {
let cache = MemoryCache::new(100, 3600, true);
let key = "test:key";
let value = serde_json::json!({"hello": "world", "count": 42});
cache.set(key, &value).await;
let retrieved: Option<serde_json::Value> = cache.get(key).await;
assert!(retrieved.is_some());
assert_eq!(retrieved.unwrap()["count"], 42);
}
#[tokio::test]
async fn disabled_cache_returns_none() {
let cache = MemoryCache::new(100, 3600, false);
cache.set("key", &"value").await;
let result: Option<String> = cache.get("key").await;
assert!(result.is_none());
}
#[tokio::test]
async fn cache_miss_returns_none() {
let cache = MemoryCache::new(100, 3600, true);
let result: Option<String> = cache.get("nonexistent:key").await;
assert!(result.is_none());
}
#[tokio::test]
async fn cache_invalidate() {
let cache = MemoryCache::new(100, 3600, true);
cache.set("mykey", &42u32).await;
cache.invalidate("mykey").await;
let result: Option<u32> = cache.get("mykey").await;
assert!(result.is_none());
}
#[tokio::test]
async fn cache_stats() {
let cache = MemoryCache::new(100, 3600, true);
cache.set("k1", &"v1").await;
cache.set("k2", &"v2").await;
let stats = cache.stats();
assert!(stats.enabled);
assert_eq!(stats.ttl_secs, 3600);
}
#[test]
fn cache_key_builders() {
let fk = fetch_key("https://example.com");
assert!(fk.starts_with("fetch:"));
assert_eq!(fk.len(), "fetch:".len() + 16);
let sk = search_key("rust", "ddg", 10);
assert!(sk.starts_with("search:"));
let qk = qatbe_key("https://example.com", "rust", 4000);
assert!(qk.starts_with("qatbe:"));
assert_eq!(fetch_key("https://example.com"), fk);
assert_ne!(fetch_key("https://other.com"), fk);
}
}