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(BaseError::RedisConnectionFailed)?;
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 health_check() -> Result<bool, BaseError> {
Self::client()?
.health_check()
.await
.map_err(BaseError::RedisOperationFailed)
}
pub fn pool_status() -> Result<yang_db::redis::PoolStatus, BaseError> {
Ok(Self::client()?.pool_status())
}
pub async fn close() {
if let Some(client) = GLOBAL_REDIS.get() {
client.close().await;
}
}
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(BaseError::RedisOperationFailed)
} else {
Self::client()?
.set(key_str, value_str)
.await
.map_err(BaseError::RedisOperationFailed)
}
}
pub async fn set_nx_ex(
key: impl Into<String>,
value: impl Into<String>,
ttl: i64,
) -> Result<bool, BaseError> {
Self::client()?
.set_nx_ex(key, value, ttl)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn get(key: impl Into<String>) -> Result<Option<String>, BaseError> {
Self::client()?
.get(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
pub async fn expire(key: impl Into<String>, seconds: i64) -> Result<bool, BaseError> {
Self::client()?
.expire(key, seconds)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn ttl(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.ttl(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn persist(key: impl Into<String>) -> Result<bool, BaseError> {
Self::client()?
.persist(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn keys(pattern: impl Into<String>) -> Result<Vec<String>, BaseError> {
Self::client()?
.keys(pattern)
.await
.map_err(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
pub async fn hget(
key: impl Into<String>,
field: impl Into<String>,
) -> Result<Option<String>, BaseError> {
Self::client()?
.hget(key, field)
.await
.map_err(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
pub async fn hgetall(key: impl Into<String>) -> Result<Vec<(String, String)>, BaseError> {
Self::client()?
.hgetall(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn hexists(
key: impl Into<String>,
field: impl Into<String>,
) -> Result<bool, BaseError> {
Self::client()?
.hexists(key, field)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn hlen(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.hlen(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
pub async fn lpop(key: impl Into<String>) -> Result<Option<String>, BaseError> {
Self::client()?
.lpop(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn rpop(key: impl Into<String>) -> Result<Option<String>, BaseError> {
Self::client()?
.rpop(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn llen(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.llen(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
pub async fn sismember(
key: impl Into<String>,
member: impl Into<String>,
) -> Result<bool, BaseError> {
Self::client()?
.sismember(key, member)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn smembers(key: impl Into<String>) -> Result<Vec<String>, BaseError> {
Self::client()?
.smembers(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn scard(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.scard(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn zadd(key: impl Into<String>, members: &[(f64, String)]) -> Result<i64, BaseError> {
Self::client()?
.zadd(key, members)
.await
.map_err(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
pub async fn zcard(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.zcard(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
pub async fn incr(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.incr(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn decr(key: impl Into<String>) -> Result<i64, BaseError> {
Self::client()?
.decr(key)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn incrby(key: impl Into<String>, increment: i64) -> Result<i64, BaseError> {
Self::client()?
.incrby(key, increment)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn decrby(key: impl Into<String>, decrement: i64) -> Result<i64, BaseError> {
Self::client()?
.decrby(key, decrement)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn incrbyfloat(key: impl Into<String>, increment: f64) -> Result<f64, BaseError> {
Self::client()?
.incrbyfloat(key, increment)
.await
.map_err(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
pub async fn hincrbyfloat(
key: impl Into<String>,
field: impl Into<String>,
increment: f64,
) -> Result<f64, BaseError> {
Self::client()?
.hincrbyfloat(key, field, increment)
.await
.map_err(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
pub async fn mset(pairs: &[(String, String)]) -> Result<(), BaseError> {
Self::client()?
.mset(pairs)
.await
.map_err(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
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(BaseError::RedisOperationFailed)
}
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)));
}
}