auto heal(3)

Signed-off-by: mujunxiang <1948535941@qq.com>

ecstore/src/config/common.rs

@@ -15,7 +15,7 @@ use s3s::dto::StreamingBlob;
 use s3s::Body;
 use tracing::error;
 
-const CONFIG_PREFIX: &str = "config";
+pub const CONFIG_PREFIX: &str = "config";
 const CONFIG_FILE: &str = "config.json";
 
 pub const STORAGE_CLASS_SUB_SYS: &str = "storage_class";
@@ -161,32 +161,29 @@ async fn apply_dynamic_config(cfg: &mut Config, api: &ECStore) -> Result<()> {
     Ok(())
 }
 
-async fn apply_dynamic_config_for_sub_sys(cfg: &mut Config, api: &ECStore, subsys: &String) -> Result<()> {
+async fn apply_dynamic_config_for_sub_sys(cfg: &mut Config, api: &ECStore, subsys: &str) -> Result<()> {
     let set_drive_counts = api.set_drive_counts();
-    match subsys.as_str() {
-        STORAGE_CLASS_SUB_SYS => {
-            let kvs = match cfg.get_value(STORAGE_CLASS_SUB_SYS, DEFAULT_KV_KEY) {
-                Some(res) => res,
-                None => KVS::new(),
-            };
+    if subsys == STORAGE_CLASS_SUB_SYS {
+        let kvs = match cfg.get_value(STORAGE_CLASS_SUB_SYS, DEFAULT_KV_KEY) {
+            Some(res) => res,
+            None => KVS::new(),
+        };
 
-            for (i, count) in set_drive_counts.iter().enumerate() {
-                match storageclass::lookup_config(&kvs, *count) {
-                    Ok(res) => {
-                        if i == 0 && GLOBAL_StorageClass.get().is_none() {
-                            if let Err(r) = GLOBAL_StorageClass.set(res) {
-                                error!("GLOBAL_StorageClass.set failed {:?}", r);
-                            }
+        for (i, count) in set_drive_counts.iter().enumerate() {
+            match storageclass::lookup_config(&kvs, *count) {
+                Ok(res) => {
+                    if i == 0 && GLOBAL_StorageClass.get().is_none() {
+                        if let Err(r) = GLOBAL_StorageClass.set(res) {
+                            error!("GLOBAL_StorageClass.set failed {:?}", r);
                         }
                     }
-                    Err(err) => {
-                        error!("init storageclass err:{:?}", &err);
-                        break;
-                    }
+                }
+                Err(err) => {
+                    error!("init storageclass err:{:?}", &err);
+                    break;
                 }
             }
         }
-        _ => {}
     }
 
     Ok(())

ecstore/src/config/heal.rs

@@ -37,9 +37,9 @@ fn parse_bitrot_config(s: &str) -> Result<Duration> {
     match parse_bool(s) {
         Ok(enabled) => {
             if enabled {
-                return Ok(Duration::from_secs_f64(0.0));
+                Ok(Duration::from_secs_f64(0.0))
             } else {
-                return Ok(Duration::from_secs_f64(-1.0));
+                Ok(Duration::from_secs_f64(-1.0))
             }
         }
         Err(_) => {

ecstore/src/config/mod.rs

@@ -1,5 +1,6 @@
 pub mod common;
 pub mod error;
+#[allow(dead_code)]
 pub mod heal;
 pub mod storageclass;
 
@@ -22,6 +23,12 @@ pub static RUSTFS_CONFIG_PREFIX: &str = "config";
 
 pub struct ConfigSys {}
 
+impl Default for ConfigSys {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ConfigSys {
     pub fn new() -> Self {
         Self {}
@@ -47,6 +54,12 @@ pub struct KV {
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct KVS(Vec<KV>);
 
+impl Default for KVS {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl KVS {
     pub fn new() -> Self {
         KVS(Vec::new())
@@ -72,6 +85,12 @@ impl KVS {
 #[derive(Debug, Clone)]
 pub struct Config(HashMap<String, HashMap<String, KVS>>);
 
+impl Default for Config {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Config {
     pub fn new() -> Self {
         let mut cfg = Config(HashMap::new());

ecstore/src/config/storageclass.rs

@@ -228,7 +228,7 @@ pub fn parse_storage_class(env: &str) -> Result<StorageClass> {
 
     // only two elements allowed in the string - "scheme" and "number of parity drives"
     if s.len() != 2 {
-        return Err(Error::msg(&format!(
+        return Err(Error::msg(format!(
             "Invalid storage class format: {}. Expected 'Scheme:Number of parity drives'.",
             env
         )));
@@ -236,13 +236,13 @@ pub fn parse_storage_class(env: &str) -> Result<StorageClass> {
 
     // only allowed scheme is "EC"
     if s[0] != SCHEME_PREFIX {
-        return Err(Error::msg(&format!("Unsupported scheme {}. Supported scheme is EC.", s[0])));
+        return Err(Error::msg(format!("Unsupported scheme {}. Supported scheme is EC.", s[0])));
     }
 
     // Number of parity drives should be integer
     let parity_drives: usize = match s[1].parse() {
         Ok(num) => num,
-        Err(_) => return Err(Error::msg(&format!("Failed to parse parity value: {}.", s[1]))),
+        Err(_) => return Err(Error::msg(format!("Failed to parse parity value: {}.", s[1]))),
     };
 
     Ok(StorageClass { parity: parity_drives })