Skip to main content

kape_memory/backend/
memory.rs

1use std::{hash::Hash, sync::Arc, time::Instant};
2
3use async_trait::async_trait;
4use kape::{CacheBackend, CacheEntry, KapeResult};
5use moka::future::Cache;
6
7use super::entry::{EntryExpiry, MemoryEntry};
8
9/// An in-memory cache backend with an entry-count capacity.
10///
11/// Clones share the same storage. Independently constructed instances are
12/// isolated, including for [`CacheBackend::clear`].
13pub struct MemoryBackend<K, V> {
14    cache: Cache<K, MemoryEntry<V>>,
15}
16
17impl<K, V> Clone for MemoryBackend<K, V> {
18    fn clone(&self) -> Self {
19        Self {
20            cache: self.cache.clone(),
21        }
22    }
23}
24
25impl<K, V> MemoryBackend<K, V>
26where
27    K: Clone + Eq + Hash + Send + Sync + 'static,
28    V: Send + Sync + 'static,
29{
30    /// Creates a backend capped at `max_capacity` entries.
31    #[must_use]
32    pub fn new(max_capacity: u64) -> Self {
33        Self {
34            cache: Cache::builder()
35                .max_capacity(max_capacity)
36                .expire_after(EntryExpiry)
37                .build(),
38        }
39    }
40}
41
42#[async_trait]
43impl<K, V> CacheBackend<K, V> for MemoryBackend<K, V>
44where
45    K: Clone + Eq + Hash + Send + Sync + 'static,
46    V: Send + Sync + 'static,
47{
48    async fn get(&self, key: &K) -> KapeResult<Option<CacheEntry<V>>> {
49        if let Some(entry) = self.cache.get(key).await {
50            if let Some(entry) = entry.into_cache_entry_at(Instant::now())? {
51                return Ok(Some(entry));
52            }
53            self.cache.invalidate(key).await;
54        }
55        Ok(None)
56    }
57
58    async fn set(&self, key: &K, value: Arc<V>, ttl: i64) -> KapeResult<()> {
59        let Some(entry) = MemoryEntry::from_write(value, ttl, Instant::now())? else {
60            return self.remove(key).await;
61        };
62        self.cache.insert(key.clone(), entry).await;
63        Ok(())
64    }
65
66    async fn remove(&self, key: &K) -> KapeResult<()> {
67        self.cache.invalidate(key).await;
68        Ok(())
69    }
70
71    async fn clear(&self) -> KapeResult<()> {
72        self.cache.invalidate_all();
73        self.cache.run_pending_tasks().await;
74        Ok(())
75    }
76}
77
78#[cfg(test)]
79mod tests {
80    use std::{sync::Arc, time::Duration};
81
82    use kape::CacheBackend;
83    use tokio::time::sleep;
84
85    use super::MemoryBackend;
86
87    #[tokio::test]
88    async fn moka_maintenance_removes_expired_entries_without_reading_each_key() {
89        let backend = MemoryBackend::<String, String>::new(100);
90        for index in 0..8 {
91            let key = format!("key-{index}");
92            backend
93                .set(&key, Arc::new(key.clone()), 500)
94                .await
95                .expect("expiring write failed");
96        }
97        backend.cache.run_pending_tasks().await;
98        assert_eq!(backend.cache.entry_count(), 8);
99
100        sleep(Duration::from_millis(1_200)).await;
101        backend.cache.run_pending_tasks().await;
102
103        assert_eq!(backend.cache.entry_count(), 0);
104    }
105}