add Error test, fix clippy

ecstore/src/heal/background_heal_ops.rs

@@ -4,8 +4,8 @@ use std::{cmp::Ordering, env, path::PathBuf, sync::Arc, time::Duration};
 use tokio::{
     spawn,
     sync::{
-        mpsc::{self, Receiver, Sender},
         RwLock,
+        mpsc::{self, Receiver, Sender},
     },
     time::interval,
 };
@@ -14,16 +14,16 @@ use uuid::Uuid;
 
 use super::{
     heal_commands::HealOpts,
-    heal_ops::{new_bg_heal_sequence, HealSequence},
+    heal_ops::{HealSequence, new_bg_heal_sequence},
 };
 use crate::error::{Error, Result};
 use crate::global::GLOBAL_MRFState;
 use crate::heal::error::ERR_RETRY_HEALING;
-use crate::heal::heal_commands::{HealScanMode, HEAL_ITEM_BUCKET};
-use crate::heal::heal_ops::{HealSource, BG_HEALING_UUID};
+use crate::heal::heal_commands::{HEAL_ITEM_BUCKET, HealScanMode};
+use crate::heal::heal_ops::{BG_HEALING_UUID, HealSource};
 use crate::{
     config::RUSTFS_CONFIG_PREFIX,
-    disk::{endpoint::Endpoint, error::DiskError, DiskAPI, DiskInfoOptions, BUCKET_META_PREFIX, RUSTFS_META_BUCKET},
+    disk::{BUCKET_META_PREFIX, DiskAPI, DiskInfoOptions, RUSTFS_META_BUCKET, endpoint::Endpoint, error::DiskError},
     global::{GLOBAL_BackgroundHealRoutine, GLOBAL_BackgroundHealState, GLOBAL_LOCAL_DISK_MAP},
     heal::{
         data_usage::{DATA_USAGE_CACHE_NAME, DATA_USAGE_ROOT},
@@ -34,7 +34,7 @@ use crate::{
     new_object_layer_fn,
     store::get_disk_via_endpoint,
     store_api::{BucketInfo, BucketOptions, StorageAPI},
-    utils::path::{path_join, SLASH_SEPARATOR},
+    utils::path::{SLASH_SEPARATOR, path_join},
 };
 
 pub static DEFAULT_MONITOR_NEW_DISK_INTERVAL: Duration = Duration::from_secs(10);
@@ -149,7 +149,7 @@ async fn heal_fresh_disk(endpoint: &Endpoint) -> Result<()> {
             return Err(Error::other(format!(
                 "Unexpected error disk must be initialized by now after formatting: {}",
                 endpoint
-            )))
+            )));
         }
     };
 

ecstore/src/heal/data_scanner.rs

