...

packages/clients/redisclient/src/redisclient.rs

@@ -0,0 +1,361 @@
+use lazy_static::lazy_static;
+use redis::{Client, Cmd, Connection, RedisError, RedisResult};
+use std::env;
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, Once};
+
+/// Redis connection configuration builder
+///
+/// This struct is used to build a Redis connection configuration.
+/// It follows the builder pattern to allow for flexible configuration.
+#[derive(Clone)]
+pub struct RedisConfigBuilder {
+    pub host: String,
+    pub port: u16,
+    pub db: i64,
+    pub username: Option<String>,
+    pub password: Option<String>,
+    pub use_tls: bool,
+    pub use_unix_socket: bool,
+    pub socket_path: Option<String>,
+    pub connection_timeout: Option<u64>,
+}
+
+impl Default for RedisConfigBuilder {
+    fn default() -> Self {
+        Self {
+            host: "127.0.0.1".to_string(),
+            port: 6379,
+            db: 0,
+            username: None,
+            password: None,
+            use_tls: false,
+            use_unix_socket: false,
+            socket_path: None,
+            connection_timeout: None,
+        }
+    }
+}
+
+impl RedisConfigBuilder {
+    /// Create a new Redis connection configuration builder with default values
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the host for the Redis connection
+    pub fn host(mut self, host: &str) -> Self {
+        self.host = host.to_string();
+        self
+    }
+
+    /// Set the port for the Redis connection
+    pub fn port(mut self, port: u16) -> Self {
+        self.port = port;
+        self
+    }
+
+    /// Set the database for the Redis connection
+    pub fn db(mut self, db: i64) -> Self {
+        self.db = db;
+        self
+    }
+
+    /// Set the username for the Redis connection (Redis 6.0+)
+    pub fn username(mut self, username: &str) -> Self {
+        self.username = Some(username.to_string());
+        self
+    }
+
+    /// Set the password for the Redis connection
+    pub fn password(mut self, password: &str) -> Self {
+        self.password = Some(password.to_string());
+        self
+    }
+
+    /// Enable TLS for the Redis connection
+    pub fn use_tls(mut self, use_tls: bool) -> Self {
+        self.use_tls = use_tls;
+        self
+    }
+
+    /// Use Unix socket for the Redis connection
+    pub fn use_unix_socket(mut self, use_unix_socket: bool) -> Self {
+        self.use_unix_socket = use_unix_socket;
+        self
+    }
+
+    /// Set the Unix socket path for the Redis connection
+    pub fn socket_path(mut self, socket_path: &str) -> Self {
+        self.socket_path = Some(socket_path.to_string());
+        self.use_unix_socket = true;
+        self
+    }
+
+    /// Set the connection timeout in seconds
+    pub fn connection_timeout(mut self, seconds: u64) -> Self {
+        self.connection_timeout = Some(seconds);
+        self
+    }
+
+    /// Build the connection URL from the configuration
+    pub fn build_connection_url(&self) -> String {
+        if self.use_unix_socket {
+            if let Some(ref socket_path) = self.socket_path {
+                return format!("unix://{}", socket_path);
+            } else {
+                // Default socket path
+                let home_dir = env::var("HOME").unwrap_or_else(|_| String::from("/root"));
+                return format!("unix://{}/hero/var/myredis.sock", home_dir);
+            }
+        }
+
+        let mut url = if self.use_tls {
+            format!("rediss://{}:{}", self.host, self.port)
+        } else {
+            format!("redis://{}:{}", self.host, self.port)
+        };
+
+        // Add authentication if provided
+        if let Some(ref username) = self.username {
+            if let Some(ref password) = self.password {
+                url = format!(
+                    "redis://{}:{}@{}:{}",
+                    username, password, self.host, self.port
+                );
+            } else {
+                url = format!("redis://{}@{}:{}", username, self.host, self.port);
+            }
+        } else if let Some(ref password) = self.password {
+            url = format!("redis://:{}@{}:{}", password, self.host, self.port);
+        }
+
+        // Add database
+        url = format!("{}/{}", url, self.db);
+
+        url
+    }
+
+    /// Build a Redis client from the configuration
+    pub fn build(&self) -> RedisResult<(Client, i64)> {
+        let url = self.build_connection_url();
+        let client = Client::open(url)?;
+        Ok((client, self.db))
+    }
+}
+
+// Global Redis client instance using lazy_static
+lazy_static! {
+    static ref REDIS_CLIENT: Mutex<Option<Arc<RedisClientWrapper>>> = Mutex::new(None);
+    static ref INIT: Once = Once::new();
+}
+
+// Wrapper for Redis client to handle connection and DB selection
+pub struct RedisClientWrapper {
+    client: Client,
+    connection: Mutex<Option<Connection>>,
+    db: i64,
+    initialized: AtomicBool,
+}
+
+impl RedisClientWrapper {
+    // Create a new Redis client wrapper
+    fn new(client: Client, db: i64) -> Self {
+        RedisClientWrapper {
+            client,
+            connection: Mutex::new(None),
+            db,
+            initialized: AtomicBool::new(false),
+        }
+    }
+
+    // Execute a command on the Redis connection
+    pub fn execute<T: redis::FromRedisValue>(&self, cmd: &mut Cmd) -> RedisResult<T> {
+        let mut conn_guard = self.connection.lock().unwrap();
+
+        // If we don't have a connection or it's not working, create a new one
+        if conn_guard.is_none() || {
+            if let Some(ref mut conn) = *conn_guard {
+                let ping_result: RedisResult<String> = redis::cmd("PING").query(conn);
+                ping_result.is_err()
+            } else {
+                true
+            }
+        } {
+            *conn_guard = Some(self.client.get_connection()?);
+        }
+        cmd.query(&mut conn_guard.as_mut().unwrap())
+    }
+
+    // Initialize the client (ping and select DB)
+    fn initialize(&self) -> RedisResult<()> {
+        if self.initialized.load(Ordering::Relaxed) {
+            return Ok(());
+        }
+
+        let mut conn = self.client.get_connection()?;
+
+        // Ping Redis to ensure it works
+        let ping_result: String = redis::cmd("PING").query(&mut conn)?;
+        if ping_result != "PONG" {
+            return Err(RedisError::from((
+                redis::ErrorKind::ResponseError,
+                "Failed to ping Redis server",
+            )));
+        }
+
+        // Select the database
+        let _ = redis::cmd("SELECT").arg(self.db).exec(&mut conn);
+
+        self.initialized.store(true, Ordering::Relaxed);
+
+        // Store the connection
+        let mut conn_guard = self.connection.lock().unwrap();
+        *conn_guard = Some(conn);
+
+        Ok(())
+    }
+}
+
+// Get the Redis client instance
+pub fn get_redis_client() -> RedisResult<Arc<RedisClientWrapper>> {
+    // Check if we already have a client
+    {
+        let guard = REDIS_CLIENT.lock().unwrap();
+        if let Some(ref client) = &*guard {
+            return Ok(Arc::clone(client));
+        }
+    }
+
+    // Create a new client
+    let client = create_redis_client()?;
+
+    // Store the client globally
+    {
+        let mut guard = REDIS_CLIENT.lock().unwrap();
+        *guard = Some(Arc::clone(&client));
+    }
+
+    Ok(client)
+}
+
+// Create a new Redis client
+fn create_redis_client() -> RedisResult<Arc<RedisClientWrapper>> {
+    // Get Redis configuration from environment variables
+    let db = get_redis_db();
+    let password = env::var("REDIS_PASSWORD").ok();
+    let username = env::var("REDIS_USERNAME").ok();
+    let host = env::var("REDIS_HOST").unwrap_or_else(|_| String::from("127.0.0.1"));
+    let port = env::var("REDIS_PORT")
+        .ok()
+        .and_then(|p| p.parse::<u16>().ok())
+        .unwrap_or(6379);
+
+    // Create a builder with environment variables
+    let mut builder = RedisConfigBuilder::new().host(&host).port(port).db(db);
+
+    if let Some(user) = username {
+        builder = builder.username(&user);
+    }
+
+    if let Some(pass) = password {
+        builder = builder.password(&pass);
+    }
+
+    // First try: Connect via Unix socket if it exists
+    let home_dir = env::var("HOME").unwrap_or_else(|_| String::from("/root"));
+    let socket_path = format!("{}/hero/var/myredis.sock", home_dir);
+
+    if Path::new(&socket_path).exists() {
+        // Try to connect via Unix socket
+        let socket_builder = builder.clone().socket_path(&socket_path);
+
+        match socket_builder.build() {
+            Ok((client, db)) => {
+                let wrapper = Arc::new(RedisClientWrapper::new(client, db));
+
+                // Initialize the client
+                if let Err(err) = wrapper.initialize() {
+                    eprintln!(
+                        "Socket exists at {} but connection failed: {}",
+                        socket_path, err
+                    );
+                } else {
+                    return Ok(wrapper);
+                }
+            }
+            Err(err) => {
+                eprintln!(
+                    "Socket exists at {} but connection failed: {}",
+                    socket_path, err
+                );
+            }
+        }
+    }
+
+    // Second try: Connect via TCP
+    match builder.clone().build() {
+        Ok((client, db)) => {
+            let wrapper = Arc::new(RedisClientWrapper::new(client, db));
+
+            // Initialize the client
+            wrapper.initialize()?;
+
+            Ok(wrapper)
+        }
+        Err(err) => Err(RedisError::from((
+            redis::ErrorKind::IoError,
+            "Failed to connect to Redis",
+            format!(
+                "Could not connect via socket at {} or via TCP to {}:{}: {}",
+                socket_path, host, port, err
+            ),
+        ))),
+    }
+}
+
+// Get the Redis DB number from environment variable
+fn get_redis_db() -> i64 {
+    env::var("REDISDB")
+        .ok()
+        .and_then(|db_str| db_str.parse::<i64>().ok())
+        .unwrap_or(0)
+}
+
+// Reload the Redis client
+pub fn reset() -> RedisResult<()> {
+    // Clear the existing client
+    {
+        let mut client_guard = REDIS_CLIENT.lock().unwrap();
+        *client_guard = None;
+    }
+
+    // Create a new client, only return error if it fails
+    // We don't need to return the client itself
+    get_redis_client()?;
+    Ok(())
+}
+
+// Execute a Redis command
+pub fn execute<T>(cmd: &mut Cmd) -> RedisResult<T>
+where
+    T: redis::FromRedisValue,
+{
+    let client = get_redis_client()?;
+    client.execute(cmd)
+}
+
+/// Create a new Redis client with custom configuration
+///
+/// # Arguments
+///
+/// * `config` - The Redis connection configuration builder
+///
+/// # Returns
+///
+/// * `RedisResult<Client>` - The Redis client if successful, error otherwise
+pub fn with_config(config: RedisConfigBuilder) -> RedisResult<Client> {
+    let (client, _) = config.build()?;
+    Ok(client)
+}