Skip to main content

yaiko_core/
query_client.rs

1//! Bounded query-client cache facade.
2use std::collections::BTreeMap;
3#[derive(Debug, Clone, PartialEq, Eq)]
4pub enum QueryClientError {
5    InvalidKey,
6    Capacity,
7    InvalidTtl,
8}
9#[derive(Debug, Clone, PartialEq, Eq)]
10pub struct QueryEntry {
11    pub key: String,
12    pub value: Vec<u8>,
13    pub stored_at: u64,
14    pub ttl: u64,
15}
16#[derive(Debug, Clone)]
17pub struct QueryClient {
18    entries: BTreeMap<String, QueryEntry>,
19    capacity: usize,
20}
21impl QueryClient {
22    pub fn new(capacity: usize) -> Self {
23        Self {
24            entries: BTreeMap::new(),
25            capacity,
26        }
27    }
28    pub fn set(
29        &mut self,
30        key: impl Into<String>,
31        value: impl Into<Vec<u8>>,
32        stored_at: u64,
33        ttl: u64,
34    ) -> Result<(), QueryClientError> {
35        let key = valid(key.into())?;
36        if ttl == 0 {
37            return Err(QueryClientError::InvalidTtl);
38        }
39        if !self.entries.contains_key(&key) && self.entries.len() >= self.capacity {
40            return Err(QueryClientError::Capacity);
41        }
42        self.entries.insert(
43            key.clone(),
44            QueryEntry {
45                key,
46                value: value.into(),
47                stored_at,
48                ttl,
49            },
50        );
51        Ok(())
52    }
53    pub fn get(&self, key: &str, now: u64) -> Option<&QueryEntry> {
54        self.entries
55            .get(key)
56            .filter(|e| now.saturating_sub(e.stored_at) <= e.ttl)
57    }
58    pub fn invalidate(&mut self, key: &str) -> bool {
59        self.entries.remove(key).is_some()
60    }
61    pub fn invalidate_prefix(&mut self, prefix: &str) -> usize {
62        let keys = self
63            .entries
64            .keys()
65            .filter(|k| k.starts_with(prefix))
66            .cloned()
67            .collect::<Vec<_>>();
68        let n = keys.len();
69        for k in keys {
70            self.entries.remove(&k);
71        }
72        n
73    }
74    pub fn snapshot(&self) -> Vec<QueryEntry> {
75        self.entries.values().cloned().collect()
76    }
77}
78impl Default for QueryClient {
79    fn default() -> Self {
80        Self::new(1024)
81    }
82}
83fn valid(k: String) -> Result<String, QueryClientError> {
84    if k.is_empty() || k.len() > 256 || k.chars().any(|c| c.is_control() || c.is_whitespace()) {
85        Err(QueryClientError::InvalidKey)
86    } else {
87        Ok(k)
88    }
89}
90#[cfg(test)]
91mod tests {
92    use super::*;
93    #[test]
94    fn sets_gets_stale_and_invalidates() {
95        let mut c = QueryClient::new(2);
96        c.set("media:1", b"ok".to_vec(), 10, 5).unwrap();
97        assert!(c.get("media:1", 15).is_some());
98        assert!(c.get("media:1", 16).is_none());
99        c.set("media:2", Vec::new(), 1, 2).unwrap();
100        assert_eq!(c.invalidate_prefix("media:"), 2)
101    }
102    #[test]
103    fn validates_ttl_keys_and_capacity() {
104        let mut c = QueryClient::new(1);
105        assert!(c.set("bad key", Vec::new(), 0, 1).is_err());
106        assert!(c.set("a", Vec::new(), 0, 0).is_err());
107        c.set("a", Vec::new(), 0, 1).unwrap();
108        assert!(c.set("b", Vec::new(), 0, 1).is_err())
109    }
110}