fix #110 #112 add ServerInfoHandler need test

ecstore/src/heal/data_usage.rs

@@ -1,14 +1,20 @@
-use std::{collections::HashMap, time::SystemTime};
-
 use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
+use std::{collections::HashMap, sync::Arc, time::SystemTime};
 use tokio::sync::mpsc::Receiver;
-use tracing::error;
+use tracing::{error, warn};
 
 use crate::{
-    config::common::save_config,
+    bucket::metadata_sys::get_replication_config,
+    config::{
+        common::{read_config, save_config},
+        error::is_err_config_not_found,
+    },
     disk::{BUCKET_META_PREFIX, RUSTFS_META_BUCKET},
+    error::Result,
     new_object_layer_fn,
+    store::ECStore,
+    store_err::to_object_err,
     utils::path::SLASH_SEPARATOR,
 };
 
@@ -133,3 +139,72 @@ pub async fn store_data_usage_in_backend(mut rx: Receiver<DataUsageInfo>) {
         }
     }
 }
+
+// TODO: cancel ctx
+pub async fn load_data_usage_from_backend(store: Arc<ECStore>) -> Result<DataUsageInfo> {
+    let buf = match read_config(store, &DATA_USAGE_OBJ_NAME_PATH).await {
+        Ok(data) => data,
+        Err(e) => {
+            error!("Failed to read data usage info from backend: {}", e);
+            if is_err_config_not_found(&e) {
+                return Ok(DataUsageInfo::default());
+            }
+
+            return Err(to_object_err(e, vec![RUSTFS_META_BUCKET, &DATA_USAGE_OBJ_NAME_PATH]));
+        }
+    };
+
+    let mut data_usage_info: DataUsageInfo = serde_json::from_slice(&buf)?;
+
+    warn!("Loaded data usage info from backend {:?}", &data_usage_info);
+
+    if data_usage_info.buckets_usage.is_empty() {
+        data_usage_info.buckets_usage = data_usage_info
+            .bucket_sizes
+            .iter()
+            .map(|(bucket, &size)| {
+                (
+                    bucket.clone(),
+                    BucketUsageInfo {
+                        size,
+                        ..Default::default()
+                    },
+                )
+            })
+            .collect();
+    }
+
+    if data_usage_info.bucket_sizes.is_empty() {
+        data_usage_info.bucket_sizes = data_usage_info
+            .buckets_usage
+            .iter()
+            .map(|(bucket, bui)| (bucket.clone(), bui.size))
+            .collect();
+    }
+
+    for (bucket, bui) in &data_usage_info.buckets_usage {
+        if bui.replicated_size_v1 > 0
+            || bui.replication_failed_count_v1 > 0
+            || bui.replication_failed_size_v1 > 0
+            || bui.replication_pending_count_v1 > 0
+        {
+            if let Ok((cfg, _)) = get_replication_config(bucket).await {
+                if !cfg.role.is_empty() {
+                    data_usage_info.replication_info.insert(
+                        cfg.role.clone(),
+                        BucketTargetUsageInfo {
+                            replication_failed_size: bui.replication_failed_size_v1,
+                            replication_failed_count: bui.replication_failed_count_v1,
+                            replicated_size: bui.replicated_size_v1,
+                            replication_pending_count: bui.replication_pending_count_v1,
+                            replication_pending_size: bui.replication_pending_size_v1,
+                            ..Default::default()
+                        },
+                    );
+                }
+            }
+        }
+    }
+
+    Ok(data_usage_info)
+}

ecstore/src/heal/data_usage_cache.rs

@@ -18,6 +18,7 @@ use std::path::Path;
 use std::time::{Duration, SystemTime};
 use tokio::sync::mpsc::Sender;
 use tokio::time::sleep;
+use tracing::warn;
 
 use super::data_scanner::{SizeSummary, DATA_SCANNER_FORCE_COMPACT_AT_FOLDERS};
 use super::data_usage::{BucketTargetUsageInfo, BucketUsageInfo, DataUsageInfo, DATA_USAGE_ROOT};
@@ -379,6 +380,7 @@ impl DataUsageCache {
         let mut retries = 0;
         while retries < 5 {
             let path = Path::new(BUCKET_META_PREFIX).join(name);
+            warn!("Loading data usage cache from backend: {}", path.display());
             match store
                 .get_object_reader(
                     RUSTFS_META_BUCKET,
@@ -398,37 +400,42 @@ impl DataUsageCache {
                     }
                     break;
                 }
-                Err(err) => match err.downcast_ref::<DiskError>() {
-                    Some(DiskError::FileNotFound) | Some(DiskError::VolumeNotFound) => {
-                        match store
-                            .get_object_reader(
-                                RUSTFS_META_BUCKET,
-                                name,
-                                None,
-                                HeaderMap::new(),
-                                &ObjectOptions {
-                                    no_lock: true,
-                                    ..Default::default()
-                                },
-                            )
-                            .await
-                        {
-                            Ok(mut reader) => {
-                                if let Ok(info) = Self::unmarshal(&reader.read_all().await?) {
-                                    d = info
-                                }
-                                break;
-                            }
-                            Err(_) => match err.downcast_ref::<DiskError>() {
-                                Some(DiskError::FileNotFound) | Some(DiskError::VolumeNotFound) => {
+                Err(err) => {
+                    warn!("Failed to load data usage cache from backend: {}", &err);
+                    match err.downcast_ref::<DiskError>() {
+                        Some(DiskError::FileNotFound) | Some(DiskError::VolumeNotFound) => {
+                            match store
+                                .get_object_reader(
+                                    RUSTFS_META_BUCKET,
+                                    name,
+                                    None,
+                                    HeaderMap::new(),
+                                    &ObjectOptions {
+                                        no_lock: true,
+                                        ..Default::default()
+                                    },
+                                )
+                                .await
+                            {
+                                Ok(mut reader) => {
+                                    if let Ok(info) = Self::unmarshal(&reader.read_all().await?) {
+                                        d = info
+                                    }
                                     break;
                                 }
-                                _ => {}
-                            },
+                                Err(_) => match err.downcast_ref::<DiskError>() {
+                                    Some(DiskError::FileNotFound) | Some(DiskError::VolumeNotFound) => {
+                                        break;
+                                    }
+                                    _ => {}
+                                },
+                            }
+                        }
+                        _ => {
+                            break;
                         }
                     }
-                    _ => {}
-                },
+                }
             }
             retries += 1;
             let dur = {
@@ -446,11 +453,14 @@ impl DataUsageCache {
         let buf_clone = buf.clone();
 
         let store_clone = store.clone();
-        let name_clone = name.to_string();
+
+        let name = Path::new(BUCKET_META_PREFIX).join(name).to_string_lossy().to_string();
+
+        let name_clone = name.clone();
         tokio::spawn(async move {
             let _ = save_config(store_clone, &format!("{}{}", &name_clone, ".bkp"), &buf_clone).await;
         });
-        save_config(store, name, &buf).await
+        save_config(store, &name, &buf).await
     }
 
     pub fn replace(&mut self, path: &str, parent: &str, e: DataUsageEntry) {