feat: cache port

Author: thuan2172001

Cargo.lock

@@ -49,3 +49,6 @@ version = "1.0.80"
 
 [dependencies.tonic]
 version = "0.11.0"
+
+[dependencies.redis-async]
+version = "0.17.1"

src/adapter/Cargo.toml

@@ -0,0 +1,109 @@
+use std::{
+    collections::HashMap,
+    sync::Arc,
+    time::{Duration, SystemTime},
+};
+
+use async_trait::async_trait;
+use tokio::sync::RwLock;
+
+use rust_core::common::errors::CoreError;
+use rust_core::ports::cache::CachePort;
+
+/// Represents an in-memory cache implementation.
+pub struct InMemoryCache {
+    cache: Arc<RwLock<HashMap<String, (String, SystemTime, Option<Duration>)>>>,
+}
+
+impl InMemoryCache {
+    /// Creates a new empty in-memory cache.
+    pub fn new() -> Self {
+        Self {
+            cache: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    /// Removes expired entries from the cache asynchronously.
+    ///
+    /// This method is used to remove any expired cache entries based on their expiration time.
+    ///
+    /// # Returns
+    ///
+    /// Returns `Ok(())` if the cleanup is successful, otherwise returns a `CoreError`.
+    async fn cleanup_expired_entries(&self) -> Result<(), CoreError> {
+        let mut cache = self.cache.write().await;
+        let now = SystemTime::now();
+        cache.retain(|_, (_, expiry_time, _)| *expiry_time > now);
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl CachePort for InMemoryCache {
+    /// Retrieves a value from the cache based on the provided key.
+    ///
+    /// # Arguments
+    ///
+    /// * `key`: A string representing the key to retrieve from the cache.
+    ///
+    /// # Returns
+    ///
+    /// Returns a `Result` containing `Some(value)` if the key is found and not expired,
+    /// or `None` if the key is not found or expired. Returns a `CoreError` on failure.
+    async fn get(&self, key: &str) -> Result<Option<String>, CoreError> {
+        let cache = self.cache.read().await;
+        Ok(cache
+            .get(key)
+            .filter(|(_, expiry_time, _)| *expiry_time > SystemTime::now())
+            .map(|(value, _, _)| value.clone()))
+    }
+
+    /// Sets a key-value pair in the cache with an optional expiration duration.
+    ///
+    /// # Arguments
+    ///
+    /// * `key`: A string representing the key to set in the cache.
+    /// * `value`: A string representing the value to associate with the key.
+    /// * `expiration`: An optional `Duration` specifying the expiration time for the key-value pair.
+    ///
+    /// # Returns
+    ///
+    /// Returns `Ok(())` if the set operation is successful, otherwise returns a `CoreError`.
+    async fn set(
+        &mut self,
+        key: String,
+        value: String,
+        expiration: Option<Duration>,
+    ) -> Result<bool, CoreError> {
+        self.cleanup_expired_entries().await?;
+        let expiry_time = expiration.map(|exp| SystemTime::now() + exp);
+        let mut cache = self.cache.write().await;
+        cache.insert(
+            key,
+            (
+                value,
+                expiry_time.unwrap_or_else(|| SystemTime::UNIX_EPOCH),
+                expiration,
+            ),
+        );
+        Ok(true)
+    }
+
+    /// Removes a key-value pair from the cache based on the provided key.
+    ///
+    /// # Arguments
+    ///
+    /// * `key`: A string representing the key to remove from the cache.
+    ///
+    /// # Returns
+    ///
+    /// Returns `Ok(())` if the key is found and removed, otherwise returns a `CoreError`.
+    async fn remove(&mut self, key: &str) -> Result<bool, CoreError> {
+        let mut cache = self.cache.write().await;
+        if cache.remove(key).is_some() {
+            Ok(true)
+        } else {
+            Err(CoreError::NotFound)
+        }
+    }
+}

src/adapter/src/repositories/in_memory/cache.rs

@@ -1 +1,2 @@
+pub mod cache;
 pub mod question;

src/adapter/src/repositories/in_memory/mod.rs

@@ -1,4 +1,5 @@
 pub mod grpc;
 pub mod in_memory;
 pub mod postgres;
+pub mod redis;
 pub mod repository_test;

src/adapter/src/repositories/mod.rs

@@ -0,0 +1,104 @@
+use async_trait::async_trait;
+use redis_async::{client, resp::RespValue, resp_array};
+
+use rust_core::{common::errors::CoreError, ports::cache::CachePort};
+
+use std::time::Duration;
+
+/// Represents a Redis cache implementation.
+pub struct RedisCache {
+    client: client::PairedConnection,
+}
+
+impl RedisCache {
+    /// Creates a new Redis cache instance.
+    ///
+    /// # Arguments
+    ///
+    /// * `redis_host`: Hostname or IP address of the Redis server.
+    /// * `redis_port`: Port number of the Redis server.
+    ///
+    /// # Returns
+    ///
+    /// Returns a `Result` containing the initialized `RedisCache` instance.
+    pub async fn new(redis_host: &str, redis_port: u16) -> Result<Self, CoreError> {
+        let client = client::paired_connect(redis_host, redis_port)
+            .await
+            .map_err(|err| CoreError::InternalError(err.into()))?;
+        Ok(Self { client })
+    }
+}
+
+#[async_trait]
+impl CachePort for RedisCache {
+    /// Retrieves a value from the Redis cache.
+    ///
+    /// # Arguments
+    ///
+    /// * `key`: The key of the value to retrieve.
+    ///
+    /// # Returns
+    ///
+    /// Returns a `Result` containing the value associated with the key if found, or `None`.
+    async fn get(&self, key: &str) -> Result<Option<String>, CoreError> {
+        let result: Result<RespValue, _> = self.client.send(resp_array!["GET", key]).await;
+        match result {
+            Ok(RespValue::BulkString(data)) => Ok(Some(String::from_utf8_lossy(&data).to_string())),
+            _ => Ok(None),
+        }
+    }
+
+    /// Sets a key-value pair in the Redis cache with an optional expiration time.
+    ///
+    /// # Arguments
+    ///
+    /// * `key`: The key to set.
+    /// * `value`: The value to associate with the key.
+    /// * `expiration`: Optional expiration duration for the key-value pair.
+    ///
+    /// # Returns
+    ///
+    /// Returns a `Result` indicating success (`true`) or failure (`false`).
+    async fn set(
+        &mut self,
+        key: String,
+        value: String,
+        expiration: Option<Duration>,
+    ) -> Result<bool, CoreError> {
+        let mut args = vec!["SET", &key, &value];
+
+        let exp_secs = if let Some(exp) = expiration {
+            args.push("EX");
+            Some(exp.as_secs().to_string())
+        } else {
+            None
+        };
+
+        if let Some(ref secs) = exp_secs {
+            args.push(secs);
+        }
+
+        let result: Result<RespValue, _> = self.client.send(resp_array![].append(args)).await;
+        match result {
+            Ok(RespValue::SimpleString(s)) if s == "OK" => Ok(true),
+            _ => Ok(false),
+        }
+    }
+
+    /// Removes a key-value pair from the Redis cache.
+    ///
+    /// # Arguments
+    ///
+    /// * `key`: The key to remove.
+    ///
+    /// # Returns
+    ///
+    /// Returns a `Result` indicating success (`true`) or failure (`false`).
+    async fn remove(&mut self, key: &str) -> Result<bool, CoreError> {
+        let result: Result<RespValue, _> = self.client.send(resp_array!["DEL", key]).await;
+        match result {
+            Ok(RespValue::Integer(1)) => Ok(true),
+            _ => Ok(false),
+        }
+    }
+}

src/adapter/src/repositories/redis/cache.rs

@@ -0,0 +1 @@
+pub mod cache;

src/adapter/src/repositories/redis/mod.rs

@@ -0,0 +1,49 @@
+use async_trait::async_trait;
+
+use std::time::Duration;
+
+use crate::common::errors::CoreError;
+
+/// Represents a cache port for storing key-value pairs.
+#[async_trait]
+pub trait CachePort {
+    /// Retrieves a value from the cache based on the given key.
+    ///
+    /// # Arguments
+    ///
+    /// * `key`: The key to look up in the cache.
+    ///
+    /// # Returns
+    ///
+    /// Returns an optional value associated with the key, or `None` if the key is not present in the cache.
+    async fn get(&self, key: &str) -> Result<Option<String>, CoreError>;
+
+    /// Sets a key-value pair in the cache with an optional expiration duration.
+    ///
+    /// # Arguments
+    ///
+    /// * `key`: The key to set in the cache.
+    /// * `value`: The value to associate with the key.
+    /// * `expiration`: Optional expiration duration for the key-value pair.
+    ///
+    /// # Returns
+    ///
+    /// Returns `true` if the key-value pair is successfully set in the cache, `false` otherwise.
+    async fn set(
+        &mut self,
+        key: String,
+        value: String,
+        expiration: Option<Duration>,
+    ) -> Result<bool, CoreError>;
+
+    /// Removes a key-value pair from the cache based on the given key.
+    ///
+    /// # Arguments
+    ///
+    /// * `key`: The key to remove from the cache.
+    ///
+    /// # Returns
+    ///
+    /// Returns `true` if the key-value pair is successfully removed from the cache, `false` otherwise.
+    async fn remove(&mut self, key: &str) -> Result<bool, CoreError>;
+}

src/core/src/ports/cache.rs

@@ -1,2 +1,3 @@
+pub mod cache;
 pub mod gpt_answer;
 pub mod question;

src/core/src/ports/mod.rs

@@ -18,6 +18,9 @@ path = "../core"
 [dependencies.common]
 path = "../common"
 
+[dependencies.adapter]
+path = "../adapter"
+
 [dependencies.tonic]
 version = "0.11.0"