use crate::error::BaseError;
use std::sync::OnceLock;
use yang_db::redis::{RedisClient, RedisConfig, RedisTransaction};
static GLOBAL_REDIS: OnceLock<RedisClient> = OnceLock::new();
pub struct GlobalRedis;
impl GlobalRedis {
pub async fn init(url: &str, config: RedisConfig) -> Result<(), BaseError> {
let client = RedisClient::connect_with_config(url, config)
.await
.map_err(|e| BaseError::RedisConnectionFailed(e.to_string()))?;
GLOBAL_REDIS
.set(client)
.map_err(|_| BaseError::RedisAlreadyInitialized)?;
log::info!("全局 Redis 已初始化");
Ok(())
}
pub fn client() -> Result<&'static RedisClient, BaseError> {
GLOBAL_REDIS.get().ok_or(BaseError::RedisNotInitialized)
}
pub async fn set(
key: impl Into<String>,
value: impl Into<String>,
expire_seconds: Option<i64>,
) -> Result<(), BaseError> {
let key_str = key.into();
let value_str = value.into();
if let Some(seconds) = expire_seconds {
Self::client()?
.setex(key_str, seconds, value_str)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
} else {
Self::client()?
.set(key_str, value_str)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
}
pub async fn get(key: impl Into<String>) -> Result<Option<String>, BaseError> {
Self::client()?
.get(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn del(keys: &[impl AsRef<str>]) -> Result<i64, BaseError> {
let keys_vec: Vec<String> = keys.iter().map(|k| k.as_ref().to_string()).collect();
Self::client()?
.del(&keys_vec)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn exists(keys: &[impl AsRef<str>]) -> Result<i64, BaseError> {
let keys_vec: Vec<String> = keys.iter().map(|k| k.as_ref().to_string()).collect();
Self::client()?
.exists(&keys_vec)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn expire(key: impl Into<String>, seconds: i64) -> Result<bool, BaseError> {
Self::client()?
.expire(key, seconds)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn ttl(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.ttl(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn persist(key: impl Into<String>) -> Result<bool, BaseError> {
Self::client()?
.persist(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn keys(pattern: impl Into<String>) -> Result<Vec<String>, BaseError> {
Self::client()?
.keys(pattern)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn hset(
key: impl Into<String>,
field: impl Into<String>,
value: impl Into<String>,
) -> Result<bool, BaseError> {
Self::client()?
.hset(key, field, value)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn hget(
key: impl Into<String>,
field: impl Into<String>,
) -> Result<Option<String>, BaseError> {
Self::client()?
.hget(key, field)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn hdel(key: impl Into<String>, fields: &[impl AsRef<str>]) -> Result<i64, BaseError> {
let fields_vec: Vec<String> = fields.iter().map(|f| f.as_ref().to_string()).collect();
Self::client()?
.hdel(key, &fields_vec)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn hgetall(key: impl Into<String>) -> Result<Vec<(String, String)>, BaseError> {
Self::client()?
.hgetall(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn hexists(
key: impl Into<String>,
field: impl Into<String>,
) -> Result<bool, BaseError> {
Self::client()?
.hexists(key, field)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn hlen(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.hlen(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn lpush(key: impl Into<String>, values: &[impl AsRef<str>]) -> Result<i64, BaseError> {
let values_vec: Vec<String> = values.iter().map(|v| v.as_ref().to_string()).collect();
Self::client()?
.lpush(key, &values_vec)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn rpush(key: impl Into<String>, values: &[impl AsRef<str>]) -> Result<i64, BaseError> {
let values_vec: Vec<String> = values.iter().map(|v| v.as_ref().to_string()).collect();
Self::client()?
.rpush(key, &values_vec)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn lpop(key: impl Into<String>) -> Result<Option<String>, BaseError> {
Self::client()?
.lpop(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn rpop(key: impl Into<String>) -> Result<Option<String>, BaseError> {
Self::client()?
.rpop(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn llen(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.llen(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn lrange(
key: impl Into<String>,
start: i64,
stop: i64,
) -> Result<Vec<String>, BaseError> {
Self::client()?
.lrange(key, start, stop)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn sadd(key: impl Into<String>, members: &[impl AsRef<str>]) -> Result<i64, BaseError> {
let members_vec: Vec<String> = members.iter().map(|m| m.as_ref().to_string()).collect();
Self::client()?
.sadd(key, &members_vec)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn srem(key: impl Into<String>, members: &[impl AsRef<str>]) -> Result<i64, BaseError> {
let members_vec: Vec<String> = members.iter().map(|m| m.as_ref().to_string()).collect();
Self::client()?
.srem(key, &members_vec)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn sismember(
key: impl Into<String>,
member: impl Into<String>,
) -> Result<bool, BaseError> {
Self::client()?
.sismember(key, member)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn smembers(key: impl Into<String>) -> Result<Vec<String>, BaseError> {
Self::client()?
.smembers(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn scard(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.scard(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn zadd(key: impl Into<String>, members: &[(f64, String)]) -> Result<i64, BaseError> {
Self::client()?
.zadd(key, members)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn zrem(key: impl Into<String>, members: &[impl AsRef<str>]) -> Result<i64, BaseError> {
let members_vec: Vec<String> = members.iter().map(|m| m.as_ref().to_string()).collect();
Self::client()?
.zrem(key, &members_vec)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn zcard(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.zcard(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn zrange(
key: impl Into<String>,
start: i64,
stop: i64,
) -> Result<Vec<String>, BaseError> {
Self::client()?
.zrange(key, start, stop)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn incr(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.incr(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn decr(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.decr(key)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn incrby(key: impl Into<String>, increment: i64) -> Result<i64, BaseError> {
Self::client()?
.incrby(key, increment)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn hincrby(
key: impl Into<String>,
field: impl Into<String>,
increment: i64,
) -> Result<i64, BaseError> {
Self::client()?
.hincrby(key, field, increment)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn mget(keys: &[impl AsRef<str>]) -> Result<Vec<Option<String>>, BaseError> {
let keys_vec: Vec<String> = keys.iter().map(|k| k.as_ref().to_string()).collect();
Self::client()?
.mget(&keys_vec)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn mset(pairs: &[(String, String)]) -> Result<(), BaseError> {
Self::client()?
.mset(pairs)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn zrange_with_scores(
key: impl Into<String>,
start: i64,
stop: i64,
) -> Result<Vec<(String, f64)>, BaseError> {
Self::client()?
.zrange_with_scores(key, start, stop)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn zrevrange(
key: impl Into<String>,
start: i64,
stop: i64,
) -> Result<Vec<String>, BaseError> {
Self::client()?
.zrevrange(key, start, stop)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub async fn zincrby(
key: impl Into<String>,
increment: f64,
member: impl Into<String>,
) -> Result<f64, BaseError> {
Self::client()?
.zincrby(key, increment, member)
.await
.map_err(|e| BaseError::RedisOperationFailed(e.to_string()))
}
pub fn transaction() -> Result<RedisTransaction, BaseError> {
Ok(Self::client()?.transaction())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_redis_not_initialized() {
let result = GlobalRedis::client();
assert!(result.is_err());
assert!(matches!(result, Err(BaseError::RedisNotInitialized)));
}
#[test]
fn test_transaction_not_initialized() {
let result = GlobalRedis::transaction();
assert!(result.is_err());
assert!(matches!(result, Err(BaseError::RedisNotInitialized)));
}
}