@@ -6,17 +6,17 @@ use std::{
     path::{Path, PathBuf},
     pin::Pin,
     sync::{
-        atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering},
         Arc,
+        atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering},
     },
     time::{Duration, SystemTime},
 };
 
 use super::{
-    data_scanner_metric::{globalScannerMetrics, ScannerMetric, ScannerMetrics},
-    data_usage::{store_data_usage_in_backend, DATA_USAGE_BLOOM_NAME_PATH},
+    data_scanner_metric::{ScannerMetric, ScannerMetrics, globalScannerMetrics},
+    data_usage::{DATA_USAGE_BLOOM_NAME_PATH, store_data_usage_in_backend},
     data_usage_cache::{DataUsageCache, DataUsageEntry, DataUsageHash},
-    heal_commands::{HealScanMode, HEAL_DEEP_SCAN, HEAL_NORMAL_SCAN},
+    heal_commands::{HEAL_DEEP_SCAN, HEAL_NORMAL_SCAN, HealScanMode},
 };
 use crate::{
     bucket::{versioning::VersioningApi, versioning_sys::BucketVersioningSys},
@@ -24,7 +24,7 @@ use crate::{
     heal::data_usage::DATA_USAGE_ROOT,
 };
 use crate::{
-    cache_value::metacache_set::{list_path_raw, ListPathRawOptions},
+    cache_value::metacache_set::{ListPathRawOptions, list_path_raw},
     config::{
         com::{read_config, save_config},
         heal::Config,
@@ -33,22 +33,22 @@ use crate::{
     global::{GLOBAL_BackgroundHealState, GLOBAL_IsErasure, GLOBAL_IsErasureSD},
     heal::{
         data_usage::BACKGROUND_HEAL_INFO_PATH,
-        data_usage_cache::{hash_path, DataUsageHashMap},
+        data_usage_cache::{DataUsageHashMap, hash_path},
         error::ERR_IGNORE_FILE_CONTRIB,
         heal_commands::{HEAL_ITEM_BUCKET, HEAL_ITEM_OBJECT},
-        heal_ops::{HealSource, BG_HEALING_UUID},
+        heal_ops::{BG_HEALING_UUID, HealSource},
     },
     new_object_layer_fn,
     peer::is_reserved_or_invalid_bucket,
     store::ECStore,
-    utils::path::{path_join, path_to_bucket_object, path_to_bucket_object_with_base_path, SLASH_SEPARATOR},
+    utils::path::{SLASH_SEPARATOR, path_join, path_to_bucket_object, path_to_bucket_object_with_base_path},
 };
+use crate::{disk::DiskAPI, store_api::ObjectInfo};
 use crate::{
     disk::error::DiskError,
     error::{Error, Result},
 };
 use crate::{disk::local::LocalDisk, heal::data_scanner_metric::current_path_updater};
-use crate::{disk::DiskAPI, store_api::ObjectInfo};
 use chrono::{DateTime, Utc};
 use lazy_static::lazy_static;
 use rand::Rng;
@@ -58,9 +58,8 @@ use s3s::dto::{BucketLifecycleConfiguration, ExpirationStatus, LifecycleRule, Re
 use serde::{Deserialize, Serialize};
 use tokio::{
     sync::{
-        broadcast,
+        RwLock, broadcast,
         mpsc::{self, Sender},
-        RwLock,
     },
     time::sleep,
 };

ecstore/src/heal/data_scanner_metric.rs

@@ -6,8 +6,8 @@ use std::{
     collections::HashMap,
     pin::Pin,
     sync::{
-        atomic::{AtomicU64, Ordering},
         Arc,
+        atomic::{AtomicU64, Ordering},
     },
     time::{Duration, SystemTime},
 };

ecstore/src/heal/data_usage_cache.rs

@@ -18,7 +18,7 @@ use std::time::{Duration, SystemTime};
 use tokio::sync::mpsc::Sender;
 use tokio::time::sleep;
 
-use super::data_scanner::{SizeSummary, DATA_SCANNER_FORCE_COMPACT_AT_FOLDERS};
+use super::data_scanner::{DATA_SCANNER_FORCE_COMPACT_AT_FOLDERS, SizeSummary};
 use super::data_usage::{BucketTargetUsageInfo, BucketUsageInfo, DataUsageInfo};
 
 // DATA_USAGE_BUCKET_LEN must be length of ObjectsHistogramIntervals

ecstore/src/heal/heal_commands.rs

@@ -6,7 +6,7 @@ use std::{
 
 use crate::{
     config::storageclass::{RRS, STANDARD},
-    disk::{error::DiskError, DeleteOptions, DiskAPI, DiskStore, BUCKET_META_PREFIX, RUSTFS_META_BUCKET},
+    disk::{BUCKET_META_PREFIX, DeleteOptions, DiskAPI, DiskStore, RUSTFS_META_BUCKET, error::DiskError},
     global::GLOBAL_BackgroundHealState,
     heal::heal_ops::HEALING_TRACKER_FILENAME,
     new_object_layer_fn,

ecstore/src/heal/heal_ops.rs

@@ -2,7 +2,7 @@ use super::{
     background_heal_ops::HealTask,
     data_scanner::HEAL_DELETE_DANGLING,
     error::ERR_SKIP_FILE,
-    heal_commands::{HealOpts, HealScanMode, HealStopSuccess, HealingTracker, HEAL_ITEM_BUCKET_METADATA},
+    heal_commands::{HEAL_ITEM_BUCKET_METADATA, HealOpts, HealScanMode, HealStopSuccess, HealingTracker},
 };
 use crate::error::{Error, Result};
 use crate::store_api::StorageAPI;
@@ -16,7 +16,7 @@ use crate::{
     disk::endpoint::Endpoint,
     endpoints::Endpoints,
     global::GLOBAL_IsDistErasure,
-    heal::heal_commands::{HealStartSuccess, HEAL_UNKNOWN_SCAN},
+    heal::heal_commands::{HEAL_UNKNOWN_SCAN, HealStartSuccess},
     new_object_layer_fn,
     utils::path::has_prefix,
 };
@@ -41,10 +41,9 @@ use std::{
 use tokio::{
     select, spawn,
     sync::{
-        broadcast,
+        RwLock, broadcast,
         mpsc::{self, Receiver as M_Receiver, Sender as M_Sender},
         watch::{self, Receiver as W_Receiver, Sender as W_Sender},
-        RwLock,
     },
     time::{interval, sleep},
 };
@@ -784,7 +783,10 @@ impl AllHealState {
             self.stop_heal_sequence(path_s).await?;
         } else if let Some(hs) = self.get_heal_sequence(path_s).await {
             if !hs.has_ended().await {
-                return Err(Error::other(format!("Heal is already running on the given path (use force-start option to stop and start afresh). The heal was started by IP {} at {:?}, token is {}", heal_sequence.client_address, heal_sequence.start_time, heal_sequence.client_token)));
+                return Err(Error::other(format!(
+                    "Heal is already running on the given path (use force-start option to stop and start afresh). The heal was started by IP {} at {:?}, token is {}",
+                    heal_sequence.client_address, heal_sequence.start_time, heal_sequence.client_token
+                )));
             }
         }
 

ecstore/src/heal/mrf.rs

@@ -8,8 +8,8 @@ use regex::Regex;
 use std::ops::Sub;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
-use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::sync::RwLock;
+use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::time::sleep;
 use tracing::error;
 use uuid::Uuid;