ilm feature add

ecstore/src/heal/data_scanner.rs

@@ -6,19 +6,45 @@ use std::{
     path::{Path, PathBuf},
     pin::Pin,
     sync::{
-        Arc,
         atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering},
+        Arc,
     },
     time::{Duration, SystemTime},
 };
 
+use time::{self, OffsetDateTime};
+use common::defer;
+
+use rustfs_utils::path::encode_dir_object;
 use super::{
     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::{HEAL_DEEP_SCAN, HEAL_NORMAL_SCAN, HealScanMode},
 };
-use crate::{bucket::metadata_sys, cmd::bucket_replication::queue_replication_heal};
+use crate::bucket::{
+    object_lock::objectlock_sys::{
+        enforce_retention_for_deletion,
+        BucketObjectLockSys,
+    }, utils::is_meta_bucketname,
+};
+use crate::{
+    bucket::{
+        lifecycle::{
+            bucket_lifecycle_audit::{LcAuditEvent, LcEventSrc},
+            lifecycle::{self, Lifecycle, ExpirationOptions},
+			      bucket_lifecycle_ops::{
+	              self, GLOBAL_ExpiryState, GLOBAL_TransitionState, LifecycleOps,
+	              expire_transitioned_object,
+	          },
+        },
+        metadata_sys
+    },
+    event_notification::{send_event, EventArgs},
+    global::GLOBAL_LocalNodeName, heal::{data_scanner},
+    store_api::{ObjectOptions, ObjectToDelete, StorageAPI},
+};
+use crate::cmd::bucket_replication::queue_replication_heal;
 use crate::{
     bucket::{versioning::VersioningApi, versioning_sys::BucketVersioningSys},
     cmd::bucket_replication::ReplicationStatusType,
@@ -44,6 +70,7 @@ use crate::{
     peer::is_reserved_or_invalid_bucket,
     store::ECStore,
 };
+use crate::event::name::EventName;
 use crate::{disk::DiskAPI, store_api::ObjectInfo};
 use crate::{
     disk::error::DiskError,
@@ -56,7 +83,7 @@ use rand::Rng;
 use rmp_serde::{Deserializer, Serializer};
 use rustfs_filemeta::{FileInfo, MetaCacheEntries, MetaCacheEntry, MetadataResolutionParams};
 use rustfs_utils::path::{SLASH_SEPARATOR, path_join, path_to_bucket_object, path_to_bucket_object_with_base_path};
-use s3s::dto::{BucketLifecycleConfiguration, ExpirationStatus, LifecycleRule, ReplicationConfiguration, ReplicationRuleStatus};
+use s3s::dto::{BucketLifecycleConfiguration, DefaultRetention, ExpirationStatus, LifecycleRule, ReplicationConfiguration, ReplicationRuleStatus, VersioningConfiguration};
 use serde::{Deserialize, Serialize};
 use tokio::{
     sync::{
@@ -515,8 +542,55 @@ impl ScannerItem {
         path_join(&[PathBuf::from(self.prefix.clone()), PathBuf::from(self.object_name.clone())])
     }
 
-    pub async fn apply_versions_actions(&self, fives: &[FileInfo]) -> Result<Vec<ObjectInfo>> {
-        let obj_infos = self.apply_newer_noncurrent_version_limit(fives).await?;
+    async fn apply_lifecycle(&self, oi: &ObjectInfo) -> (lifecycle::IlmAction, i64) {
+        let mut size = oi.get_actual_size().expect("err!");
+        if self.debug {
+            info!("apply_lifecycle debug");
+        }
+        if self.lifecycle.is_none() {
+            return (lifecycle::IlmAction::NoneAction, size as i64);
+        }
+
+        let version_id = oi.version_id;
+
+        let mut vc = None;
+        let mut lr = None;
+        let mut rcfg = None;
+        if !is_meta_bucketname(&self.bucket) {
+            vc = Some(BucketVersioningSys::get(&self.bucket).await.unwrap());
+            lr = BucketObjectLockSys::get(&self.bucket).await;
+            rcfg = if let Ok(replication_config) = metadata_sys::get_replication_config(&self.bucket).await {
+                Some(replication_config)
+            } else { None };
+        }
+
+        let lc_evt = eval_action_from_lifecycle(self.lifecycle.as_ref().expect("err"), lr, rcfg, oi).await;
+        if self.debug {
+            if !version_id.is_none() {
+                info!("lifecycle: {} (version-id={}), Initial scan: {}", self.object_path().to_string_lossy().to_string(), version_id.expect("err"), lc_evt.action);
+            } else {
+                info!("lifecycle: {} Initial scan: {}", self.object_path().to_string_lossy().to_string(), lc_evt.action);
+            }
+        }
+
+        match lc_evt.action {
+            lifecycle::IlmAction::DeleteVersionAction | lifecycle::IlmAction::DeleteAllVersionsAction | lifecycle::IlmAction::DelMarkerDeleteAllVersionsAction => {
+                size = 0;
+            }
+            lifecycle::IlmAction::DeleteAction => {
+                if !vc.unwrap().prefix_enabled(&oi.name) {
+                    size = 0
+                }
+            }
+            _ => ()
+        }
+
+        apply_lifecycle_action(&lc_evt, &LcEventSrc::Scanner, oi).await;
+        (lc_evt.action, size as i64)
+    }
+
+    pub async fn apply_versions_actions(&self, fivs: &[FileInfo]) -> Result<Vec<ObjectInfo>> {
+        let obj_infos = self.apply_newer_noncurrent_version_limit(fivs).await?;
         if obj_infos.len() >= SCANNER_EXCESS_OBJECT_VERSIONS.load(Ordering::SeqCst) as usize {
             // todo
         }
@@ -533,16 +607,22 @@ impl ScannerItem {
         Ok(obj_infos)
     }
 
-    pub async fn apply_newer_noncurrent_version_limit(&self, fives: &[FileInfo]) -> Result<Vec<ObjectInfo>> {
+    pub async fn apply_newer_noncurrent_version_limit(&self, fivs: &[FileInfo]) -> Result<Vec<ObjectInfo>> {
         // let done = ScannerMetrics::time(ScannerMetric::ApplyNonCurrent);
+
+        let lock_enabled = if let Some(rcfg) = BucketObjectLockSys::get(&self.bucket).await {
+            rcfg.mode.is_some()
+        } else { false };
+        let vcfg = BucketVersioningSys::get(&self.bucket).await?;
+
         let versioned = match BucketVersioningSys::get(&self.bucket).await {
             Ok(vcfg) => vcfg.versioned(self.object_path().to_str().unwrap_or_default()),
             Err(_) => false,
         };
-        let mut object_infos = Vec::with_capacity(fives.len());
+        let mut object_infos = Vec::with_capacity(fivs.len());
 
         if self.lifecycle.is_none() {
-            for info in fives.iter() {
+            for info in fivs.iter() {
                 object_infos.push(ObjectInfo::from_file_info(
                     info,
                     &self.bucket,
@@ -553,6 +633,54 @@ impl ScannerItem {
             return Ok(object_infos);
         }
 
+        let event = self.lifecycle.as_ref().expect("lifecycle err.").noncurrent_versions_expiration_limit(&lifecycle::ObjectOpts {
+            name: self.object_path().to_string_lossy().to_string(),
+            ..Default::default()
+        }).await;
+        let lim = event.newer_noncurrent_versions;
+        if lim == 0 || fivs.len() <= lim+1 {
+            for fi in fivs.iter() {
+                object_infos.push(ObjectInfo::from_file_info(fi, &self.bucket, &self.object_path().to_string_lossy(), versioned));
+            }
+            return Ok(object_infos);
+        }
+
+        let overflow_versions = &fivs[lim+1..];
+        for fi in fivs[..lim+1].iter() {
+            object_infos.push(ObjectInfo::from_file_info(fi, &self.bucket, &self.object_path().to_string_lossy(), versioned));
+        }
+
+        let mut to_del = Vec::<ObjectToDelete>::with_capacity(overflow_versions.len());
+        for fi in overflow_versions.iter() {
+            let obj = ObjectInfo::from_file_info(fi, &self.bucket, &self.object_path().to_string_lossy(), versioned);
+            if lock_enabled && enforce_retention_for_deletion(&obj) {
+            //if enforce_retention_for_deletion(&obj) {
+                if self.debug {
+                    if obj.version_id.is_some() {
+                        info!("lifecycle: {} v({}) is locked, not deleting\n", obj.name, obj.version_id.expect("err"));
+                    } else {
+                        info!("lifecycle: {} is locked, not deleting\n", obj.name);
+                    }
+                }
+                object_infos.push(obj);
+                continue;
+            }
+
+            if OffsetDateTime::now_utc().unix_timestamp() < lifecycle::expected_expiry_time(obj.successor_mod_time.expect("err"), event.noncurrent_days as i32).unix_timestamp() {
+                object_infos.push(obj);
+                continue;
+            }
+
+            to_del.push(ObjectToDelete {
+                object_name: obj.name,
+                version_id: obj.version_id,
+            });
+        }
+
+        if to_del.len() > 0 {
+            let mut expiry_state = GLOBAL_ExpiryState.write().await;
+            expiry_state.enqueue_by_newer_noncurrent(&self.bucket, to_del, event).await;
+        }
         // done().await;
 
         Ok(object_infos)
@@ -560,7 +688,9 @@ impl ScannerItem {
 
     pub async fn apply_actions(&mut self, oi: &ObjectInfo, _size_s: &mut SizeSummary) -> (bool, usize) {
         let done = ScannerMetrics::time(ScannerMetric::Ilm);
-        //todo: lifecycle
+        
+        let (action, size) = self.apply_lifecycle(oi).await;
+
         info!(
             "apply_actions {} {} {:?} {:?}",
             oi.bucket.clone(),
@@ -581,6 +711,10 @@ impl ScannerItem {
         self.heal_replication(&oi, _size_s).await;
         done();
 
+        if action.delete_all() {
+            return (true, 0);
+        }
+
         (false, oi.size)
     }
 
@@ -757,9 +891,9 @@ impl FolderScanner {
 
             let (_, prefix) = path_to_bucket_object_with_base_path(&self.root, &folder.name);
             // Todo: lifeCycle
-            let active_life_cycle = if let Some(lc) = self.old_cache.info.life_cycle.as_ref() {
+            let active_life_cycle = if let Some(lc) = self.old_cache.info.lifecycle.as_ref() {
                 if lc_has_active_rules(lc, &prefix) {
-                    self.old_cache.info.life_cycle.clone()
+                    self.old_cache.info.lifecycle.clone()
                 } else {
                     None
                 }
@@ -1401,7 +1535,151 @@ pub async fn scan_data_folder(
     Ok(s.new_cache)
 }
 
-// pub fn eval_action_from_lifecycle(lc: &BucketLifecycleConfiguration, lr: &ObjectLockConfiguration, rcfg: &ReplicationConfiguration， obj: &ObjectInfo)
+pub async fn eval_action_from_lifecycle(lc: &BucketLifecycleConfiguration, lr: Option<DefaultRetention>, rcfg: Option<(ReplicationConfiguration, OffsetDateTime)>, oi: &ObjectInfo) -> lifecycle::Event {
+    let event = lc.eval(&oi.to_lifecycle_opts()).await;
+    //if serverDebugLog {
+        info!("lifecycle: Secondary scan: {}", event.action);
+    //}
+
+    let lock_enabled = if let Some(lr) = lr {
+        lr.mode.is_some()
+    } else { false };
+
+    match event.action {
+        lifecycle::IlmAction::DeleteAllVersionsAction | lifecycle::IlmAction::DelMarkerDeleteAllVersionsAction => {
+            if lock_enabled {
+                return lifecycle::Event::default();
+            }
+        }
+        lifecycle::IlmAction::DeleteVersionAction | lifecycle::IlmAction::DeleteRestoredVersionAction => {
+            if oi.version_id.is_none() {
+                return lifecycle::Event::default();
+            }
+            if lock_enabled && enforce_retention_for_deletion(oi) {
+                //if serverDebugLog {
+                    if !oi.version_id.is_none() {
+                        info!("lifecycle: {} v({}) is locked, not deleting", oi.name, oi.version_id.expect("err"));
+                    } else {
+                        info!("lifecycle: {} is locked, not deleting", oi.name);
+                    }
+                //}
+                return lifecycle::Event::default();
+            }
+            if let Some(rcfg) = rcfg {
+                if rep_has_active_rules(&rcfg.0, &oi.name, true) {
+                    return lifecycle::Event::default();
+                }
+            }
+        }
+        _ => ()
+    }
+
+    event
+}
+
+async fn apply_transition_rule(event: &lifecycle::Event, src: &LcEventSrc, oi: &ObjectInfo) -> bool {
+    if oi.delete_marker || oi.is_dir {
+        return false;
+    }
+    GLOBAL_TransitionState.queue_transition_task(oi, event, src).await;
+    true
+}
+
+pub async fn apply_expiry_on_transitioned_object(api: Arc<ECStore>, oi: &ObjectInfo, lc_event: &lifecycle::Event, src: &LcEventSrc) -> bool {
+    let time_ilm = ScannerMetrics::time_ilm(lc_event.action.clone());
+    if let Err(_err) = expire_transitioned_object(api, oi, lc_event, src).await {
+        return false;
+    }
+    time_ilm(1);
+
+    true
+}
+
+pub async fn apply_expiry_on_non_transitioned_objects(api: Arc<ECStore>, oi: &ObjectInfo, lc_event: &lifecycle::Event, src: &LcEventSrc) -> bool {
+    let mut opts = ObjectOptions {
+        expiration: ExpirationOptions {expire: true},
+        ..Default::default()
+    };
+
+    if lc_event.action.delete_versioned() {
+        opts.version_id = Some(oi.version_id.expect("err").to_string());
+    }
+
+    opts.versioned = BucketVersioningSys::prefix_enabled(&oi.bucket, &oi.name).await;
+    opts.version_suspended = BucketVersioningSys::prefix_suspended(&oi.bucket, &oi.name).await;
+
+    if lc_event.action.delete_all() {
+        opts.delete_prefix = true;
+        opts.delete_prefix_object = true;
+    }
+    let dobj: ObjectInfo;
+    //let  err: Error;
+
+    let time_ilm = ScannerMetrics::time_ilm(lc_event.action.clone());
+
+    let mut dobj = api.delete_object(&oi.bucket, &encode_dir_object(&oi.name), opts).await.unwrap();
+    if dobj.name == "" {
+        dobj = oi.clone();
+    }
+
+    //let tags = LcAuditEvent::new(lc_event.clone(), src.clone()).tags();
+    //tags["version-id"] = dobj.version_id;
+
+    let mut event_name = EventName::ObjectRemovedDelete;
+    if oi.delete_marker {
+        event_name = EventName::ObjectRemovedDeleteMarkerCreated;
+    }
+    match lc_event.action {
+        lifecycle::IlmAction::DeleteAllVersionsAction => {
+            event_name = EventName::ObjectRemovedDeleteAllVersions
+        }
+        lifecycle::IlmAction::DelMarkerDeleteAllVersionsAction => {
+            event_name = EventName::ILMDelMarkerExpirationDelete
+        }
+        _ => ()
+    }
+    send_event(EventArgs {
+        event_name: event_name.as_ref().to_string(),
+        bucket_name: dobj.bucket.clone(),
+        object: dobj,
+        user_agent: "Internal: [ILM-Expiry]".to_string(),
+        host: GLOBAL_LocalNodeName.to_string(),
+        ..Default::default()
+    });
+
+    if lc_event.action != lifecycle::IlmAction::NoneAction {
+        let mut num_versions = 1_u64;
+        if lc_event.action.delete_all() {
+            num_versions = oi.num_versions as u64;
+        }
+        time_ilm(num_versions);
+    }
+
+    true
+}
+
+async fn apply_expiry_rule(event: &lifecycle::Event, src: &LcEventSrc, oi: &ObjectInfo) -> bool {
+    let mut expiry_state = GLOBAL_ExpiryState.write().await;
+    expiry_state.enqueue_by_days(oi, event, src).await;
+    true
+}
+
+pub async fn apply_lifecycle_action(event: &lifecycle::Event, src: &LcEventSrc, oi: &ObjectInfo) -> bool {
+    let mut success = false;
+    match event.action {
+        lifecycle::IlmAction::DeleteVersionAction | lifecycle::IlmAction::DeleteAction
+        | lifecycle::IlmAction::DeleteRestoredAction | lifecycle::IlmAction::DeleteRestoredVersionAction
+        | lifecycle::IlmAction::DeleteAllVersionsAction | lifecycle::IlmAction::DelMarkerDeleteAllVersionsAction => {
+            success = apply_expiry_rule(event, src, oi).await;
+        }
+        lifecycle::IlmAction::TransitionAction | lifecycle::IlmAction::TransitionVersionAction => {
+            success = apply_transition_rule(event, src, oi).await;
+        }
+        _ => ()
+    }
+    success
+}
+
 
 #[cfg(test)]
 mod tests {

ecstore/src/heal/data_scanner_metric.rs

@@ -15,14 +15,13 @@ use tokio::sync::{Mutex, RwLock};
 use tracing::debug;
 
 use super::data_scanner::CurrentScannerCycle;
+use crate::bucket::lifecycle::lifecycle;
 
 lazy_static! {
     pub static ref globalScannerMetrics: Arc<ScannerMetrics> = Arc::new(ScannerMetrics::new());
 }
 
-/// Scanner metric types, matching the Go version exactly
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[repr(u8)]
+#[derive(Clone, Debug, PartialEq, PartialOrd)]
 pub enum ScannerMetric {
     // START Realtime metrics, that only records
     // last minute latencies and total operation count.
@@ -196,7 +195,8 @@ pub struct ScannerMetrics {
     // All fields must be accessed atomically and aligned.
     operations: Vec<AtomicU64>,
     latency: Vec<LockedLastMinuteLatency>,
-
+    actions: Vec<AtomicU64>,
+    actions_latency: Vec<LockedLastMinuteLatency>,
     // Current paths contains disk -> tracker mappings
     current_paths: Arc<RwLock<HashMap<String, Arc<CurrentPathTracker>>>>,
 
@@ -215,6 +215,8 @@ impl ScannerMetrics {
         Self {
             operations,
             latency,
+            actions: (0..ScannerMetric::Last as usize).map(|_| AtomicU64::new(0)).collect(),
+            actions_latency: vec![LockedLastMinuteLatency::default(); ScannerMetric::LastRealtime as usize],
             current_paths: Arc::new(RwLock::new(HashMap::new())),
             cycle_info: Arc::new(RwLock::new(None)),
         }
@@ -222,16 +224,17 @@ impl ScannerMetrics {
 
     /// Log scanner action with custom metadata - compatible with existing usage
     pub fn log(metric: ScannerMetric) -> impl Fn(&HashMap<String, String>) {
+        let metric = metric as usize;
         let start_time = SystemTime::now();
         move |_custom: &HashMap<String, String>| {
             let duration = SystemTime::now().duration_since(start_time).unwrap_or_default();
 
             // Update operation count
-            globalScannerMetrics.operations[metric as usize].fetch_add(1, Ordering::Relaxed);
+            globalScannerMetrics.operations[metric].fetch_add(1, Ordering::Relaxed);
 
             // Update latency for realtime metrics (spawn async task for this)
-            if (metric as usize) < ScannerMetric::LastRealtime as usize {
-                let metric_index = metric as usize;
+            if (metric) < ScannerMetric::LastRealtime as usize {
+                let metric_index = metric;
                 tokio::spawn(async move {
                     globalScannerMetrics.latency[metric_index].add(duration).await;
                 });
@@ -239,23 +242,24 @@ impl ScannerMetrics {
 
             // Log trace metrics
             if metric as u8 > ScannerMetric::StartTrace as u8 {
-                debug!(metric = metric.as_str(), duration_ms = duration.as_millis(), "Scanner trace metric");
+                //debug!(metric = metric.as_str(), duration_ms = duration.as_millis(), "Scanner trace metric");
             }
         }
     }
 
     /// Time scanner action with size - returns function that takes size
     pub fn time_size(metric: ScannerMetric) -> impl Fn(u64) {
+        let metric = metric as usize;
         let start_time = SystemTime::now();
         move |size: u64| {
             let duration = SystemTime::now().duration_since(start_time).unwrap_or_default();
 
             // Update operation count
-            globalScannerMetrics.operations[metric as usize].fetch_add(1, Ordering::Relaxed);
+            globalScannerMetrics.operations[metric].fetch_add(1, Ordering::Relaxed);
 
             // Update latency for realtime metrics with size (spawn async task)
-            if (metric as usize) < ScannerMetric::LastRealtime as usize {
-                let metric_index = metric as usize;
+            if (metric) < ScannerMetric::LastRealtime as usize {
+                let metric_index = metric;
                 tokio::spawn(async move {
                     globalScannerMetrics.latency[metric_index].add_size(duration, size).await;
                 });
@@ -265,16 +269,17 @@ impl ScannerMetrics {
 
     /// Time a scanner action - returns a closure to call when done
     pub fn time(metric: ScannerMetric) -> impl Fn() {
+        let metric = metric as usize;
         let start_time = SystemTime::now();
         move || {
             let duration = SystemTime::now().duration_since(start_time).unwrap_or_default();
 
             // Update operation count
-            globalScannerMetrics.operations[metric as usize].fetch_add(1, Ordering::Relaxed);
+            globalScannerMetrics.operations[metric].fetch_add(1, Ordering::Relaxed);
 
             // Update latency for realtime metrics (spawn async task)
-            if (metric as usize) < ScannerMetric::LastRealtime as usize {
-                let metric_index = metric as usize;
+            if (metric) < ScannerMetric::LastRealtime as usize {
+                let metric_index = metric;
                 tokio::spawn(async move {
                     globalScannerMetrics.latency[metric_index].add(duration).await;
                 });
@@ -284,17 +289,18 @@ impl ScannerMetrics {
 
     /// Time N scanner actions - returns function that takes count, then returns completion function
     pub fn time_n(metric: ScannerMetric) -> Box<dyn Fn(usize) -> Box<dyn Fn() + Send + Sync> + Send + Sync> {
+        let metric = metric as usize;
         let start_time = SystemTime::now();
         Box::new(move |count: usize| {
             Box::new(move || {
                 let duration = SystemTime::now().duration_since(start_time).unwrap_or_default();
 
                 // Update operation count
-                globalScannerMetrics.operations[metric as usize].fetch_add(count as u64, Ordering::Relaxed);
+                globalScannerMetrics.operations[metric].fetch_add(count as u64, Ordering::Relaxed);
 
                 // Update latency for realtime metrics (spawn async task)
-                if (metric as usize) < ScannerMetric::LastRealtime as usize {
-                    let metric_index = metric as usize;
+                if (metric) < ScannerMetric::LastRealtime as usize {
+                    let metric_index = metric;
                     tokio::spawn(async move {
                         globalScannerMetrics.latency[metric_index].add(duration).await;
                     });
@@ -303,31 +309,53 @@ impl ScannerMetrics {
         })
     }
 
+    pub fn time_ilm(a: lifecycle::IlmAction) -> Box<dyn Fn(u64) -> Box<dyn Fn() + Send + Sync> + Send + Sync> {
+        let a_clone = a as usize;
+        if a_clone == lifecycle::IlmAction::NoneAction as usize || a_clone >= lifecycle::IlmAction::ActionCount as usize {
+            return Box::new(move |_: u64| {
+                Box::new(move || {})
+            });
+        }
+        let start = SystemTime::now();
+        Box::new(move |versions: u64| {
+            Box::new(move || {
+                let duration = SystemTime::now().duration_since(start).unwrap_or(Duration::from_secs(0));
+                tokio::spawn(async move {
+                    globalScannerMetrics.actions[a_clone].fetch_add(versions, Ordering::Relaxed);
+                    globalScannerMetrics.actions_latency[a_clone].add(duration).await;
+                });
+            })
+        })
+    }
+
     /// Increment time with specific duration
     pub async fn inc_time(metric: ScannerMetric, duration: Duration) {
+        let metric = metric as usize;
         // Update operation count
-        globalScannerMetrics.operations[metric as usize].fetch_add(1, Ordering::Relaxed);
+        globalScannerMetrics.operations[metric].fetch_add(1, Ordering::Relaxed);
 
         // Update latency for realtime metrics
-        if (metric as usize) < ScannerMetric::LastRealtime as usize {
-            globalScannerMetrics.latency[metric as usize].add(duration).await;
+        if (metric) < ScannerMetric::LastRealtime as usize {
+            globalScannerMetrics.latency[metric].add(duration).await;
         }
     }
 
     /// Get lifetime operation count for a metric
     pub fn lifetime(&self, metric: ScannerMetric) -> u64 {
-        if (metric as usize) >= ScannerMetric::Last as usize {
+        let metric = metric as usize;
+        if (metric) >= ScannerMetric::Last as usize {
             return 0;
         }
-        self.operations[metric as usize].load(Ordering::Relaxed)
+        self.operations[metric].load(Ordering::Relaxed)
     }
 
     /// Get last minute statistics for a metric
     pub async fn last_minute(&self, metric: ScannerMetric) -> AccElem {
-        if (metric as usize) >= ScannerMetric::LastRealtime as usize {
+        let metric = metric as usize;
+        if (metric) >= ScannerMetric::LastRealtime as usize {
             return AccElem::default();
         }
-        self.latency[metric as usize].total().await
+        self.latency[metric].total().await
     }
 
     /// Set current cycle information

ecstore/src/heal/data_usage_cache.rs

@@ -129,6 +129,58 @@ const OBJECTS_VERSION_COUNT_INTERVALS: [ObjectHistogramInterval; DATA_USAGE_VERS
     },
 ];
 
+#[derive(Clone, Copy, Default)]
+pub struct TierStats {
+    pub total_size: u64,
+    pub num_versions: i32,
+    pub num_objects: i32,
+}
+
+impl TierStats {
+    pub fn add(&self, u: &TierStats) -> TierStats {
+        TierStats {
+            total_size:   self.total_size + u.total_size,
+            num_versions: self.num_versions + u.num_versions,
+            num_objects:  self.num_objects + u.num_objects,
+        }
+    }
+}
+
+#[derive(Clone)]
+struct AllTierStats {
+    tiers: HashMap<String, TierStats>,
+}
+
+impl AllTierStats {
+    pub fn new() -> Self {
+        Self {
+            tiers: HashMap::new(),
+        }
+    }
+
+    fn add_sizes(&mut self, tiers: HashMap<String, TierStats>) {
+        for (tier, st) in tiers {
+            self.tiers.insert(tier.clone(), self.tiers[&tier].add(&st));
+        }
+    }
+
+    fn merge(&mut self, other: AllTierStats) {
+        for (tier, st) in other.tiers {
+            self.tiers.insert(tier.clone(), self.tiers[&tier].add(&st));
+        }
+    }
+
+    fn populate_stats(&self, stats: &mut HashMap<String, TierStats>) {
+        for (tier, st) in &self.tiers {
+            stats.insert(tier.clone(), TierStats {
+                total_size:   st.total_size.clone(),
+                num_versions: st.num_versions.clone(),
+                num_objects:  st.num_objects.clone(),
+            });
+        }
+    }
+}
+
 // sizeHistogram is a size histogram.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct SizeHistogram(Vec<u64>);
@@ -346,8 +398,7 @@ pub struct DataUsageCacheInfo {
     pub last_update: Option<SystemTime>,
     pub skip_healing: bool,
     #[serde(skip)]
-    pub life_cycle: Option<BucketLifecycleConfiguration>,
-    // pub life_cycle:
+    pub lifecycle: Option<BucketLifecycleConfiguration>,
     #[serde(skip)]
     pub updates: Option<Sender<DataUsageEntry>>,
     #[serde(skip)]