feat: init

cache/mod.rs

@@ -0,0 +1,97 @@
+use crate::cache::lru::LruTtlCache;
+use crate::cache::redis::AppRedis;
+use crate::config::AppConfig;
+use crate::error::AppResult;
+use ::redis::Cmd;
+use serde::Serialize;
+use serde::de::DeserializeOwned;
+use std::time::Duration;
+
+pub mod lru;
+pub mod redis;
+
+pub struct AppCache {
+    l1: LruTtlCache<String, String>,
+    l2: AppRedis,
+    key_prefix: String,
+    default_ttl: Duration,
+}
+
+impl AppCache {
+    pub fn from_config(config: &AppConfig) -> AppResult<Self> {
+        let cap = config.lru_default_capacity()?;
+        let ttl = Duration::from_secs(config.lru_default_ttl_secs()?);
+        let l2 = AppRedis::from_config(config)?;
+        let key_prefix = config.redis_key_prefix()?;
+        Ok(Self {
+            l1: LruTtlCache::new(cap, ttl),
+            l2,
+            key_prefix,
+            default_ttl: ttl,
+        })
+    }
+
+    pub fn get<T: DeserializeOwned>(&self, key: &str) -> Option<T> {
+        if let Some(json) = self.l1.get(&key.to_string()) {
+            return serde_json::from_str(&json).ok();
+        }
+
+        let full_key = self.full_key(key);
+        let mut conn = self.l2.get_connection().ok()?;
+        let json: String = Cmd::new()
+            .arg("GET")
+            .arg(&full_key)
+            .query::<Option<String>>(&mut *conn.inner_mut())
+            .ok()??;
+
+        let value: T = serde_json::from_str(&json).ok()?;
+        self.l1.insert(key.to_string(), json);
+        Some(value)
+    }
+
+    pub fn set<T: Serialize>(&self, key: &str, value: &T, ttl: Option<Duration>) -> AppResult<()> {
+        let json = serde_json::to_string(value)?;
+        let full_key = self.full_key(key);
+        let ttl_duration = ttl.unwrap_or(self.default_ttl);
+        let ttl_secs = ttl_duration.as_secs() as usize;
+        let mut conn = self.l2.get_connection()?;
+        Cmd::new()
+            .arg("SETEX")
+            .arg(&full_key)
+            .arg(ttl_secs)
+            .arg(&json)
+            .query::<()>(&mut *conn.inner_mut())?;
+        self.l1.insert_with_ttl(key.to_string(), json, ttl_duration);
+        Ok(())
+    }
+
+    pub fn delete(&self, key: &str) -> AppResult<()> {
+        self.l1.remove(&key.to_string());
+        let full_key = self.full_key(key);
+        let mut conn = self.l2.get_connection()?;
+        Cmd::new()
+            .arg("DEL")
+            .arg(&full_key)
+            .query::<()>(&mut *conn.inner_mut())?;
+        Ok(())
+    }
+
+    pub fn exists(&self, key: &str) -> bool {
+        if self.l1.get(&key.to_string()).is_some() {
+            return true;
+        }
+        let full_key = self.full_key(key);
+        if let Ok(mut conn) = self.l2.get_connection() {
+            return Cmd::new()
+                .arg("EXISTS")
+                .arg(&full_key)
+                .query(&mut *conn.inner_mut())
+                .unwrap_or(false);
+        }
+        false
+    }
+
+    fn full_key(&self, key: &str) -> String {
+        format!("{}{}", self.key_prefix, key)
+    }
+}