feat: Add redisclient package to the monorepo
Some checks are pending
Rhai Tests / Run Rhai Tests (push) Waiting to run
Some checks are pending
Rhai Tests / Run Rhai Tests (push) Waiting to run
- Integrate the redisclient package into the workspace. - Update the MONOREPO_CONVERSION_PLAN.md to reflect the completion of the redisclient package conversion. This includes marking its conversion as complete and updating the success metrics. - Add the redisclient package's Cargo.toml file. - Add the redisclient package's source code files. - Add tests for the redisclient package. - Add README file for the redisclient package.
This commit is contained in:
Mahmoud-Emad
36
redisclient/src/lib.rs
Normal file
36
redisclient/src/lib.rs
Normal file
@@ -0,0 +1,36 @@
|
||||
//! SAL Redis Client
|
||||
//!
|
||||
//! A robust Redis client wrapper for Rust applications that provides connection management,
|
||||
//! automatic reconnection, and a simple interface for executing Redis commands.
|
||||
//!
|
||||
//! ## Features
|
||||
//!
|
||||
//! - **Connection Management**: Automatic connection handling with lazy initialization
|
||||
//! - **Reconnection**: Automatic reconnection on connection failures
|
||||
//! - **Builder Pattern**: Flexible configuration with authentication support
|
||||
//! - **Environment Configuration**: Support for environment variables
|
||||
//! - **Thread Safety**: Safe to use in multi-threaded applications
|
||||
//! - **Rhai Integration**: Scripting support for Redis operations
|
||||
//!
|
||||
//! ## Usage
|
||||
//!
|
||||
//! ```rust
|
||||
//! use sal_redisclient::{execute, get_redis_client};
|
||||
//! use redis::cmd;
|
||||
//!
|
||||
//! // Execute a simple SET command
|
||||
//! let mut set_cmd = redis::cmd("SET");
|
||||
//! set_cmd.arg("my_key").arg("my_value");
|
||||
//! let result: redis::RedisResult<()> = execute(&mut set_cmd);
|
||||
//!
|
||||
//! // Get the Redis client directly
|
||||
//! let client = get_redis_client()?;
|
||||
//! ```
|
||||
|
||||
mod redisclient;
|
||||
|
||||
pub use redisclient::*;
|
||||
|
||||
// Rhai integration module
|
||||
#[cfg(feature = "rhai")]
|
||||
pub mod rhai;
|
||||
361
redisclient/src/redisclient.rs
Normal file
361
redisclient/src/redisclient.rs
Normal file
@@ -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)
|
||||
}
|
||||
323
redisclient/src/rhai.rs
Normal file
323
redisclient/src/rhai.rs
Normal file
@@ -0,0 +1,323 @@
|
||||
//! Rhai wrappers for Redis client module functions
|
||||
//!
|
||||
//! This module provides Rhai wrappers for the functions in the Redis client module.
|
||||
|
||||
use crate::redisclient;
|
||||
use rhai::{Engine, EvalAltResult, Map};
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// Register Redis client module functions with the Rhai engine
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `engine` - The Rhai engine to register the functions with
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<(), Box<EvalAltResult>>` - Ok if registration was successful, Err otherwise
|
||||
pub fn register_redisclient_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
|
||||
// Register basic Redis operations
|
||||
engine.register_fn("redis_ping", redis_ping);
|
||||
engine.register_fn("redis_set", redis_set);
|
||||
engine.register_fn("redis_get", redis_get);
|
||||
engine.register_fn("redis_del", redis_del);
|
||||
|
||||
// Register hash operations
|
||||
engine.register_fn("redis_hset", redis_hset);
|
||||
engine.register_fn("redis_hget", redis_hget);
|
||||
engine.register_fn("redis_hgetall", redis_hgetall);
|
||||
engine.register_fn("redis_hdel", redis_hdel);
|
||||
|
||||
// Register list operations
|
||||
engine.register_fn("redis_rpush", redis_rpush);
|
||||
engine.register_fn("redis_lpush", redis_lpush);
|
||||
engine.register_fn("redis_llen", redis_llen);
|
||||
engine.register_fn("redis_lrange", redis_lrange);
|
||||
|
||||
// Register other operations
|
||||
engine.register_fn("redis_reset", redis_reset);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Ping the Redis server
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<String, Box<EvalAltResult>>` - "PONG" if successful, error otherwise
|
||||
pub fn redis_ping() -> Result<String, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("PING");
|
||||
redisclient::execute(&mut cmd).map_err(|e| {
|
||||
Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
/// Set a key-value pair in Redis
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The key to set
|
||||
/// * `value` - The value to set
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<bool, Box<EvalAltResult>>` - true if successful, error otherwise
|
||||
pub fn redis_set(key: &str, value: &str) -> Result<bool, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("SET");
|
||||
cmd.arg(key).arg(value);
|
||||
let result: redis::RedisResult<String> = redisclient::execute(&mut cmd);
|
||||
match result {
|
||||
Ok(s) if s == "OK" => Ok(true),
|
||||
Ok(_) => Ok(false),
|
||||
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get a value from Redis by key
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The key to get
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<String, Box<EvalAltResult>>` - The value if found, empty string if not found, error otherwise
|
||||
pub fn redis_get(key: &str) -> Result<String, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("GET");
|
||||
cmd.arg(key);
|
||||
let result: redis::RedisResult<Option<String>> = redisclient::execute(&mut cmd);
|
||||
match result {
|
||||
Ok(Some(value)) => Ok(value),
|
||||
Ok(None) => Ok(String::new()),
|
||||
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Delete a key from Redis
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The key to delete
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<bool, Box<EvalAltResult>>` - true if successful, error otherwise
|
||||
pub fn redis_del(key: &str) -> Result<bool, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("DEL");
|
||||
cmd.arg(key);
|
||||
let result: redis::RedisResult<i64> = redisclient::execute(&mut cmd);
|
||||
match result {
|
||||
Ok(n) => Ok(n > 0),
|
||||
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Set a field in a hash
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The hash key
|
||||
/// * `field` - The field to set
|
||||
/// * `value` - The value to set
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<bool, Box<EvalAltResult>>` - true if successful, error otherwise
|
||||
pub fn redis_hset(key: &str, field: &str, value: &str) -> Result<bool, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("HSET");
|
||||
cmd.arg(key).arg(field).arg(value);
|
||||
let result: redis::RedisResult<i64> = redisclient::execute(&mut cmd);
|
||||
match result {
|
||||
Ok(_) => Ok(true),
|
||||
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get a field from a hash
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The hash key
|
||||
/// * `field` - The field to get
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<String, Box<EvalAltResult>>` - The value if found, empty string if not found, error otherwise
|
||||
pub fn redis_hget(key: &str, field: &str) -> Result<String, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("HGET");
|
||||
cmd.arg(key).arg(field);
|
||||
let result: redis::RedisResult<Option<String>> = redisclient::execute(&mut cmd);
|
||||
match result {
|
||||
Ok(Some(value)) => Ok(value),
|
||||
Ok(None) => Ok(String::new()),
|
||||
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get all fields and values from a hash
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The hash key
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<Map, Box<EvalAltResult>>` - A map of field-value pairs, error otherwise
|
||||
pub fn redis_hgetall(key: &str) -> Result<Map, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("HGETALL");
|
||||
cmd.arg(key);
|
||||
let result: redis::RedisResult<HashMap<String, String>> = redisclient::execute(&mut cmd);
|
||||
match result {
|
||||
Ok(hash_map) => {
|
||||
let mut map = Map::new();
|
||||
for (k, v) in hash_map {
|
||||
map.insert(k.into(), v.into());
|
||||
}
|
||||
Ok(map)
|
||||
}
|
||||
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Delete a field from a hash
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The hash key
|
||||
/// * `field` - The field to delete
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<bool, Box<EvalAltResult>>` - true if successful, error otherwise
|
||||
pub fn redis_hdel(key: &str, field: &str) -> Result<bool, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("HDEL");
|
||||
cmd.arg(key).arg(field);
|
||||
let result: redis::RedisResult<i64> = redisclient::execute(&mut cmd);
|
||||
match result {
|
||||
Ok(n) => Ok(n > 0),
|
||||
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Push an element to the end of a list
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The list key
|
||||
/// * `value` - The value to push
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<i64, Box<EvalAltResult>>` - The new length of the list, error otherwise
|
||||
pub fn redis_rpush(key: &str, value: &str) -> Result<i64, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("RPUSH");
|
||||
cmd.arg(key).arg(value);
|
||||
redisclient::execute(&mut cmd).map_err(|e| {
|
||||
Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
/// Push an element to the beginning of a list
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The list key
|
||||
/// * `value` - The value to push
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<i64, Box<EvalAltResult>>` - The new length of the list, error otherwise
|
||||
pub fn redis_lpush(key: &str, value: &str) -> Result<i64, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("LPUSH");
|
||||
cmd.arg(key).arg(value);
|
||||
redisclient::execute(&mut cmd).map_err(|e| {
|
||||
Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
/// Get the length of a list
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The list key
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<i64, Box<EvalAltResult>>` - The length of the list, error otherwise
|
||||
pub fn redis_llen(key: &str) -> Result<i64, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("LLEN");
|
||||
cmd.arg(key);
|
||||
redisclient::execute(&mut cmd).map_err(|e| {
|
||||
Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
/// Get a range of elements from a list
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `key` - The list key
|
||||
/// * `start` - The start index
|
||||
/// * `stop` - The stop index
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<Vec<String>, Box<EvalAltResult>>` - The elements in the range, error otherwise
|
||||
pub fn redis_lrange(key: &str, start: i64, stop: i64) -> Result<Vec<String>, Box<EvalAltResult>> {
|
||||
let mut cmd = redis::cmd("LRANGE");
|
||||
cmd.arg(key).arg(start).arg(stop);
|
||||
redisclient::execute(&mut cmd).map_err(|e| {
|
||||
Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
/// Reset the Redis client connection
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// * `Result<bool, Box<EvalAltResult>>` - true if successful, error otherwise
|
||||
pub fn redis_reset() -> Result<bool, Box<EvalAltResult>> {
|
||||
match redisclient::reset() {
|
||||
Ok(_) => Ok(true),
|
||||
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
|
||||
format!("Redis error: {}", e).into(),
|
||||
rhai::Position::NONE,
|
||||
))),
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user