br_cache/

lib.rs

use std::sync::mpsc::{Sender};
use crate::redis::Redis;
use json::{JsonValue};
use std::sync::RwLock;
use once_cell::sync::Lazy;
pub use crate::config::{CacheMode, Config, Connection};

pub mod config;
mod redis;

static GLOBAL_CONFIG: Lazy<RwLock<Config>> = Lazy::new(|| {
    RwLock::new(Config::default())
});

#[derive(Clone)]
pub enum Cache {
    Redis(Redis),
    None,
}

impl Cache {
    /// 配置文件模式
    pub fn new(config: Config) -> Self {
        {
            let mut data = GLOBAL_CONFIG.write().unwrap();
            data.clone_from(&config);
        }
        let config = GLOBAL_CONFIG.read().unwrap();
        let connection = config.connections.get(config.default.as_str()).unwrap().clone();
        match connection.mode {
            CacheMode::Redis => {
                match Redis::connect(connection) {
                    Ok(e) => Cache::Redis(e),
                    Err(_) => Cache::None
                }
            }
            CacheMode::None => Cache::None
        }
    }

    /// 非配置文件模式
    pub fn create(name: &str, connection: Connection) -> Self {
        {
            let mut data = GLOBAL_CONFIG.write().unwrap();
            if !data.connections.contains_key(name) {
                data.connections.insert(name.to_string(), connection);
            }
            data.default = name.to_string();
        }
        let config = GLOBAL_CONFIG.read().unwrap();
        let connection = config.connections.get(config.default.as_str()).unwrap().clone();
        match connection.mode {
            CacheMode::Redis => {
                match Redis::connect(connection) {
                    Ok(e) => Cache::Redis(e),
                    Err(_) => Cache::None
                }
            }
            CacheMode::None => Cache::None
        }
    }
    /// 获取通道列表
    pub fn connections(&mut self) -> JsonValue {
        let mut connections = vec![];
        let data = GLOBAL_CONFIG.read().unwrap();
        for (item, mut value) in data.connections.clone() {
            if value.mode.str().is_empty() {
                continue;
            }
            let mut t = value.json();
            t["name"] = item.into();
            connections.push(t);
        }
        connections.into()
    }
    /// 切换通道
    pub fn connection(&mut self, name: &str) -> Self {
        let mut data = GLOBAL_CONFIG.write().unwrap();
        if data.connections.contains_key(name) {
            if name == data.default {
                return self.clone();
            }
            data.default = name.to_string();
            let connection = data.connections.get(data.default.as_str()).unwrap().clone();
            match connection.mode {
                CacheMode::Redis => {
                    match Redis::connect(connection) {
                        Ok(e) => Cache::Redis(e),
                        Err(_) => Cache::None
                    }
                }
                CacheMode::None => Cache::None
            }
        } else {
            Cache::None
        }
    }
}


pub trait CacheBase {
    /// 选择数据库
    fn db(&mut self, db: i8) -> &mut Self;

    /// 键 判断是否存在
    fn key_exists(&mut self, key: &str) -> Result<bool, String>;
    /// 键 删除
    fn key_del(&mut self, key: &str) -> Result<bool, String>;
    /// 键 以秒为单位返回 key 的剩余过期时间。
    fn key_ttl(&mut self, key: &str) -> Result<i64, String>;

    /// 键 设置到期时间
    /// * key 键
    /// * timestamp 到期时间戳 10位
    fn key_set_expireat(&mut self, key: &str, timestamp: i64) -> Result<bool, String>;
    /// 键 设置到期时间
    /// * s 过期秒
    fn key_set_seconds(&mut self, key: &str, s: i64) -> Result<bool, String>;
    /// 键 删除到期时间
    fn key_del_expire(&mut self, key: &str) -> Result<bool, String>;
    /// 查询 KEY
    /// * key 键 格式 * 或 *#### 模糊查询
    fn key_query(&mut self, key: &str) -> Result<JsonValue, String>;

    /// 设置缓存
    ///
    /// * expiration_date 过期时间 s 秒
    fn add(&mut self, key: &str, value: JsonValue, expiration_date: u64) -> Result<bool, String>;
    /// 获取缓存
    fn get(&mut self, key: &str) -> Result<JsonValue, String>;

    /// 集合 添加
    fn set_add(&mut self, key: &str, value: JsonValue, expiry_s: i64) -> Result<bool, String>;
    /// 集合 获取成员数量
    fn set_count(&mut self, key: &str) -> Result<usize, String>;
    /// 集合 获取
    fn set_get(&mut self, key: &str) -> Result<JsonValue, String>;
    /// 集合 删除
    fn set_delete(&mut self, key: &str, value: JsonValue) -> Result<bool, String>;
    /// 集合 获取交集
    fn set_get_sinter(&mut self, keys: Vec<&str>) -> Result<JsonValue, String>;
    /// 集合 获取并集
    fn set_get_sunion(&mut self, keys: Vec<&str>) -> Result<JsonValue, String>;

