mycommon-utils 0.1.2

use std::sync::{Arc, OnceLock};
use std::time::Duration;
use r2d2::Pool;
use redis::Client;
use sea_orm::{ConnectOptions, Database, DatabaseConnection};
use serde::{Deserialize, Serialize};
use crate::log::log;
use crate::log::log::LogConfig;

// 数据库连接池全局变量
pub static DATABASE: OnceLock<Arc<DatabaseConnection>> = OnceLock::new();

pub static REDIS_POOL : OnceLock<Pool<Client>> = OnceLock::new();

#[derive(Deserialize, Serialize, Debug)]
pub struct DatasourceConfig {
    pub url: String,
    //数据库线程池最大连接数（默认10）
    pub max_connections:u32,
    //数据库线程池最小连接数 （默认1）
    pub min_connections:u32,
    //数据库连接超时时间，单位秒 （默认10秒）
    pub  connect_timeout: u64,
    //数据库连接最大空闲时间，单位秒 (默认1小时)
    pub idle_timeout: u64,
    //数据库连接最大存活时间，单位秒 (默认8小时)
    pub max_lifetime: u64,
}

#[derive(Deserialize, Serialize, Debug)]
pub struct RedisConfig {
    pub url: String,
    pub max_size: u32,
    pub min_idle: u32,
}


/// 初始化redis连接
pub fn redis_conn(config: &RedisConfig) {
    let client = Client::open(config.url.as_str()).expect("连接REDIS服务失败");
    let pool= Pool::builder()
        .max_size(config.max_size)
        .min_idle(match config.min_idle
        { 0 => None,
            _ => Some(config.min_idle)
        }).build(client).expect("创建redis连接池失败");
    REDIS_POOL.get_or_init( move || pool);
}

pub async fn db_conn(db: &DatasourceConfig, log: &LogConfig) {
    // 初始化数据库连接
    let mut opt = ConnectOptions::new(db.url.clone());
    opt.max_connections(db.max_connections)
        .min_connections(db.min_connections)
        .connect_timeout(Duration::from_secs(db.connect_timeout))
        .idle_timeout(Duration::from_secs(db.idle_timeout))
        .max_lifetime(Duration::from_secs(db.max_lifetime))
        .sqlx_logging(log.debug)
        .sqlx_logging_level(log::log_orm_level(log.level.as_str()));
    // 创建数据库连接池
    let db_connect: DatabaseConnection = Database::connect(opt).await.expect("Failed to connect to the database");
    // 设置数据库全部变量
    DATABASE.set(Arc::new(db_connect)).expect("设置数据库连接全局变量失败");
}