ruwebframe 0.1.3

a simple webframe for rust actix-web, based on rudi and rbatis.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::rubase::{BaseEntitySingle, rudto, ruentity, BaseEntity, rutils};

use crate::rubase::ruconst::ruconst;
use crate::rubase::rudto::cfgdto;

use crate::rucfg;
use crate::rulog::rulog;
use serde::Deserialize;
use spicex::Spice;
use std::fs::File;
use std::io::{BufRead, BufReader, Read};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
use crate::rubase::getself::GetSelf;
use crate::rubase::rudto::cfgdto::CfgDto; 
pub fn ifDev() -> bool {
    findEnv() == "dev"
}
pub fn ifTest() -> bool {
    findEnv() == "test"
}
pub fn ifMaster() -> bool {
    findEnv() == "prod" || findEnv() == "master"
}

pub fn ifNotMaster() -> bool {
    !ifMaster()
}

pub fn findEnv() -> String {
    rucfg::find_bean_ruconfig().unwrap().readEnv()
}

#[derive(Debug, serde::Serialize, Deserialize)]
pub struct RuConfig {
    parsed: AtomicBool,
    pub config: Arc<Mutex<CfgDto>>,
}
impl  BaseEntity for RuConfig {}
impl RuConfig {
    pub fn new() -> Self {
        let rucfg = Self {
            parsed: AtomicBool::new(false),
            config: Arc::new(Mutex::new(cfgdto::CfgDto::default())),
        };
        rucfg.parse_config();
        rucfg
    }
    pub fn get_config(&self,file:String )-> String {
        let mut  cfgdir=rutils::find_base_path();
        cfgdir.push_str("/config/");
        cfgdir.push_str( file.as_str()) ;
        cfgdir
    }
    pub fn parse_config(&self) {

        let envFile =self.get_config(self.parse_env2file());
        let file = File::open(&envFile);
        rulog::info2("f:", envFile.as_str());
        let mut read = BufReader::new(file.unwrap());
        let mut yaml_str = String::new();
        read.read_to_string(&mut yaml_str).unwrap();
        println!("yaml_str:{:#?}", yaml_str);
        let ret = serde_yaml::from_str::<cfgdto::cfgdto::CfgDto>(&yaml_str);

        // ✅ 显式指定类型
        println!("ret:{:#?}", ret);
        if let Ok(config) = ret {
            let mut guard = self.config.lock().unwrap(); // 获取写锁
            *guard = config;
            guard.parse_env_var();
        } else {
            rulog::error("parse config failed");
        }
        self.parsed.store(true, Ordering::Relaxed);
    }
    pub fn read(&self) -> cfgdto::CfgDto {
        self.readCfg().clone()
    }
    pub fn readCfg(&self) -> MutexGuard<'_, cfgdto::CfgDto> {
        self.config.lock().unwrap()
    }
    pub fn readEnv(&self) ->  String {
         self.get_self().software.env
    }

    pub fn parse_env2file(&self) -> String {
        let env_file = self.parse_env();

        let filename =  String::from(   "/ichub-" ) + &rucfg::parsecfg::parse_env_var(env_file) + ".yml";
        rulog::info2("filename:", filename.as_str());

        return filename;
    }
    pub fn parse_env(&self) -> String {
        let mut spice = Spice::new();
        spice.set_config_file(rutils::find_base_path()+ruconst::FILE_PATH_ENV).unwrap();
        let env = spice.get_string("Env").unwrap();

        return env.unwrap();
    }
    pub fn read2json(&self) -> String {
        self.read().to_json()
    }
    pub fn get_self(&self) ->  cfgdto::CfgDto {
        self.readCfg().get_self()
    }

}