    /// 列表 添加
    fn list_add(&mut self, key: &str, value: JsonValue, expiry_s: i64) -> Result<bool, String>;
    /// 列表 删除元素
    fn list_del(&mut self, key: &str, value: JsonValue) -> Result<bool, String>;
    /// 从列表左侧添加元素
    fn list_lpush(&mut self, key: &str, value: JsonValue, expiry_s: i64) -> Result<bool, String>;
    /// 从列表右侧添加元素
    fn list_rpush(&mut self, key: &str, value: JsonValue, expiry_s: i64) -> Result<bool, String>;
    /// 从列表左侧弹出元素
    /// count: 0 = 弹出1个（兼容旧版），>0 = 弹出指定数量
    fn list_lpop(&mut self, key: &str, count: usize) -> Result<Vec<JsonValue>, String>;
    /// 从列表右侧弹出元素
    fn list_rpop(&mut self, key: &str, count: usize) -> Result<Vec<JsonValue>, String>;
    /// 获取列表长度
    fn list_len(&mut self, key: &str) -> Result<usize, String>;
    /// 获取列表指定范围的元素
    fn list_range(&mut self, key: &str, start: isize, stop: isize) -> Result<Vec<JsonValue>, String>;
    /// 获取列表所有元素
    fn list_all(&mut self, key: &str) -> Result<Vec<JsonValue>, String>;
    /// 根据索引获取列表元素
    fn list_get(&mut self, key: &str, index: isize) -> Result<JsonValue, String>;
    /// 修剪列表，只保留指定范围内的元素
    fn list_trim(&mut self, key: &str, start: isize, stop: isize) -> Result<bool, String>;
    /// 设置指定索引位置的元素值
    fn list_set(&mut self, key: &str, index: isize, value: JsonValue) -> Result<bool, String>;
    /// 删除列表中指定值的元素（count=0表示删除所有匹配项）
    fn list_remove(&mut self, key: &str, value: JsonValue, count: isize) -> Result<isize, String>;
    /// 获取哈希值
    fn hash_get(&mut self, key: &str) -> Result<JsonValue, String>;
    /// 添加哈希
    fn hash_add(&mut self, key: &str, field: &str, value: JsonValue) -> Result<bool, String>;
    /// 获取哈希指定key的字段值
    fn hash_get_field_value(&mut self, key: &str, field: &str) -> Result<JsonValue, String>;
    /// 获取key下所有的field
    fn hash_get_fields(&mut self, key: &str) -> Result<JsonValue, String>;
    /// 删除哈希指定key的字段
    fn hash_delete(&mut self, key: &str, field: &str) -> Result<bool, String>;
    /// 获取key下所有的value
    fn hash_get_values(&mut self, key: &str) -> Result<JsonValue, String>;
    /// 地理 添加地理位置
    fn geo_add(&mut self, key: &str, longitude: f64, latitude: f64, value: JsonValue) -> Result<bool, String>;
    /// 地理 获取地理位置
    fn geo_get(&mut self, key: &str, value: JsonValue) -> Result<JsonValue, String>;
    /// 地理 获取两地之间的距离地理位置
    fn geo_dist(&mut self, key: &str, value1: JsonValue, value2: JsonValue) -> Result<JsonValue, String>;
    /// 地理 以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素
    fn geo_radius(&mut self, key: &str, value: JsonValue, radius: &str) -> Result<JsonValue, String>;

    /// 设置消息队列
    fn stream_add(&mut self, key: &str, msg_id: &str, field: &str, value: JsonValue) -> Result<String, String>;
    /// 获取消息长度
    fn stream_count(&mut self, key: &str) -> Result<usize, String>;
    /// 获取 过滤已删除的消息队列
    fn stream_get(&mut self, key: &str) -> Result<JsonValue, String>;
    /// 删除消息
    fn stream_del(&mut self, key: &str, id: &str) -> Result<bool, String>;

    /// 创建消费者组
    fn stream_group_create(&mut self, key: &str, group: &str) -> Result<bool, String>;
    fn stream_group_add_user(&mut self, key: &str, group: &str, user: &str) -> Result<bool, String>;
    fn stream_group_del_user(&mut self, key: &str, group: &str, user: &str) -> Result<bool, String>;
    /// 删除 消费者
    fn stream_group_del(&mut self, key: &str, group: &str) -> Result<bool, String>;
    /// 删除 消费者
    fn stream_group_msg(&mut self, key: &str, group: &str, user: &str) -> Result<JsonValue, String>;
    /// 获取组存在不
    fn stream_get_group(&mut self, key: &str, group: &str) -> Result<bool, String>;

    fn stream_get_stream(&mut self, key: &str) -> Result<JsonValue, String>;

    /// 订阅消息
    fn subscribe(&mut self, key: &str, tx: Sender<JsonValue>) -> Result<(), String>;
    /// 发布消息
    fn publish(&mut self, key: &str, value: JsonValue) -> Result<bool, String>;
}

impl Cache {
    pub fn db(&mut self, db: i8) -> &mut Self {
        match self {
            Cache::Redis(e) => {
                e.db(db);
            }
            Cache::None => {}
        }
        self
    }

    pub fn key_exists(&mut self, key: &str) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.key_exists(key)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn key_del(&mut self, key: &str) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.key_del(key)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn key_ttl(&mut self, key: &str) -> Result<i64, String> {
        Ok(match self {
            Cache::Redis(e) => e.key_ttl(key)?,
            Cache::None => return Err("error".to_string()),
        })
    }


    pub fn key_set_expireat(&mut self, key: &str, timestamp: i64) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.key_set_expireat(key, timestamp)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn key_set_seconds(&mut self, key: &str, s: i64) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.key_set_seconds(key, s)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn key_del_expire(&mut self, key: &str) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.key_del_expire(key)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn key_query(&mut self, key: &str) -> Result<JsonValue, String> {
        let res = match self {
            Cache::Redis(e) => e.key_query(key)?,
            Cache::None => return Err("error".to_string()),
        };
        Ok(res)
    }
    pub fn add(&mut self, key: &str, value: JsonValue, expiration_date: u64) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.add(key, value, expiration_date)?,
            Cache::None => return Err("error".to_string()),
        })
    }
    pub fn get(&mut self, key: &str) -> Result<JsonValue, String> {
        let res = match self {
            Cache::Redis(e) => e.get(key)?,
            Cache::None => return Err("error".to_string()),
        };
        Ok(res)
    }


    pub fn set_add(&mut self, key: &str, value: JsonValue, expiry_s: i64) -> Result<bool, String> {
        let res = match self {
            Cache::Redis(e) => e.set_add(key, value, expiry_s)?,
            Cache::None => return Err("error".to_string()),
        };
        Ok(res)
    }
    pub fn set_count(&mut self, key: &str) -> Result<usize, String> {
        let res = match self {
            Cache::Redis(e) => e.set_count(key)?,
            Cache::None => return Err("error".to_string()),
        };
        Ok(res)
    }
    pub fn set_get(&mut self, key: &str) -> Result<JsonValue, String> {
        let res = match self {
            Cache::Redis(e) => e.set_get(key)?,
            Cache::None => return Err("error".to_string()),
        };
        Ok(res)
    }

    pub fn set_delete(&mut self, key: &str, value: JsonValue) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.set_delete(key, value)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn set_get_sinter(&mut self, keys: Vec<&str>) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.set_get_sinter(keys)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn set_get_sunion(&mut self, keys: Vec<&str>) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.set_get_sunion(keys)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn list_add(&mut self, key: &str, value: JsonValue, expiry_s: i64) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_add(key, value, expiry_s)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn list_del(&mut self, key: &str, value: JsonValue) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_del(key, value)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    /// 从列表左侧添加元素
    pub fn list_lpush(&mut self, key: &str, value: JsonValue, expiry_s: i64) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_lpush(key, value, expiry_s)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }

    /// 从列表右侧添加元素
    pub fn list_rpush(&mut self, key: &str, value: JsonValue, expiry_s: i64) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_rpush(key, value, expiry_s)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }

    /// 从列表左侧弹出多个元素
    pub fn list_lpop(&mut self, key: &str, count: usize) -> Result<Vec<JsonValue>, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_lpop(key, count)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }

    /// 从列表右侧弹出多个元素
    pub fn list_rpop(&mut self, key: &str, count: usize) -> Result<Vec<JsonValue>, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_rpop(key, count)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }

    /// 获取列表长度
    pub fn list_len(&mut self, key: &str) -> Result<usize, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_len(key)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }

    /// 获取列表指定范围的元素
    pub fn list_range(&mut self, key: &str, start: isize, stop: isize) -> Result<Vec<JsonValue>, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_range(key, start, stop)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }

    /// 获取列表所有元素
    pub fn list_all(&mut self, key: &str) -> Result<Vec<JsonValue>, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_all(key)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }

    /// 根据索引获取列表元素（返回JsonValue）
    pub fn list_get(&mut self, key: &str, index: isize) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_get(key, index)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }

    /// 修剪列表，只保留指定范围内的元素
    pub fn list_trim(&mut self, key: &str, start: isize, stop: isize) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_trim(key, start, stop)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }

    /// 设置指定索引位置的元素值
    pub fn list_set(&mut self, key: &str, index: isize, value: JsonValue) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_set(key, index, value)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }

    /// 删除列表中指定值的元素
    pub fn list_remove(&mut self, key: &str, value: JsonValue, count: isize) -> Result<isize, String> {
        Ok(match self {
            Cache::Redis(e) => e.list_remove(key, value, count)?,
            Cache::None => return Err("Redis连接未初始化".to_string()),
        })
    }


    /// 哈希 获取
    pub fn hash_get(&mut self, key: &str) -> Result<JsonValue, String> {
        let res = match self {
            Cache::Redis(e) => e.hash_get(key)?,
            Cache::None => return Err("error".to_string()),
        };
        Ok(res)
    }
    /// 哈希 添加
    pub fn hash_add(&mut self, key: &str, field: &str, value: JsonValue) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.hash_add(key, field, value)?,
            Cache::None => return Err("error".to_string()),
        })
    }
    /// 哈希-获取指定字段的值
    pub fn hash_get_field_value(&mut self, key: &str, field: &str) -> Result<JsonValue, String> {
        let res = match self {
            Cache::Redis(e) => e.hash_get_field_value(key, field)?,
            Cache::None => return Err("error".to_string()),
        };
        Ok(res)
    }
    /// 哈希-获取所有字段
    pub fn hash_get_fields(&mut self, key: &str) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.hash_get_fields(key)?,
            Cache::None => return Err("error".to_string()),
        })
    }
    pub fn hash_delete(&mut self, key: &str, field: &str) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.hash_delete(key, field)?,
            Cache::None => return Err("error".to_string()),
        })
    }
    /// 哈希-获取所有值
    pub fn hash_get_values(&mut self, key: &str) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.hash_get_values(key)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn geo_add(&mut self, key: &str, longitude: f64, latitude: f64, value: JsonValue) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.geo_add(key, longitude, latitude, value)?,
            Cache::None => return Err("error".to_string()),
        })
    }


    pub fn geo_get(&mut self, key: &str, value: JsonValue) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.geo_get(key, value)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn geo_dist(&mut self, key: &str, value1: JsonValue, value2: JsonValue) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.geo_dist(key, value1, value2)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn geo_radius(&mut self, key: &str, value: JsonValue, radius: &str) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.geo_radius(key, value, radius)?,
            Cache::None => return Err("error".to_string()),
        })
    }
    pub fn stream_add(&mut self, key: &str, msg_id: &str, field: &str, value: JsonValue) -> Result<String, String> {
        match self {
            Cache::Redis(e) => e.stream_add(key, msg_id, field, value),
            Cache::None => Err("error".to_string()),
        }
    }
    pub fn stream_count(&mut self, key: &str) -> Result<usize, String> {
        Ok(match self {
            Cache::Redis(e) => e.stream_count(key)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn stream_get(&mut self, key: &str) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.stream_get(key)?,
            Cache::None => return Err("error".to_string()),
        })
    }


    pub fn stream_del(&mut self, key: &str, id: &str) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.stream_del(key, id)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn stream_group_create(&mut self, key: &str, group: &str) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.stream_group_create(key, group)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn stream_group_add_user(&mut self, key: &str, group: &str, user: &str) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.stream_group_add_user(key, group, user)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn stream_group_del_user(&mut self, key: &str, group: &str, user: &str) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.stream_group_del_user(key, group, user)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn stream_group_del(&mut self, key: &str, group: &str) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.stream_group_del(key, group)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn stream_group_msg(&mut self, key: &str, group: &str, user: &str) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.stream_group_msg(key, group, user)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn stream_get_group(&mut self, key: &str, group: &str) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.stream_get_group(key, group)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn stream_get_stream(&mut self, key: &str) -> Result<JsonValue, String> {
        Ok(match self {
            Cache::Redis(e) => e.stream_get_stream(key)?,
            Cache::None => return Err("error".to_string()),
        })
    }

    pub fn subscribe(&mut self, key: &str, tx: Sender<JsonValue>) -> Result<(), String> {
        let _: () = match self {
            Cache::Redis(e) => e.subscribe(key, tx)?,
            Cache::None => return Err("error".to_string()),
        };
        Ok(())
    }
    pub fn publish(&mut self, key: &str, value: JsonValue) -> Result<bool, String> {
        Ok(match self {
            Cache::Redis(e) => e.publish(key, value)?,
            Cache::None => return Err("error".to_string()),
        })
    }
}