refactor: Restructure project layout and clean up dependencies (#30)

This commit introduces a significant reorganization of the project structure to improve maintainability and clarity.

Key changes include:
- Adjusted the directory layout for a more logical module organization.
- Removed unused crate dependencies, reducing the overall project size and potentially speeding up build times.
- Updated import paths and configuration files to reflect the structural changes.

crates/ecstore/src/bucket/error.rs

@@ -0,0 +1,106 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::error::Error;
+
+#[derive(Debug, thiserror::Error)]
+pub enum BucketMetadataError {
+    #[error("tagging not found")]
+    TaggingNotFound,
+    #[error("bucket policy not found")]
+    BucketPolicyNotFound,
+    #[error("bucket object lock not found")]
+    BucketObjectLockConfigNotFound,
+    #[error("bucket lifecycle not found")]
+    BucketLifecycleNotFound,
+    #[error("bucket SSE config not found")]
+    BucketSSEConfigNotFound,
+    #[error("bucket quota config not found")]
+    BucketQuotaConfigNotFound,
+    #[error("bucket replication config not found")]
+    BucketReplicationConfigNotFound,
+    #[error("bucket remote target not found")]
+    BucketRemoteTargetNotFound,
+
+    #[error("Io error: {0}")]
+    Io(std::io::Error),
+}
+
+impl BucketMetadataError {
+    pub fn other<E>(error: E) -> Self
+    where
+        E: Into<Box<dyn std::error::Error + Send + Sync>>,
+    {
+        BucketMetadataError::Io(std::io::Error::other(error))
+    }
+}
+
+impl From<Error> for BucketMetadataError {
+    fn from(e: Error) -> Self {
+        match e {
+            Error::Io(e) => e.into(),
+            _ => BucketMetadataError::other(e),
+        }
+    }
+}
+
+impl From<std::io::Error> for BucketMetadataError {
+    fn from(e: std::io::Error) -> Self {
+        e.downcast::<BucketMetadataError>().unwrap_or_else(BucketMetadataError::other)
+    }
+}
+
+impl PartialEq for BucketMetadataError {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (BucketMetadataError::Io(e1), BucketMetadataError::Io(e2)) => {
+                e1.kind() == e2.kind() && e1.to_string() == e2.to_string()
+            }
+            (e1, e2) => e1.to_u32() == e2.to_u32(),
+        }
+    }
+}
+
+impl Eq for BucketMetadataError {}
+
+impl BucketMetadataError {
+    pub fn to_u32(&self) -> u32 {
+        match self {
+            BucketMetadataError::TaggingNotFound => 0x01,
+            BucketMetadataError::BucketPolicyNotFound => 0x02,
+            BucketMetadataError::BucketObjectLockConfigNotFound => 0x03,
+            BucketMetadataError::BucketLifecycleNotFound => 0x04,
+            BucketMetadataError::BucketSSEConfigNotFound => 0x05,
+            BucketMetadataError::BucketQuotaConfigNotFound => 0x06,
+            BucketMetadataError::BucketReplicationConfigNotFound => 0x07,
+            BucketMetadataError::BucketRemoteTargetNotFound => 0x08,
+            BucketMetadataError::Io(_) => 0x09,
+        }
+    }
+
+    pub fn from_u32(error: u32) -> Option<Self> {
+        match error {
+            0x01 => Some(BucketMetadataError::TaggingNotFound),
+            0x02 => Some(BucketMetadataError::BucketPolicyNotFound),
+            0x03 => Some(BucketMetadataError::BucketObjectLockConfigNotFound),
+            0x04 => Some(BucketMetadataError::BucketLifecycleNotFound),
+            0x05 => Some(BucketMetadataError::BucketSSEConfigNotFound),
+            0x06 => Some(BucketMetadataError::BucketQuotaConfigNotFound),
+            0x07 => Some(BucketMetadataError::BucketReplicationConfigNotFound),
+            0x08 => Some(BucketMetadataError::BucketRemoteTargetNotFound),
+            0x09 => Some(BucketMetadataError::Io(std::io::Error::other("Io error"))),
+            _ => None,
+        }
+    }
+}

crates/ecstore/src/bucket/lifecycle/bucket_lifecycle_audit.rs

@@ -0,0 +1,43 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::lifecycle;
+
+#[derive(Debug, Clone, Default)]
+pub enum LcEventSrc {
+    #[default]
+    None,
+    Heal,
+    Scanner,
+    Decom,
+    Rebal,
+    S3HeadObject,
+    S3GetObject,
+    S3ListObjects,
+    S3PutObject,
+    S3CopyObject,
+    S3CompleteMultipartUpload,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct LcAuditEvent {
+    pub event: lifecycle::Event,
+    pub source: LcEventSrc,
+}
+
+impl LcAuditEvent {
+    pub fn new(event: lifecycle::Event, source: LcEventSrc) -> Self {
+        Self { event, source }
+    }
+}

crates/ecstore/src/bucket/lifecycle/bucket_lifecycle_ops.rs

@@ -0,0 +1,844 @@
+#![allow(unused_imports)]
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
+use async_channel::{Receiver as A_Receiver, Sender as A_Sender, bounded};
+use futures::Future;
+use http::HeaderMap;
+use lazy_static::lazy_static;
+use s3s::Body;
+use sha2::{Digest, Sha256};
+use std::any::Any;
+use std::collections::HashMap;
+use std::env;
+use std::io::Write;
+use std::pin::Pin;
+use std::sync::atomic::{AtomicI64, Ordering};
+use std::sync::{Arc, Mutex};
+use tokio::select;
+use tokio::sync::mpsc::{Receiver, Sender};
+use tokio::sync::{RwLock, mpsc};
+use tracing::{error, info};
+use uuid::Uuid;
+use xxhash_rust::xxh64;
+
+//use rustfs_notify::{BucketNotificationConfig, Event, EventName, LogLevel, NotificationError, init_logger};
+//use rustfs_notify::{initialize, notification_system};
+use super::bucket_lifecycle_audit::{LcAuditEvent, LcEventSrc};
+use super::lifecycle::{self, ExpirationOptions, IlmAction, Lifecycle, TransitionOptions};
+use super::tier_last_day_stats::{DailyAllTierStats, LastDayTierStats};
+use super::tier_sweeper::{Jentry, delete_object_from_remote_tier};
+use crate::bucket::{metadata_sys::get_lifecycle_config, versioning_sys::BucketVersioningSys};
+use crate::client::object_api_utils::new_getobjectreader;
+use crate::error::Error;
+use crate::error::{error_resp_to_object_err, is_err_object_not_found, is_err_version_not_found, is_network_or_host_down};
+use crate::event::name::EventName;
+use crate::event_notification::{EventArgs, send_event};
+use crate::global::GLOBAL_LocalNodeName;
+use crate::global::{GLOBAL_LifecycleSys, GLOBAL_TierConfigMgr, get_global_deployment_id};
+use crate::heal::{
+    data_scanner::{apply_expiry_on_non_transitioned_objects, apply_expiry_on_transitioned_object},
+    data_scanner_metric::ScannerMetrics,
+    data_usage_cache::TierStats,
+};
+use crate::store::ECStore;
+use crate::store_api::StorageAPI;
+use crate::store_api::{GetObjectReader, HTTPRangeSpec, ObjectInfo, ObjectOptions, ObjectToDelete};
+use crate::tier::warm_backend::WarmBackendGetOpts;
+use s3s::dto::BucketLifecycleConfiguration;
+
+pub type TimeFn = Arc<dyn Fn() -> Pin<Box<dyn Future<Output = ()> + Send>> + Send + Sync + 'static>;
+pub type TraceFn =
+    Arc<dyn Fn(String, HashMap<String, String>) -> Pin<Box<dyn Future<Output = ()> + Send>> + Send + Sync + 'static>;
+pub type ExpiryOpType = Box<dyn ExpiryOp + Send + Sync + 'static>;
+
+static XXHASH_SEED: u64 = 0;
+
+const _DISABLED: &str = "Disabled";
+
+//pub const ERR_INVALID_STORAGECLASS: &str = "invalid storage class.";
+pub const ERR_INVALID_STORAGECLASS: &str = "invalid tier.";
+
+lazy_static! {
+    pub static ref GLOBAL_ExpiryState: Arc<RwLock<ExpiryState>> = ExpiryState::new();
+    pub static ref GLOBAL_TransitionState: Arc<TransitionState> = TransitionState::new();
+}
+
+pub struct LifecycleSys;
+
+impl LifecycleSys {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self)
+    }
+
+    pub async fn get(&self, bucket: &str) -> Option<BucketLifecycleConfiguration> {
+        let lc = get_lifecycle_config(bucket).await.expect("get_lifecycle_config err!").0;
+        Some(lc)
+    }
+
+    pub fn trace(_oi: &ObjectInfo) -> TraceFn {
+        todo!();
+    }
+}
+
+struct ExpiryTask {
+    obj_info: ObjectInfo,
+    event: lifecycle::Event,
+    src: LcEventSrc,
+}
+
+impl ExpiryOp for ExpiryTask {
+    fn op_hash(&self) -> u64 {
+        let mut hasher = Sha256::new();
+        let _ = hasher.write(format!("{}", self.obj_info.bucket).as_bytes());
+        let _ = hasher.write(format!("{}", self.obj_info.name).as_bytes());
+        hasher.flush();
+        xxh64::xxh64(hasher.clone().finalize().as_slice(), XXHASH_SEED)
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+struct ExpiryStats {
+    missed_expiry_tasks: AtomicI64,
+    missed_freevers_tasks: AtomicI64,
+    missed_tier_journal_tasks: AtomicI64,
+    workers: AtomicI64,
+}
+
+#[allow(dead_code)]
+impl ExpiryStats {
+    pub fn missed_tasks(&self) -> i64 {
+        self.missed_expiry_tasks.load(Ordering::SeqCst)
+    }
+
+    fn missed_free_vers_tasks(&self) -> i64 {
+        self.missed_freevers_tasks.load(Ordering::SeqCst)
+    }
+
+    fn missed_tier_journal_tasks(&self) -> i64 {
+        self.missed_tier_journal_tasks.load(Ordering::SeqCst)
+    }
+
+    fn num_workers(&self) -> i64 {
+        self.workers.load(Ordering::SeqCst)
+    }
+}
+
+pub trait ExpiryOp: 'static {
+    fn op_hash(&self) -> u64;
+    fn as_any(&self) -> &dyn Any;
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct TransitionedObject {
+    pub name: String,
+    pub version_id: String,
+    pub tier: String,
+    pub free_version: bool,
+    pub status: String,
+}
+
+struct FreeVersionTask(ObjectInfo);
+
+impl ExpiryOp for FreeVersionTask {
+    fn op_hash(&self) -> u64 {
+        let mut hasher = Sha256::new();
+        let _ = hasher.write(format!("{}", self.0.transitioned_object.tier).as_bytes());
+        let _ = hasher.write(format!("{}", self.0.transitioned_object.name).as_bytes());
+        hasher.flush();
+        xxh64::xxh64(hasher.clone().finalize().as_slice(), XXHASH_SEED)
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+struct NewerNoncurrentTask {
+    bucket: String,
+    versions: Vec<ObjectToDelete>,
+    event: lifecycle::Event,
+}
+
+impl ExpiryOp for NewerNoncurrentTask {
+    fn op_hash(&self) -> u64 {
+        let mut hasher = Sha256::new();
+        let _ = hasher.write(format!("{}", self.bucket).as_bytes());
+        let _ = hasher.write(format!("{}", self.versions[0].object_name).as_bytes());
+        hasher.flush();
+        xxh64::xxh64(hasher.clone().finalize().as_slice(), XXHASH_SEED)
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+pub struct ExpiryState {
+    tasks_tx: Vec<Sender<Option<ExpiryOpType>>>,
+    tasks_rx: Vec<Arc<tokio::sync::Mutex<Receiver<Option<ExpiryOpType>>>>>,
+    stats: Option<ExpiryStats>,
+}
+
+impl ExpiryState {
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new() -> Arc<RwLock<Self>> {
+        Arc::new(RwLock::new(Self {
+            tasks_tx: vec![],
+            tasks_rx: vec![],
+            stats: Some(ExpiryStats {
+                missed_expiry_tasks: AtomicI64::new(0),
+                missed_freevers_tasks: AtomicI64::new(0),
+                missed_tier_journal_tasks: AtomicI64::new(0),
+                workers: AtomicI64::new(0),
+            }),
+        }))
+    }
+
+    pub async fn pending_tasks(&self) -> usize {
+        let rxs = &self.tasks_rx;
+        if rxs.len() == 0 {
+            return 0;
+        }
+        let mut tasks = 0;
+        for rx in rxs.iter() {
+            tasks += rx.lock().await.len();
+        }
+        tasks
+    }
+
+    pub async fn enqueue_tier_journal_entry(&mut self, je: &Jentry) -> Result<(), std::io::Error> {
+        let wrkr = self.get_worker_ch(je.op_hash());
+        if wrkr.is_none() {
+            *self.stats.as_mut().expect("err").missed_tier_journal_tasks.get_mut() += 1;
+        }
+        let wrkr = wrkr.expect("err");
+        select! {
+            //_ -> GlobalContext.Done() => ()
+            _ = wrkr.send(Some(Box::new(je.clone()))) => (),
+            else => {
+                *self.stats.as_mut().expect("err").missed_tier_journal_tasks.get_mut() += 1;
+            }
+        }
+        return Ok(());
+    }
+
+    pub async fn enqueue_free_version(&mut self, oi: ObjectInfo) {
+        let task = FreeVersionTask(oi);
+        let wrkr = self.get_worker_ch(task.op_hash());
+        if wrkr.is_none() {
+            *self.stats.as_mut().expect("err").missed_freevers_tasks.get_mut() += 1;
+            return;
+        }
+        let wrkr = wrkr.expect("err!");
+        select! {
+            //_ -> GlobalContext.Done() => {}
+            _ = wrkr.send(Some(Box::new(task))) => (),
+            else => {
+                *self.stats.as_mut().expect("err").missed_freevers_tasks.get_mut() += 1;
+            }
+        }
+    }
+
+    pub async fn enqueue_by_days(&mut self, oi: &ObjectInfo, event: &lifecycle::Event, src: &LcEventSrc) {
+        let task = ExpiryTask {
+            obj_info: oi.clone(),
+            event: event.clone(),
+            src: src.clone(),
+        };
+        let wrkr = self.get_worker_ch(task.op_hash());
+        if wrkr.is_none() {
+            *self.stats.as_mut().expect("err").missed_expiry_tasks.get_mut() += 1;
+            return;
+        }
+        let wrkr = wrkr.expect("err!");
+        select! {
+            //_ -> GlobalContext.Done() => {}
+            _ = wrkr.send(Some(Box::new(task))) => (),
+            else => {
+                *self.stats.as_mut().expect("err").missed_expiry_tasks.get_mut() += 1;
+            }
+        }
+    }
+
+    pub async fn enqueue_by_newer_noncurrent(&mut self, bucket: &str, versions: Vec<ObjectToDelete>, lc_event: lifecycle::Event) {
+        if versions.len() == 0 {
+            return;
+        }
+
+        let task = NewerNoncurrentTask {
+            bucket: String::from(bucket),
+            versions,
+            event: lc_event,
+        };
+        let wrkr = self.get_worker_ch(task.op_hash());
+        if wrkr.is_none() {
+            *self.stats.as_mut().expect("err").missed_expiry_tasks.get_mut() += 1;
+            return;
+        }
+        let wrkr = wrkr.expect("err!");
+        select! {
+            //_ -> GlobalContext.Done() => {}
+            _ = wrkr.send(Some(Box::new(task))) => (),
+            else => {
+                *self.stats.as_mut().expect("err").missed_expiry_tasks.get_mut() += 1;
+            }
+        }
+    }
+
+    pub fn get_worker_ch(&self, h: u64) -> Option<Sender<Option<ExpiryOpType>>> {
+        if self.tasks_tx.len() == 0 {
+            return None;
+        }
+        Some(self.tasks_tx[h as usize % self.tasks_tx.len()].clone())
+    }
+
+    pub async fn resize_workers(n: usize, api: Arc<ECStore>) {
+        if n == GLOBAL_ExpiryState.read().await.tasks_tx.len() || n < 1 {
+            return;
+        }
+
+        let mut state = GLOBAL_ExpiryState.write().await;
+
+        while state.tasks_tx.len() < n {
+            let (tx, rx) = mpsc::channel(10000);
+            let api = api.clone();
+            let rx = Arc::new(tokio::sync::Mutex::new(rx));
+            state.tasks_tx.push(tx);
+            state.tasks_rx.push(rx.clone());
+            *state.stats.as_mut().expect("err").workers.get_mut() += 1;
+            tokio::spawn(async move {
+                let mut rx = rx.lock().await;
+                //let mut expiry_state = GLOBAL_ExpiryState.read().await;
+                ExpiryState::worker(&mut *rx, api).await;
+            });
+        }
+
+        let mut l = state.tasks_tx.len();
+        while l > n {
+            let worker = state.tasks_tx[l - 1].clone();
+            worker.send(None).await.unwrap_or(());
+            state.tasks_tx.remove(l - 1);
+            state.tasks_rx.remove(l - 1);
+            *state.stats.as_mut().expect("err").workers.get_mut() -= 1;
+            l -= 1;
+        }
+    }
+
+    pub async fn worker(rx: &mut Receiver<Option<ExpiryOpType>>, api: Arc<ECStore>) {
+        loop {
+            select! {
+                _ = tokio::signal::ctrl_c() => {
+                    info!("got ctrl+c, exits");
+                    break;
+                }
+                v = rx.recv() => {
+                    if v.is_none() {
+                        break;
+                    }
+                    let v = v.expect("err!");
+                    if v.is_none() {
+                        //rx.close();
+                        //drop(rx);
+                        let _ = rx;
+                        return;
+                    }
+                    let v = v.expect("err!");
+                    if v.as_any().is::<ExpiryTask>() {
+                        let v = v.as_any().downcast_ref::<ExpiryTask>().expect("err!");
+                        if v.obj_info.transitioned_object.status != "" {
+                            apply_expiry_on_transitioned_object(api.clone(), &v.obj_info, &v.event, &v.src).await;
+                        } else {
+                            apply_expiry_on_non_transitioned_objects(api.clone(), &v.obj_info, &v.event, &v.src).await;
+                        }
+                    }
+                    else if v.as_any().is::<NewerNoncurrentTask>() {
+                        let _v = v.as_any().downcast_ref::<NewerNoncurrentTask>().expect("err!");
+                        //delete_object_versions(api, &v.bucket, &v.versions, v.event).await;
+                    }
+                    else if v.as_any().is::<Jentry>() {
+                        //transitionLogIf(es.ctx, deleteObjectFromRemoteTier(es.ctx, v.ObjName, v.VersionID, v.TierName))
+                    }
+                    else if v.as_any().is::<FreeVersionTask>() {
+                        let v = v.as_any().downcast_ref::<FreeVersionTask>().expect("err!");
+                        let _oi = v.0.clone();
+
+                    }
+                    else {
+                        //info!("Invalid work type - {:?}", v);
+                        todo!();
+                    }
+                }
+            }
+        }
+    }
+}
+
+struct TransitionTask {
+    obj_info: ObjectInfo,
+    src: LcEventSrc,
+    event: lifecycle::Event,
+}
+
+impl ExpiryOp for TransitionTask {
+    fn op_hash(&self) -> u64 {
+        let mut hasher = Sha256::new();
+        let _ = hasher.write(format!("{}", self.obj_info.bucket).as_bytes());
+        //let _ = hasher.write(format!("{}", self.obj_info.versions[0].object_name).as_bytes());
+        hasher.flush();
+        xxh64::xxh64(hasher.clone().finalize().as_slice(), XXHASH_SEED)
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+pub struct TransitionState {
+    transition_tx: A_Sender<Option<TransitionTask>>,
+    transition_rx: A_Receiver<Option<TransitionTask>>,
+    pub num_workers: AtomicI64,
+    kill_tx: A_Sender<()>,
+    kill_rx: A_Receiver<()>,
+    active_tasks: AtomicI64,
+    missed_immediate_tasks: AtomicI64,
+    last_day_stats: Arc<Mutex<HashMap<String, LastDayTierStats>>>,
+}
+
+impl TransitionState {
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new() -> Arc<Self> {
+        let (tx1, rx1) = bounded(100000);
+        let (tx2, rx2) = bounded(1);
+        Arc::new(Self {
+            transition_tx: tx1,
+            transition_rx: rx1,
+            num_workers: AtomicI64::new(0),
+            kill_tx: tx2,
+            kill_rx: rx2,
+            active_tasks: AtomicI64::new(0),
+            missed_immediate_tasks: AtomicI64::new(0),
+            last_day_stats: Arc::new(Mutex::new(HashMap::new())),
+        })
+    }
+
+    pub async fn queue_transition_task(&self, oi: &ObjectInfo, event: &lifecycle::Event, src: &LcEventSrc) {
+        let task = TransitionTask {
+            obj_info: oi.clone(),
+            src: src.clone(),
+            event: event.clone(),
+        };
+        select! {
+            //_ -> t.ctx.Done() => (),
+            _ = self.transition_tx.send(Some(task)) => (),
+            else => {
+                match src {
+                    LcEventSrc::S3PutObject | LcEventSrc::S3CopyObject | LcEventSrc::S3CompleteMultipartUpload => {
+                        self.missed_immediate_tasks.fetch_add(1, Ordering::SeqCst);
+                    }
+                    _ => ()
+                }
+            },
+        }
+    }
+
+    pub async fn init(api: Arc<ECStore>) {
+        let mut n = 10; //globalAPIConfig.getTransitionWorkers();
+        let tw = 10; //globalILMConfig.getTransitionWorkers(); 
+        if tw > 0 {
+            n = tw;
+        }
+
+        //let mut transition_state = GLOBAL_TransitionState.write().await;
+        //self.objAPI = objAPI
+        Self::update_workers(api, n).await;
+    }
+
+    pub fn pending_tasks(&self) -> usize {
+        //let transition_rx = GLOBAL_TransitionState.transition_rx.lock().unwrap();
+        let transition_rx = &GLOBAL_TransitionState.transition_rx;
+        transition_rx.len()
+    }
+
+    pub fn active_tasks(&self) -> i64 {
+        self.active_tasks.load(Ordering::SeqCst)
+    }
+
+    pub fn missed_immediate_tasks(&self) -> i64 {
+        self.missed_immediate_tasks.load(Ordering::SeqCst)
+    }
+
+    pub async fn worker(api: Arc<ECStore>) {
+        loop {
+            select! {
+                _ = GLOBAL_TransitionState.kill_rx.recv() => {
+                    return;
+                }
+                task = GLOBAL_TransitionState.transition_rx.recv() => {
+                    if task.is_err() {
+                        break;
+                    }
+                    let task = task.expect("err!");
+                    if task.is_none() {
+                        //self.transition_rx.close();
+                        //drop(self.transition_rx);
+                        return;
+                    }
+                    let task = task.expect("err!");
+                    if task.as_any().is::<TransitionTask>() {
+                        let task = task.as_any().downcast_ref::<TransitionTask>().expect("err!");
+
+                        GLOBAL_TransitionState.active_tasks.fetch_add(1, Ordering::SeqCst);
+                        if let Err(err) = transition_object(api.clone(), &task.obj_info, LcAuditEvent::new(task.event.clone(), task.src.clone())).await {
+                            if !is_err_version_not_found(&err) && !is_err_object_not_found(&err) && !is_network_or_host_down(&err.to_string(), false) && !err.to_string().contains("use of closed network connection") {
+                                error!("Transition to {} failed for {}/{} version:{} with {}",
+                                    task.event.storage_class, task.obj_info.bucket, task.obj_info.name, task.obj_info.version_id.expect("err"), err.to_string());
+                            }
+                        } else {
+                            let mut ts = TierStats {
+                                total_size: task.obj_info.size as u64,
+                                num_versions: 1,
+                                ..Default::default()
+                            };
+                            if task.obj_info.is_latest {
+                                ts.num_objects = 1;
+                            }
+                            GLOBAL_TransitionState.add_lastday_stats(&task.event.storage_class, ts);
+                        }
+                        GLOBAL_TransitionState.active_tasks.fetch_add(-1, Ordering::SeqCst);
+                    }
+                }
+                else => ()
+            }
+        }
+    }
+
+    pub fn add_lastday_stats(&self, tier: &str, ts: TierStats) {
+        let mut tier_stats = self.last_day_stats.lock().unwrap();
+        tier_stats
+            .entry(tier.to_string())
+            .and_modify(|e| e.add_stats(ts))
+            .or_insert(LastDayTierStats::default());
+    }
+
+    pub fn get_daily_all_tier_stats(&self) -> DailyAllTierStats {
+        let tier_stats = self.last_day_stats.lock().unwrap();
+        let mut res = DailyAllTierStats::with_capacity(tier_stats.len());
+        for (tier, st) in tier_stats.iter() {
+            res.insert(tier.clone(), st.clone());
+        }
+        res
+    }
+
+    pub async fn update_workers(api: Arc<ECStore>, n: i64) {
+        Self::update_workers_inner(api, n).await;
+    }
+
+    pub async fn update_workers_inner(api: Arc<ECStore>, n: i64) {
+        let mut n = n;
+        if n == 0 {
+            n = 100;
+        }
+
+        let mut num_workers = GLOBAL_TransitionState.num_workers.load(Ordering::SeqCst);
+        while num_workers < n {
+            let clone_api = api.clone();
+            tokio::spawn(async move {
+                TransitionState::worker(clone_api).await;
+            });
+            num_workers = num_workers + 1;
+            GLOBAL_TransitionState.num_workers.fetch_add(1, Ordering::SeqCst);
+        }
+
+        let mut num_workers = GLOBAL_TransitionState.num_workers.load(Ordering::SeqCst);
+        while num_workers > n {
+            let worker = GLOBAL_TransitionState.kill_tx.clone();
+            worker.send(()).await;
+            num_workers = num_workers - 1;
+            GLOBAL_TransitionState.num_workers.fetch_add(-1, Ordering::SeqCst);
+        }
+    }
+}
+
+pub async fn init_background_expiry(api: Arc<ECStore>) {
+    let mut workers = num_cpus::get() / 2;
+    //globalILMConfig.getExpirationWorkers()
+    if let Ok(env_expiration_workers) = env::var("_RUSTFS_EXPIRATION_WORKERS") {
+        if let Ok(num_expirations) = env_expiration_workers.parse::<usize>() {
+            workers = num_expirations;
+        }
+    }
+
+    if workers == 0 {
+        workers = 100;
+    }
+
+    //let expiry_state = GLOBAL_ExpiryStSate.write().await;
+    ExpiryState::resize_workers(workers, api).await;
+}
+
+pub async fn validate_transition_tier(lc: &BucketLifecycleConfiguration) -> Result<(), std::io::Error> {
+    for rule in &lc.rules {
+        if let Some(transitions) = &rule.transitions {
+            for transition in transitions {
+                if let Some(storage_class) = &transition.storage_class {
+                    if storage_class.as_str() != "" {
+                        let valid = GLOBAL_TierConfigMgr.read().await.is_tier_valid(storage_class.as_str());
+                        if !valid {
+                            return Err(std::io::Error::other(ERR_INVALID_STORAGECLASS));
+                        }
+                    }
+                }
+            }
+        }
+        if let Some(noncurrent_version_transitions) = &rule.noncurrent_version_transitions {
+            for noncurrent_version_transition in noncurrent_version_transitions {
+                if let Some(storage_class) = &noncurrent_version_transition.storage_class {
+                    if storage_class.as_str() != "" {
+                        let valid = GLOBAL_TierConfigMgr.read().await.is_tier_valid(storage_class.as_str());
+                        if !valid {
+                            return Err(std::io::Error::other(ERR_INVALID_STORAGECLASS));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+pub async fn enqueue_transition_immediate(oi: &ObjectInfo, src: LcEventSrc) {
+    let lc = GLOBAL_LifecycleSys.get(&oi.bucket).await;
+    if !lc.is_none() {
+        let event = lc.expect("err").eval(&oi.to_lifecycle_opts()).await;
+        match event.action {
+            lifecycle::IlmAction::TransitionAction | lifecycle::IlmAction::TransitionVersionAction => {
+                if oi.delete_marker || oi.is_dir {
+                    return;
+                }
+                GLOBAL_TransitionState.queue_transition_task(oi, &event, &src).await;
+            }
+            _ => (),
+        }
+    }
+}
+
+pub async fn expire_transitioned_object(
+    api: Arc<ECStore>,
+    oi: &ObjectInfo,
+    lc_event: &lifecycle::Event,
+    _src: &LcEventSrc,
+) -> Result<ObjectInfo, std::io::Error> {
+    //let traceFn = GLOBAL_LifecycleSys.trace(oi);
+    let mut opts = ObjectOptions {
+        versioned: BucketVersioningSys::prefix_enabled(&oi.bucket, &oi.name).await,
+        expiration: ExpirationOptions { expire: true },
+        ..Default::default()
+    };
+    if lc_event.action == IlmAction::DeleteVersionAction {
+        opts.version_id = oi.version_id.map(|id| id.to_string());
+    }
+    //let tags = LcAuditEvent::new(src, lcEvent).Tags();
+    if lc_event.action == IlmAction::DeleteRestoredAction {
+        opts.transition.expire_restored = true;
+        match api.delete_object(&oi.bucket, &oi.name, opts).await {
+            Ok(dobj) => {
+                //audit_log_lifecycle(*oi, ILMExpiry, tags, traceFn);
+                return Ok(dobj);
+            }
+            Err(err) => return Err(std::io::Error::other(err)),
+        }
+    }
+
+    let ret = delete_object_from_remote_tier(
+        &oi.transitioned_object.name,
+        &oi.transitioned_object.version_id,
+        &oi.transitioned_object.tier,
+    )
+    .await;
+    if ret.is_ok() {
+        opts.skip_decommissioned = true;
+    } else {
+        //transitionLogIf(ctx, err);
+    }
+
+    let dobj = api.delete_object(&oi.bucket, &oi.name, opts).await?;
+
+    //defer auditLogLifecycle(ctx, *oi, ILMExpiry, tags, traceFn)
+
+    let mut event_name = EventName::ObjectRemovedDelete;
+    if oi.delete_marker {
+        event_name = EventName::ObjectRemovedDeleteMarkerCreated;
+    }
+    let obj_info = ObjectInfo {
+        name: oi.name.clone(),
+        version_id: oi.version_id,
+        delete_marker: oi.delete_marker,
+        ..Default::default()
+    };
+    send_event(EventArgs {
+        event_name: event_name.as_ref().to_string(),
+        bucket_name: obj_info.bucket.clone(),
+        object: obj_info,
+        user_agent: "Internal: [ILM-Expiry]".to_string(),
+        host: GLOBAL_LocalNodeName.to_string(),
+        ..Default::default()
+    });
+    /*let system = match notification_system() {
+        Some(sys) => sys,
+        None => {
+            let config = Config::new();
+            initialize(config).await?;
+            notification_system().expect("Failed to initialize notification system")
+        }
+    };
+    let event = Arc::new(Event::new_test_event("my-bucket", "document.pdf", EventName::ObjectCreatedPut));
+    system.send_event(event).await;*/
+
+    Ok(dobj)
+}
+
+pub fn gen_transition_objname(bucket: &str) -> Result<String, Error> {
+    let us = Uuid::new_v4().to_string();
+    let mut hasher = Sha256::new();
+    let _ = hasher.write(format!("{}/{}", get_global_deployment_id().unwrap_or_default(), bucket).as_bytes());
+    hasher.flush();
+    let hash = rustfs_utils::crypto::hex(hasher.clone().finalize().as_slice());
+    let obj = format!("{}/{}/{}/{}", &hash[0..16], &us[0..2], &us[2..4], &us);
+    Ok(obj)
+}
+
+pub async fn transition_object(api: Arc<ECStore>, oi: &ObjectInfo, lae: LcAuditEvent) -> Result<(), Error> {
+    let time_ilm = ScannerMetrics::time_ilm(lae.event.action);
+
+    let opts = ObjectOptions {
+        transition: TransitionOptions {
+            status: lifecycle::TRANSITION_PENDING.to_string(),
+            tier: lae.event.storage_class,
+            etag: oi.etag.clone().expect("err").to_string(),
+            ..Default::default()
+        },
+        //lifecycle_audit_event: lae,
+        version_id: Some(oi.version_id.expect("err").to_string()),
+        versioned: BucketVersioningSys::prefix_enabled(&oi.bucket, &oi.name).await,
+        version_suspended: BucketVersioningSys::prefix_suspended(&oi.bucket, &oi.name).await,
+        mod_time: oi.mod_time,
+        ..Default::default()
+    };
+    time_ilm(1);
+    api.transition_object(&oi.bucket, &oi.name, &opts).await
+}
+
+pub fn audit_tier_actions(_api: ECStore, _tier: &str, _bytes: i64) -> TimeFn {
+    todo!();
+}
+
+pub async fn get_transitioned_object_reader(
+    bucket: &str,
+    object: &str,
+    rs: HTTPRangeSpec,
+    h: HeaderMap,
+    oi: ObjectInfo,
+    opts: &ObjectOptions,
+) -> Result<GetObjectReader, std::io::Error> {
+    let mut tier_config_mgr = GLOBAL_TierConfigMgr.write().await;
+    let tgt_client = match tier_config_mgr.get_driver(&oi.transitioned_object.tier).await {
+        Ok(d) => d,
+        Err(err) => return Err(std::io::Error::other(err)),
+    };
+
+    let ret = new_getobjectreader(rs, &oi, opts, &h);
+    if let Err(err) = ret {
+        return Err(error_resp_to_object_err(err, vec![bucket, object]));
+    }
+    let (get_fn, off, length) = ret.expect("err");
+    let mut gopts = WarmBackendGetOpts::default();
+
+    if off >= 0 && length >= 0 {
+        gopts.start_offset = off;
+        gopts.length = length;
+    }
+
+    //return Ok(HttpFileReader::new(rs, &oi, opts, &h));
+    //timeTierAction := auditTierActions(oi.transitioned_object.Tier, length)
+    let reader = tgt_client
+        .get(&oi.transitioned_object.name, &oi.transitioned_object.version_id, gopts)
+        .await?;
+    Ok(get_fn(reader, h))
+}
+
+pub fn post_restore_opts(_r: http::Request<Body>, _bucket: &str, _object: &str) -> Result<ObjectOptions, std::io::Error> {
+    todo!();
+}
+
+pub fn put_restore_opts(_bucket: &str, _object: &str, _rreq: &RestoreObjectRequest, _oi: &ObjectInfo) -> ObjectOptions {
+    todo!();
+}
+
+pub trait LifecycleOps {
+    fn to_lifecycle_opts(&self) -> lifecycle::ObjectOpts;
+}
+
+impl LifecycleOps for ObjectInfo {
+    fn to_lifecycle_opts(&self) -> lifecycle::ObjectOpts {
+        lifecycle::ObjectOpts {
+            name: self.name.clone(),
+            user_tags: self.user_tags.clone(),
+            version_id: self.version_id.expect("err").to_string(),
+            mod_time: self.mod_time,
+            size: self.size as usize,
+            is_latest: self.is_latest,
+            num_versions: self.num_versions,
+            delete_marker: self.delete_marker,
+            successor_mod_time: self.successor_mod_time,
+            //restore_ongoing:    self.restore_ongoing,
+            //restore_expires:    self.restore_expires,
+            transition_status: self.transitioned_object.status.clone(),
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct S3Location {
+    pub bucketname: String,
+    //pub encryption:    Encryption,
+    pub prefix: String,
+    pub storage_class: String,
+    //pub tagging:       Tags,
+    pub user_metadata: HashMap<String, String>,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct OutputLocation(pub S3Location);
+
+#[derive(Debug, Default, Clone)]
+pub struct RestoreObjectRequest {
+    pub days: i64,
+    pub ror_type: String,
+    pub tier: String,
+    pub description: String,
+    //pub select_parameters: SelectParameters,
+    pub output_location: OutputLocation,
+}
+
+const _MAX_RESTORE_OBJECT_REQUEST_SIZE: i64 = 2 << 20;

crates/ecstore/src/bucket/lifecycle/lifecycle.rs

@@ -0,0 +1,729 @@
+#![allow(unused_imports)]
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
+use s3s::dto::{
+    BucketLifecycleConfiguration, ExpirationStatus, LifecycleExpiration, LifecycleRule, NoncurrentVersionTransition,
+    ObjectLockConfiguration, ObjectLockEnabled, Transition,
+};
+use std::cmp::Ordering;
+use std::env;
+use std::fmt::Display;
+use time::macros::{datetime, offset};
+use time::{self, Duration, OffsetDateTime};
+
+use crate::bucket::lifecycle::rule::TransitionOps;
+
+use super::bucket_lifecycle_ops::RestoreObjectRequest;
+
+pub const TRANSITION_COMPLETE: &str = "complete";
+pub const TRANSITION_PENDING: &str = "pending";
+
+const ERR_LIFECYCLE_TOO_MANY_RULES: &str = "Lifecycle configuration allows a maximum of 1000 rules";
+const ERR_LIFECYCLE_NO_RULE: &str = "Lifecycle configuration should have at least one rule";
+const ERR_LIFECYCLE_DUPLICATE_ID: &str = "Rule ID must be unique. Found same ID for more than one rule";
+const _ERR_XML_NOT_WELL_FORMED: &str =
+    "The XML you provided was not well-formed or did not validate against our published schema";
+const ERR_LIFECYCLE_BUCKET_LOCKED: &str =
+    "ExpiredObjectAllVersions element and DelMarkerExpiration action cannot be used on an object locked bucket";
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum IlmAction {
+    NoneAction = 0,
+    DeleteAction,
+    DeleteVersionAction,
+    TransitionAction,
+    TransitionVersionAction,
+    DeleteRestoredAction,
+    DeleteRestoredVersionAction,
+    DeleteAllVersionsAction,
+    DelMarkerDeleteAllVersionsAction,
+    ActionCount,
+}
+
+impl IlmAction {
+    pub fn delete_restored(&self) -> bool {
+        *self == Self::DeleteRestoredAction || *self == Self::DeleteRestoredVersionAction
+    }
+
+    pub fn delete_versioned(&self) -> bool {
+        *self == Self::DeleteVersionAction || *self == Self::DeleteRestoredVersionAction
+    }
+
+    pub fn delete_all(&self) -> bool {
+        *self == Self::DeleteAllVersionsAction || *self == Self::DelMarkerDeleteAllVersionsAction
+    }
+
+    pub fn delete(&self) -> bool {
+        if self.delete_restored() {
+            return true;
+        }
+        *self == Self::DeleteVersionAction
+            || *self == Self::DeleteAction
+            || *self == Self::DeleteAllVersionsAction
+            || *self == Self::DelMarkerDeleteAllVersionsAction
+    }
+}
+
+impl Display for IlmAction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+#[async_trait::async_trait]
+pub trait RuleValidate {
+    fn validate(&self) -> Result<(), std::io::Error>;
+}
+
+#[async_trait::async_trait]
+impl RuleValidate for LifecycleRule {
+    /*fn validate_id(&self) -> Result<()> {
+        if self.id.len() > 255 {
+            return errInvalidRuleID;
+        }
+        Ok(())
+    }
+
+    fn validate_status(&self) -> Result<()> {
+        if self.Status.len() == 0 {
+            return errEmptyRuleStatus;
+        }
+
+        if self.Status != Enabled && self.Status != Disabled {
+            return errInvalidRuleStatus;
+        }
+        Ok(())
+    }
+
+    fn validate_expiration(&self) -> Result<()> {
+        self.Expiration.Validate();
+    }
+
+    fn validate_noncurrent_expiration(&self) -> Result<()> {
+        self.NoncurrentVersionExpiration.Validate()
+    }
+
+    fn validate_prefix_and_filter(&self) -> Result<()> {
+        if !self.Prefix.set && self.Filter.IsEmpty() || self.Prefix.set && !self.Filter.IsEmpty() {
+            return errXMLNotWellFormed;
+        }
+        if !self.Prefix.set {
+            return self.Filter.Validate();
+        }
+        Ok(())
+    }
+
+    fn validate_transition(&self) -> Result<()> {
+        self.Transition.Validate()
+    }
+
+    fn validate_noncurrent_transition(&self) -> Result<()> {
+        self.NoncurrentVersionTransition.Validate()
+    }
+
+    fn get_prefix(&self) -> String {
+        if p := self.Prefix.String(); p != "" {
+          return p
+        }
+        if p := self.Filter.Prefix.String(); p != "" {
+          return p
+        }
+        if p := self.Filter.And.Prefix.String(); p != "" {
+          return p
+        }
+        "".to_string()
+    }*/
+
+    fn validate(&self) -> Result<(), std::io::Error> {
+        /*self.validate_id()?;
+        self.validate_status()?;
+        self.validate_expiration()?;
+        self.validate_noncurrent_expiration()?;
+        self.validate_prefix_and_filter()?;
+        self.validate_transition()?;
+        self.validate_noncurrent_transition()?;
+        if (!self.Filter.Tag.IsEmpty() || len(self.Filter.And.Tags) != 0) && !self.delmarker_expiration.Empty() {
+          return errInvalidRuleDelMarkerExpiration
+        }
+        if !self.expiration.set && !self.transition.set && !self.noncurrent_version_expiration.set && !self.noncurrent_version_transitions.unwrap()[0].set && self.delmarker_expiration.Empty() {
+          return errXMLNotWellFormed
+        }*/
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+pub trait Lifecycle {
+    async fn has_transition(&self) -> bool;
+    fn has_expiry(&self) -> bool;
+    async fn has_active_rules(&self, prefix: &str) -> bool;
+    async fn validate(&self, lr_retention: bool) -> Result<(), std::io::Error>;
+    async fn filter_rules(&self, obj: &ObjectOpts) -> Option<Vec<LifecycleRule>>;
+    async fn eval(&self, obj: &ObjectOpts) -> Event;
+    async fn eval_inner(&self, obj: &ObjectOpts, now: OffsetDateTime) -> Event;
+    //fn set_prediction_headers(&self, w: http.ResponseWriter, obj: ObjectOpts);
+    async fn noncurrent_versions_expiration_limit(&self, obj: &ObjectOpts) -> Event;
+}
+
+#[async_trait::async_trait]
+impl Lifecycle for BucketLifecycleConfiguration {
+    async fn has_transition(&self) -> bool {
+        for rule in self.rules.iter() {
+            if !rule.transitions.is_none() {
+                return true;
+            }
+        }
+        false
+    }
+
+    fn has_expiry(&self) -> bool {
+        for rule in self.rules.iter() {
+            if !rule.expiration.is_none() || !rule.noncurrent_version_expiration.is_none() {
+                return true;
+            }
+        }
+        false
+    }
+
+    async fn has_active_rules(&self, prefix: &str) -> bool {
+        if self.rules.len() == 0 {
+            return false;
+        }
+        for rule in self.rules.iter() {
+            if rule.status.as_str() == ExpirationStatus::DISABLED {
+                continue;
+            }
+
+            let rule_prefix = rule.prefix.as_ref().expect("err!");
+            if prefix.len() > 0 && rule_prefix.len() > 0 && !prefix.starts_with(rule_prefix) && !rule_prefix.starts_with(&prefix)
+            {
+                continue;
+            }
+
+            let rule_noncurrent_version_expiration = rule.noncurrent_version_expiration.as_ref().expect("err!");
+            if rule_noncurrent_version_expiration.noncurrent_days.expect("err!") > 0 {
+                return true;
+            }
+            if rule_noncurrent_version_expiration.newer_noncurrent_versions.expect("err!") > 0 {
+                return true;
+            }
+            if !rule.noncurrent_version_transitions.is_none() {
+                return true;
+            }
+            let rule_expiration = rule.expiration.as_ref().expect("err!");
+            if !rule_expiration.date.is_none()
+                && OffsetDateTime::from(rule_expiration.date.clone().expect("err!")).unix_timestamp()
+                    < OffsetDateTime::now_utc().unix_timestamp()
+            {
+                return true;
+            }
+            if !rule_expiration.date.is_none() {
+                return true;
+            }
+            if rule_expiration.expired_object_delete_marker.expect("err!") {
+                return true;
+            }
+            let rule_transitions: &[Transition] = &rule.transitions.as_ref().expect("err!");
+            let rule_transitions_0 = rule_transitions[0].clone();
+            if !rule_transitions_0.date.is_none()
+                && OffsetDateTime::from(rule_transitions_0.date.expect("err!")).unix_timestamp()
+                    < OffsetDateTime::now_utc().unix_timestamp()
+            {
+                return true;
+            }
+            if !rule.transitions.is_none() {
+                return true;
+            }
+        }
+        false
+    }
+
+    async fn validate(&self, lr_retention: bool) -> Result<(), std::io::Error> {
+        if self.rules.len() > 1000 {
+            return Err(std::io::Error::other(ERR_LIFECYCLE_TOO_MANY_RULES));
+        }
+        if self.rules.len() == 0 {
+            return Err(std::io::Error::other(ERR_LIFECYCLE_NO_RULE));
+        }
+
+        for r in &self.rules {
+            r.validate()?;
+            if let Some(expiration) = r.expiration.as_ref() {
+                if let Some(expired_object_delete_marker) = expiration.expired_object_delete_marker {
+                    if lr_retention && (!expired_object_delete_marker) {
+                        return Err(std::io::Error::other(ERR_LIFECYCLE_BUCKET_LOCKED));
+                    }
+                }
+            }
+        }
+        for (i, _) in self.rules.iter().enumerate() {
+            if i == self.rules.len() - 1 {
+                break;
+            }
+            let other_rules = &self.rules[i + 1..];
+            for other_rule in other_rules {
+                if self.rules[i].id == other_rule.id {
+                    return Err(std::io::Error::other(ERR_LIFECYCLE_DUPLICATE_ID));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    async fn filter_rules(&self, obj: &ObjectOpts) -> Option<Vec<LifecycleRule>> {
+        if obj.name == "" {
+            return None;
+        }
+        let mut rules = Vec::<LifecycleRule>::new();
+        for rule in self.rules.iter() {
+            if rule.status.as_str() == ExpirationStatus::DISABLED {
+                continue;
+            }
+            if let Some(prefix) = rule.prefix.clone() {
+                if !obj.name.starts_with(prefix.as_str()) {
+                    continue;
+                }
+            }
+            /*if !rule.filter.test_tags(obj.user_tags) {
+                continue;
+            }*/
+            //if !obj.delete_marker && !rule.filter.BySize(obj.size) {
+            if !obj.delete_marker && false {
+                continue;
+            }
+            rules.push(rule.clone());
+        }
+        Some(rules)
+    }
+
+    async fn eval(&self, obj: &ObjectOpts) -> Event {
+        self.eval_inner(obj, OffsetDateTime::now_utc()).await
+    }
+
+    async fn eval_inner(&self, obj: &ObjectOpts, now: OffsetDateTime) -> Event {
+        let mut events = Vec::<Event>::new();
+        if obj.mod_time.expect("err").unix_timestamp() == 0 {
+            return Event::default();
+        }
+
+        if let Some(restore_expires) = obj.restore_expires {
+            if !restore_expires.unix_timestamp() == 0 && now.unix_timestamp() > restore_expires.unix_timestamp() {
+                let mut action = IlmAction::DeleteRestoredAction;
+                if !obj.is_latest {
+                    action = IlmAction::DeleteRestoredVersionAction;
+                }
+
+                events.push(Event {
+                    action,
+                    due: Some(now),
+                    rule_id: "".into(),
+                    noncurrent_days: 0,
+                    newer_noncurrent_versions: 0,
+                    storage_class: "".into(),
+                });
+            }
+        }
+
+        if let Some(ref lc_rules) = self.filter_rules(obj).await {
+            for rule in lc_rules.iter() {
+                if obj.expired_object_deletemarker() {
+                    if let Some(expiration) = rule.expiration.as_ref() {
+                        if let Some(expired_object_delete_marker) = expiration.expired_object_delete_marker {
+                            events.push(Event {
+                                action: IlmAction::DeleteVersionAction,
+                                rule_id: rule.id.clone().expect("err!"),
+                                due: Some(now),
+                                noncurrent_days: 0,
+                                newer_noncurrent_versions: 0,
+                                storage_class: "".into(),
+                            });
+                            break;
+                        }
+                    }
+
+                    if let Some(expiration) = rule.expiration.as_ref() {
+                        if let Some(days) = expiration.days {
+                            let expected_expiry = expected_expiry_time(obj.mod_time.expect("err!"), days /*, date*/);
+                            if now.unix_timestamp() == 0 || now.unix_timestamp() > expected_expiry.unix_timestamp() {
+                                events.push(Event {
+                                    action: IlmAction::DeleteVersionAction,
+                                    rule_id: rule.id.clone().expect("err!"),
+                                    due: Some(expected_expiry),
+                                    noncurrent_days: 0,
+                                    newer_noncurrent_versions: 0,
+                                    storage_class: "".into(),
+                                });
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                if obj.is_latest {
+                    if let Some(ref expiration) = rule.expiration {
+                        if let Some(expired_object_delete_marker) = expiration.expired_object_delete_marker {
+                            if obj.delete_marker && expired_object_delete_marker {
+                                let due = expiration.next_due(obj);
+                                if let Some(due) = due {
+                                    if now.unix_timestamp() == 0 || now.unix_timestamp() > due.unix_timestamp() {
+                                        events.push(Event {
+                                            action: IlmAction::DelMarkerDeleteAllVersionsAction,
+                                            rule_id: rule.id.clone().expect("err!"),
+                                            due: Some(due),
+                                            noncurrent_days: 0,
+                                            newer_noncurrent_versions: 0,
+                                            storage_class: "".into(),
+                                        });
+                                    }
+                                }
+                                continue;
+                            }
+                        }
+                    }
+                }
+
+                if !obj.is_latest {
+                    if let Some(ref noncurrent_version_expiration) = rule.noncurrent_version_expiration {
+                        if let Some(newer_noncurrent_versions) = noncurrent_version_expiration.newer_noncurrent_versions {
+                            if newer_noncurrent_versions > 0 {
+                                continue;
+                            }
+                        }
+                    }
+                }
+
+                if !obj.is_latest {
+                    if let Some(ref noncurrent_version_expiration) = rule.noncurrent_version_expiration {
+                        if let Some(noncurrent_days) = noncurrent_version_expiration.noncurrent_days {
+                            if noncurrent_days != 0 {
+                                if let Some(successor_mod_time) = obj.successor_mod_time {
+                                    let expected_expiry = expected_expiry_time(successor_mod_time, noncurrent_days);
+                                    if now.unix_timestamp() == 0 || now.unix_timestamp() > expected_expiry.unix_timestamp() {
+                                        events.push(Event {
+                                            action: IlmAction::DeleteVersionAction,
+                                            rule_id: rule.id.clone().expect("err!"),
+                                            due: Some(expected_expiry),
+                                            noncurrent_days: 0,
+                                            newer_noncurrent_versions: 0,
+                                            storage_class: "".into(),
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if !obj.is_latest {
+                    if let Some(ref noncurrent_version_transitions) = rule.noncurrent_version_transitions {
+                        if let Some(ref storage_class) = noncurrent_version_transitions[0].storage_class {
+                            if storage_class.as_str() != "" && !obj.delete_marker && obj.transition_status != TRANSITION_COMPLETE
+                            {
+                                let due = rule.noncurrent_version_transitions.as_ref().unwrap()[0].next_due(obj);
+                                if due.is_some()
+                                    && (now.unix_timestamp() == 0 || now.unix_timestamp() > due.unwrap().unix_timestamp())
+                                {
+                                    events.push(Event {
+                                        action: IlmAction::TransitionVersionAction,
+                                        rule_id: rule.id.clone().expect("err!"),
+                                        due,
+                                        storage_class: rule.noncurrent_version_transitions.as_ref().unwrap()[0]
+                                            .storage_class
+                                            .clone()
+                                            .unwrap()
+                                            .as_str()
+                                            .to_string(),
+                                        ..Default::default()
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if obj.is_latest && !obj.delete_marker {
+                    if let Some(ref expiration) = rule.expiration {
+                        if let Some(ref date) = expiration.date {
+                            let date0 = OffsetDateTime::from(date.clone());
+                            if date0.unix_timestamp() != 0
+                                && (now.unix_timestamp() == 0 || now.unix_timestamp() > date0.unix_timestamp())
+                            {
+                                events.push(Event {
+                                    action: IlmAction::DeleteAction,
+                                    rule_id: rule.id.clone().expect("err!"),
+                                    due: Some(date0),
+                                    noncurrent_days: 0,
+                                    newer_noncurrent_versions: 0,
+                                    storage_class: "".into(),
+                                });
+                            }
+                        } else if let Some(days) = expiration.days {
+                            if days != 0 {
+                                let expected_expiry: OffsetDateTime = expected_expiry_time(obj.mod_time.expect("err!"), days);
+                                if now.unix_timestamp() == 0 || now.unix_timestamp() > expected_expiry.unix_timestamp() {
+                                    let mut event = Event {
+                                        action: IlmAction::DeleteAction,
+                                        rule_id: rule.id.clone().expect("err!"),
+                                        due: Some(expected_expiry),
+                                        noncurrent_days: 0,
+                                        newer_noncurrent_versions: 0,
+                                        storage_class: "".into(),
+                                    };
+                                    /*if rule.expiration.expect("err!").delete_all.val {
+                                        event.action = IlmAction::DeleteAllVersionsAction
+                                    }*/
+                                    events.push(event);
+                                }
+                            }
+                        }
+                    }
+
+                    if obj.transition_status != TRANSITION_COMPLETE {
+                        if let Some(ref transitions) = rule.transitions {
+                            let due = transitions[0].next_due(obj);
+                            if let Some(due) = due {
+                                if due.unix_timestamp() > 0
+                                    && (now.unix_timestamp() == 0 || now.unix_timestamp() > due.unix_timestamp())
+                                {
+                                    events.push(Event {
+                                        action: IlmAction::TransitionAction,
+                                        rule_id: rule.id.clone().expect("err!"),
+                                        due: Some(due),
+                                        storage_class: transitions[0].storage_class.clone().expect("err!").as_str().to_string(),
+                                        noncurrent_days: 0,
+                                        newer_noncurrent_versions: 0,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if events.len() > 0 {
+            events.sort_by(|a, b| {
+                if now.unix_timestamp() > a.due.expect("err!").unix_timestamp()
+                    && now.unix_timestamp() > b.due.expect("err").unix_timestamp()
+                    || a.due.expect("err").unix_timestamp() == b.due.expect("err").unix_timestamp()
+                {
+                    match a.action {
+                        IlmAction::DeleteAllVersionsAction
+                        | IlmAction::DelMarkerDeleteAllVersionsAction
+                        | IlmAction::DeleteAction
+                        | IlmAction::DeleteVersionAction => {
+                            return Ordering::Less;
+                        }
+                        _ => (),
+                    }
+                    match b.action {
+                        IlmAction::DeleteAllVersionsAction
+                        | IlmAction::DelMarkerDeleteAllVersionsAction
+                        | IlmAction::DeleteAction
+                        | IlmAction::DeleteVersionAction => {
+                            return Ordering::Greater;
+                        }
+                        _ => (),
+                    }
+                    return Ordering::Less;
+                }
+
+                if a.due.expect("err").unix_timestamp() < b.due.expect("err").unix_timestamp() {
+                    return Ordering::Less;
+                }
+                return Ordering::Greater;
+            });
+            return events[0].clone();
+        }
+
+        Event::default()
+    }
+
+    async fn noncurrent_versions_expiration_limit(&self, obj: &ObjectOpts) -> Event {
+        if let Some(filter_rules) = self.filter_rules(obj).await {
+            for rule in filter_rules.iter() {
+                if let Some(ref noncurrent_version_expiration) = rule.noncurrent_version_expiration {
+                    if let Some(newer_noncurrent_versions) = noncurrent_version_expiration.newer_noncurrent_versions {
+                        if newer_noncurrent_versions == 0 {
+                            continue;
+                        }
+                        return Event {
+                            action: IlmAction::DeleteVersionAction,
+                            rule_id: rule.id.clone().expect("err"),
+                            noncurrent_days: noncurrent_version_expiration.noncurrent_days.expect("noncurrent_days err.") as u32,
+                            newer_noncurrent_versions: newer_noncurrent_versions as usize,
+                            due: Some(OffsetDateTime::UNIX_EPOCH),
+                            storage_class: "".into(),
+                        };
+                    } else {
+                        return Event {
+                            action: IlmAction::DeleteVersionAction,
+                            rule_id: rule.id.clone().expect("err"),
+                            noncurrent_days: noncurrent_version_expiration.noncurrent_days.expect("noncurrent_days err.") as u32,
+                            newer_noncurrent_versions: 0,
+                            due: Some(OffsetDateTime::UNIX_EPOCH),
+                            storage_class: "".into(),
+                        };
+                    }
+                }
+            }
+        }
+        Event::default()
+    }
+}
+
+#[async_trait::async_trait]
+pub trait LifecycleCalculate {
+    fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime>;
+}
+
+#[async_trait::async_trait]
+impl LifecycleCalculate for LifecycleExpiration {
+    fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime> {
+        if !obj.is_latest || !obj.delete_marker {
+            return None;
+        }
+
+        Some(expected_expiry_time(obj.mod_time.unwrap(), self.days.unwrap()))
+    }
+}
+
+#[async_trait::async_trait]
+impl LifecycleCalculate for NoncurrentVersionTransition {
+    fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime> {
+        if obj.is_latest || self.storage_class.is_none() {
+            return None;
+        }
+        if self.noncurrent_days.is_none() {
+            return obj.successor_mod_time;
+        }
+        Some(expected_expiry_time(obj.successor_mod_time.unwrap(), self.noncurrent_days.unwrap()))
+    }
+}
+
+#[async_trait::async_trait]
+impl LifecycleCalculate for Transition {
+    fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime> {
+        if !obj.is_latest || self.days.is_none() {
+            return None;
+        }
+
+        if let Some(date) = self.date.clone() {
+            return Some(date.into());
+        }
+
+        if self.days.is_none() {
+            return obj.mod_time;
+        }
+        Some(expected_expiry_time(obj.mod_time.unwrap(), self.days.unwrap()))
+    }
+}
+
+pub fn expected_expiry_time(mod_time: OffsetDateTime, days: i32) -> OffsetDateTime {
+    if days == 0 {
+        return mod_time;
+    }
+    let t = mod_time
+        .to_offset(offset!(-0:00:00))
+        .saturating_add(Duration::days(0 /*days as i64*/)); //debug
+    let mut hour = 3600;
+    if let Ok(env_ilm_hour) = env::var("_RUSTFS_ILM_HOUR") {
+        if let Ok(num_hour) = env_ilm_hour.parse::<usize>() {
+            hour = num_hour;
+        }
+    }
+    //t.Truncate(24 * hour)
+    t
+}
+
+#[derive(Default)]
+pub struct ObjectOpts {
+    pub name: String,
+    pub user_tags: String,
+    pub mod_time: Option<OffsetDateTime>,
+    pub size: usize,
+    pub version_id: String,
+    pub is_latest: bool,
+    pub delete_marker: bool,
+    pub num_versions: usize,
+    pub successor_mod_time: Option<OffsetDateTime>,
+    pub transition_status: String,
+    pub restore_ongoing: bool,
+    pub restore_expires: Option<OffsetDateTime>,
+    pub versioned: bool,
+    pub version_suspended: bool,
+}
+
+impl ObjectOpts {
+    pub fn expired_object_deletemarker(&self) -> bool {
+        self.delete_marker && self.num_versions == 1
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Event {
+    pub action: IlmAction,
+    pub rule_id: String,
+    pub due: Option<OffsetDateTime>,
+    pub noncurrent_days: u32,
+    pub newer_noncurrent_versions: usize,
+    pub storage_class: String,
+}
+
+impl Default for Event {
+    fn default() -> Self {
+        Self {
+            action: IlmAction::NoneAction,
+            rule_id: "".into(),
+            due: Some(OffsetDateTime::UNIX_EPOCH),
+            noncurrent_days: 0,
+            newer_noncurrent_versions: 0,
+            storage_class: "".into(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ExpirationOptions {
+    pub expire: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct TransitionOptions {
+    pub status: String,
+    pub tier: String,
+    pub etag: String,
+    pub restore_request: RestoreObjectRequest,
+    pub restore_expiry: OffsetDateTime,
+    pub expire_restored: bool,
+}
+
+impl Default for TransitionOptions {
+    fn default() -> Self {
+        Self {
+            status: Default::default(),
+            tier: Default::default(),
+            etag: Default::default(),
+            restore_request: Default::default(),
+            restore_expiry: OffsetDateTime::now_utc(),
+            expire_restored: Default::default(),
+        }
+    }
+}

crates/ecstore/src/bucket/lifecycle/mod.rs

@@ -0,0 +1,20 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub mod bucket_lifecycle_audit;
+pub mod bucket_lifecycle_ops;
+pub mod lifecycle;
+pub mod rule;
+pub mod tier_last_day_stats;
+pub mod tier_sweeper;

crates/ecstore/src/bucket/lifecycle/rule.rs

@@ -0,0 +1,69 @@
+#![allow(unused_imports)]
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
+use s3s::dto::{LifecycleRuleFilter, Transition};
+
+const _ERR_TRANSITION_INVALID_DAYS: &str = "Days must be 0 or greater when used with Transition";
+const _ERR_TRANSITION_INVALID_DATE: &str = "Date must be provided in ISO 8601 format";
+const ERR_TRANSITION_INVALID: &str =
+    "Exactly one of Days (0 or greater) or Date (positive ISO 8601 format) should be present in Transition.";
+const _ERR_TRANSITION_DATE_NOT_MIDNIGHT: &str = "'Date' must be at midnight GMT";
+
+pub trait Filter {
+    fn test_tags(&self, user_tags: &str) -> bool;
+    fn by_size(&self, sz: i64) -> bool;
+}
+
+impl Filter for LifecycleRuleFilter {
+    fn test_tags(&self, user_tags: &str) -> bool {
+        true
+    }
+
+    fn by_size(&self, sz: i64) -> bool {
+        true
+    }
+}
+
+pub trait TransitionOps {
+    fn validate(&self) -> Result<(), std::io::Error>;
+}
+
+impl TransitionOps for Transition {
+    fn validate(&self) -> Result<(), std::io::Error> {
+        if !self.date.is_none() && self.days.expect("err!") > 0 {
+            return Err(std::io::Error::other(ERR_TRANSITION_INVALID));
+        }
+
+        if self.storage_class.is_none() {
+            return Err(std::io::Error::other("ERR_XML_NOT_WELL_FORMED"));
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_rule() {
+        //assert!(skip_access_checks(p.to_str().unwrap()));
+    }
+}

crates/ecstore/src/bucket/lifecycle/tier_last_day_stats.rs

@@ -0,0 +1,104 @@
+#![allow(unused_imports)]
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
+use sha2::Sha256;
+
+use std::collections::HashMap;
+use std::ops::Sub;
+use time::OffsetDateTime;
+use tracing::{error, warn};
+
+use crate::heal::data_usage_cache::TierStats;
+
+pub type DailyAllTierStats = HashMap<String, LastDayTierStats>;
+
+#[derive(Clone)]
+pub struct LastDayTierStats {
+    bins: [TierStats; 24],
+    updated_at: OffsetDateTime,
+}
+
+impl Default for LastDayTierStats {
+    fn default() -> Self {
+        Self {
+            bins: Default::default(),
+            updated_at: OffsetDateTime::now_utc(),
+        }
+    }
+}
+
+impl LastDayTierStats {
+    pub fn add_stats(&mut self, ts: TierStats) {
+        let mut now = OffsetDateTime::now_utc();
+        self.forward_to(&mut now);
+
+        let now_idx = now.hour() as usize;
+        self.bins[now_idx] = self.bins[now_idx].add(&ts);
+    }
+
+    fn forward_to(&mut self, t: &mut OffsetDateTime) {
+        if t.unix_timestamp() == 0 {
+            *t = OffsetDateTime::now_utc();
+        }
+
+        let since = t.sub(self.updated_at).whole_hours();
+        if since < 1 {
+            return;
+        }
+
+        let (idx, mut last_idx) = (t.hour(), self.updated_at.hour());
+
+        self.updated_at = *t;
+
+        if since >= 24 {
+            self.bins = [TierStats::default(); 24];
+            return;
+        }
+
+        while last_idx != idx {
+            last_idx = (last_idx + 1) % 24;
+            self.bins[last_idx as usize] = TierStats::default();
+        }
+    }
+
+    #[allow(dead_code)]
+    fn merge(&self, m: LastDayTierStats) -> LastDayTierStats {
+        let mut cl = self.clone();
+        let mut cm = m.clone();
+        let mut merged = LastDayTierStats::default();
+
+        if cl.updated_at.unix_timestamp() > cm.updated_at.unix_timestamp() {
+            cm.forward_to(&mut cl.updated_at);
+            merged.updated_at = cl.updated_at;
+        } else {
+            cl.forward_to(&mut cm.updated_at);
+            merged.updated_at = cm.updated_at;
+        }
+
+        for (i, _) in cl.bins.iter().enumerate() {
+            merged.bins[i] = cl.bins[i].add(&cm.bins[i]);
+        }
+
+        merged
+    }
+}
+
+#[cfg(test)]
+mod test {}

crates/ecstore/src/bucket/lifecycle/tier_sweeper.rs

@@ -0,0 +1,152 @@
+#![allow(unused_imports)]
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
+use sha2::{Digest, Sha256};
+use std::any::Any;
+use std::io::{Cursor, Write};
+use xxhash_rust::xxh64;
+
+use super::bucket_lifecycle_ops::{ExpiryOp, GLOBAL_ExpiryState, TransitionedObject};
+use super::lifecycle::{self, ObjectOpts};
+use crate::global::GLOBAL_TierConfigMgr;
+
+static XXHASH_SEED: u64 = 0;
+
+#[derive(Default)]
+#[allow(dead_code)]
+struct ObjSweeper {
+    object: String,
+    bucket: String,
+    version_id: String,
+    versioned: bool,
+    suspended: bool,
+    transition_status: String,
+    transition_tier: String,
+    transition_version_id: String,
+    remote_object: String,
+}
+
+#[allow(dead_code)]
+impl ObjSweeper {
+    #[allow(clippy::new_ret_no_self)]
+    pub async fn new(bucket: &str, object: &str) -> Result<Self, std::io::Error> {
+        Ok(Self {
+            object: object.into(),
+            bucket: bucket.into(),
+            ..Default::default()
+        })
+    }
+
+    pub fn with_version(&mut self, vid: String) -> &Self {
+        self.version_id = vid;
+        self
+    }
+
+    pub fn with_versioning(&mut self, versioned: bool, suspended: bool) -> &Self {
+        self.versioned = versioned;
+        self.suspended = suspended;
+        self
+    }
+
+    pub fn get_opts(&self) -> lifecycle::ObjectOpts {
+        let mut opts = ObjectOpts {
+            version_id: self.version_id.clone(),
+            versioned: self.versioned,
+            version_suspended: self.suspended,
+            ..Default::default()
+        };
+        if self.suspended && self.version_id == "" {
+            opts.version_id = String::from("");
+        }
+        opts
+    }
+
+    pub fn set_transition_state(&mut self, info: TransitionedObject) {
+        self.transition_tier = info.tier;
+        self.transition_status = info.status;
+        self.remote_object = info.name;
+        self.transition_version_id = info.version_id;
+    }
+
+    pub fn should_remove_remote_object(&self) -> Option<Jentry> {
+        if self.transition_status != lifecycle::TRANSITION_COMPLETE {
+            return None;
+        }
+
+        let mut del_tier = false;
+        if !self.versioned || self.suspended {
+            // 1, 2.a, 2.b
+            del_tier = true;
+        } else if self.versioned && self.version_id != "" {
+            // 3.a
+            del_tier = true;
+        }
+        if del_tier {
+            return Some(Jentry {
+                obj_name: self.remote_object.clone(),
+                version_id: self.transition_version_id.clone(),
+                tier_name: self.transition_tier.clone(),
+            });
+        }
+        None
+    }
+
+    pub async fn sweep(&self) {
+        let je = self.should_remove_remote_object();
+        if !je.is_none() {
+            let mut expiry_state = GLOBAL_ExpiryState.write().await;
+            expiry_state.enqueue_tier_journal_entry(&je.expect("err!"));
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+#[allow(unused_assignments)]
+pub struct Jentry {
+    obj_name: String,
+    version_id: String,
+    tier_name: String,
+}
+
+impl ExpiryOp for Jentry {
+    fn op_hash(&self) -> u64 {
+        let mut hasher = Sha256::new();
+        let _ = hasher.write(format!("{}", self.tier_name).as_bytes());
+        let _ = hasher.write(format!("{}", self.obj_name).as_bytes());
+        hasher.flush();
+        xxh64::xxh64(hasher.clone().finalize().as_slice(), XXHASH_SEED)
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+pub async fn delete_object_from_remote_tier(obj_name: &str, rv_id: &str, tier_name: &str) -> Result<(), std::io::Error> {
+    let mut config_mgr = GLOBAL_TierConfigMgr.write().await;
+    let w = match config_mgr.get_driver(tier_name).await {
+        Ok(w) => w,
+        Err(e) => return Err(std::io::Error::other(e)),
+    };
+    w.remove(obj_name, rv_id).await
+}
+
+#[cfg(test)]
+mod test {}

crates/ecstore/src/bucket/metadata.rs

@@ -0,0 +1,454 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::{quota::BucketQuota, target::BucketTargets};
+
+use super::object_lock::ObjectLockApi;
+use super::versioning::VersioningApi;
+use byteorder::{BigEndian, ByteOrder, LittleEndian};
+use rmp_serde::Serializer as rmpSerializer;
+use rustfs_policy::policy::BucketPolicy;
+use s3s::dto::{
+    BucketLifecycleConfiguration, NotificationConfiguration, ObjectLockConfiguration, ReplicationConfiguration,
+    ServerSideEncryptionConfiguration, Tagging, VersioningConfiguration,
+};
+use serde::Serializer;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::Arc;
+use time::OffsetDateTime;
+use tracing::error;
+
+use crate::bucket::target::BucketTarget;
+use crate::bucket::utils::deserialize;
+use crate::config::com::{read_config, save_config};
+use crate::error::{Error, Result};
+use crate::new_object_layer_fn;
+
+use crate::disk::BUCKET_META_PREFIX;
+use crate::store::ECStore;
+
+pub const BUCKET_METADATA_FILE: &str = ".metadata.bin";
+pub const BUCKET_METADATA_FORMAT: u16 = 1;
+pub const BUCKET_METADATA_VERSION: u16 = 1;
+
+pub const BUCKET_POLICY_CONFIG: &str = "policy.json";
+pub const BUCKET_NOTIFICATION_CONFIG: &str = "notification.xml";
+pub const BUCKET_LIFECYCLE_CONFIG: &str = "lifecycle.xml";
+pub const BUCKET_SSECONFIG: &str = "bucket-encryption.xml";
+pub const BUCKET_TAGGING_CONFIG: &str = "tagging.xml";
+pub const BUCKET_QUOTA_CONFIG_FILE: &str = "quota.json";
+pub const OBJECT_LOCK_CONFIG: &str = "object-lock.xml";
+pub const BUCKET_VERSIONING_CONFIG: &str = "versioning.xml";
+pub const BUCKET_REPLICATION_CONFIG: &str = "replication.xml";
+pub const BUCKET_TARGETS_FILE: &str = "bucket-targets.json";
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(rename_all = "PascalCase", default)]
+pub struct BucketMetadata {
+    pub name: String,
+    pub created: OffsetDateTime,
+    pub lock_enabled: bool, // While marked as unused, it may need to be retained
+    pub policy_config_json: Vec<u8>,
+    pub notification_config_xml: Vec<u8>,
+    pub lifecycle_config_xml: Vec<u8>,
+    pub object_lock_config_xml: Vec<u8>,
+    pub versioning_config_xml: Vec<u8>,
+    pub encryption_config_xml: Vec<u8>,
+    pub tagging_config_xml: Vec<u8>,
+    pub quota_config_json: Vec<u8>,
+    pub replication_config_xml: Vec<u8>,
+    pub bucket_targets_config_json: Vec<u8>,
+    pub bucket_targets_config_meta_json: Vec<u8>,
+
+    pub policy_config_updated_at: OffsetDateTime,
+    pub object_lock_config_updated_at: OffsetDateTime,
+    pub encryption_config_updated_at: OffsetDateTime,
+    pub tagging_config_updated_at: OffsetDateTime,
+    pub quota_config_updated_at: OffsetDateTime,
+    pub replication_config_updated_at: OffsetDateTime,
+    pub versioning_config_updated_at: OffsetDateTime,
+    pub lifecycle_config_updated_at: OffsetDateTime,
+    pub notification_config_updated_at: OffsetDateTime,
+    pub bucket_targets_config_updated_at: OffsetDateTime,
+    pub bucket_targets_config_meta_updated_at: OffsetDateTime,
+
+    #[serde(skip)]
+    pub new_field_updated_at: OffsetDateTime,
+
+    #[serde(skip)]
+    pub policy_config: Option<BucketPolicy>,
+    #[serde(skip)]
+    pub notification_config: Option<NotificationConfiguration>,
+    #[serde(skip)]
+    pub lifecycle_config: Option<BucketLifecycleConfiguration>,
+    #[serde(skip)]
+    pub object_lock_config: Option<ObjectLockConfiguration>,
+    #[serde(skip)]
+    pub versioning_config: Option<VersioningConfiguration>,
+    #[serde(skip)]
+    pub sse_config: Option<ServerSideEncryptionConfiguration>,
+    #[serde(skip)]
+    pub tagging_config: Option<Tagging>,
+    #[serde(skip)]
+    pub quota_config: Option<BucketQuota>,
+    #[serde(skip)]
+    pub replication_config: Option<ReplicationConfiguration>,
+    #[serde(skip)]
+    pub bucket_target_config: Option<BucketTargets>,
+    #[serde(skip)]
+    pub bucket_target_config_meta: Option<HashMap<String, String>>,
+}
+
+impl Default for BucketMetadata {
+    fn default() -> Self {
+        Self {
+            name: Default::default(),
+            created: OffsetDateTime::UNIX_EPOCH,
+            lock_enabled: Default::default(),
+            policy_config_json: Default::default(),
+            notification_config_xml: Default::default(),
+            lifecycle_config_xml: Default::default(),
+            object_lock_config_xml: Default::default(),
+            versioning_config_xml: Default::default(),
+            encryption_config_xml: Default::default(),
+            tagging_config_xml: Default::default(),
+            quota_config_json: Default::default(),
+            replication_config_xml: Default::default(),
+            bucket_targets_config_json: Default::default(),
+            bucket_targets_config_meta_json: Default::default(),
+            policy_config_updated_at: OffsetDateTime::UNIX_EPOCH,
+            object_lock_config_updated_at: OffsetDateTime::UNIX_EPOCH,
+            encryption_config_updated_at: OffsetDateTime::UNIX_EPOCH,
+            tagging_config_updated_at: OffsetDateTime::UNIX_EPOCH,
+            quota_config_updated_at: OffsetDateTime::UNIX_EPOCH,
+            replication_config_updated_at: OffsetDateTime::UNIX_EPOCH,
+            versioning_config_updated_at: OffsetDateTime::UNIX_EPOCH,
+            lifecycle_config_updated_at: OffsetDateTime::UNIX_EPOCH,
+            notification_config_updated_at: OffsetDateTime::UNIX_EPOCH,
+            bucket_targets_config_updated_at: OffsetDateTime::UNIX_EPOCH,
+            bucket_targets_config_meta_updated_at: OffsetDateTime::UNIX_EPOCH,
+            new_field_updated_at: OffsetDateTime::UNIX_EPOCH,
+            policy_config: Default::default(),
+            notification_config: Default::default(),
+            lifecycle_config: Default::default(),
+            object_lock_config: Default::default(),
+            versioning_config: Default::default(),
+            sse_config: Default::default(),
+            tagging_config: Default::default(),
+            quota_config: Default::default(),
+            replication_config: Default::default(),
+            bucket_target_config: Default::default(),
+            bucket_target_config_meta: Default::default(),
+        }
+    }
+}
+
+impl BucketMetadata {
+    pub fn new(name: &str) -> Self {
+        BucketMetadata {
+            name: name.to_string(),
+            ..Default::default()
+        }
+    }
+
+    pub fn save_file_path(&self) -> String {
+        format!("{}/{}/{}", BUCKET_META_PREFIX, self.name.as_str(), BUCKET_METADATA_FILE)
+    }
+
+    pub fn versioning(&self) -> bool {
+        self.lock_enabled
+            || (self.object_lock_config.as_ref().is_some_and(|v| v.enabled())
+                || self.versioning_config.as_ref().is_some_and(|v| v.enabled()))
+    }
+
+    pub fn object_locking(&self) -> bool {
+        self.lock_enabled || (self.versioning_config.as_ref().is_some_and(|v| v.enabled()))
+    }
+
+    pub fn marshal_msg(&self) -> Result<Vec<u8>> {
+        let mut buf = Vec::new();
+
+        self.serialize(&mut rmpSerializer::new(&mut buf).with_struct_map())?;
+
+        Ok(buf)
+    }
+
+    pub fn unmarshal(buf: &[u8]) -> Result<Self> {
+        let t: BucketMetadata = rmp_serde::from_slice(buf)?;
+        Ok(t)
+    }
+
+    pub fn check_header(buf: &[u8]) -> Result<()> {
+        if buf.len() <= 4 {
+            return Err(Error::other("read_bucket_metadata: data invalid"));
+        }
+
+        let format = LittleEndian::read_u16(&buf[0..2]);
+        let version = LittleEndian::read_u16(&buf[2..4]);
+
+        match format {
+            BUCKET_METADATA_FORMAT => {}
+            _ => return Err(Error::other("read_bucket_metadata: format invalid")),
+        }
+
+        match version {
+            BUCKET_METADATA_VERSION => {}
+            _ => return Err(Error::other("read_bucket_metadata: version invalid")),
+        }
+
+        Ok(())
+    }
+
+    fn default_timestamps(&mut self) {
+        if self.policy_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.policy_config_updated_at = self.created
+        }
+        if self.encryption_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.encryption_config_updated_at = self.created
+        }
+
+        if self.tagging_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.tagging_config_updated_at = self.created
+        }
+        if self.object_lock_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.object_lock_config_updated_at = self.created
+        }
+        if self.quota_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.quota_config_updated_at = self.created
+        }
+
+        if self.replication_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.replication_config_updated_at = self.created
+        }
+
+        if self.versioning_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.versioning_config_updated_at = self.created
+        }
+
+        if self.lifecycle_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.lifecycle_config_updated_at = self.created
+        }
+        if self.notification_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.notification_config_updated_at = self.created
+        }
+
+        if self.bucket_targets_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.bucket_targets_config_updated_at = self.created
+        }
+        if self.bucket_targets_config_meta_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.bucket_targets_config_meta_updated_at = self.created
+        }
+    }
+
+    pub fn update_config(&mut self, config_file: &str, data: Vec<u8>) -> Result<OffsetDateTime> {
+        let updated = OffsetDateTime::now_utc();
+
+        match config_file {
+            BUCKET_POLICY_CONFIG => {
+                self.policy_config_json = data;
+                self.policy_config_updated_at = updated;
+            }
+            BUCKET_NOTIFICATION_CONFIG => {
+                self.notification_config_xml = data;
+                self.notification_config_updated_at = updated;
+            }
+            BUCKET_LIFECYCLE_CONFIG => {
+                self.lifecycle_config_xml = data;
+                self.lifecycle_config_updated_at = updated;
+            }
+            BUCKET_SSECONFIG => {
+                self.encryption_config_xml = data;
+                self.encryption_config_updated_at = updated;
+            }
+            BUCKET_TAGGING_CONFIG => {
+                self.tagging_config_xml = data;
+                self.tagging_config_updated_at = updated;
+            }
+            BUCKET_QUOTA_CONFIG_FILE => {
+                self.quota_config_json = data;
+                self.quota_config_updated_at = updated;
+            }
+            OBJECT_LOCK_CONFIG => {
+                self.object_lock_config_xml = data;
+                self.object_lock_config_updated_at = updated;
+            }
+            BUCKET_VERSIONING_CONFIG => {
+                self.versioning_config_xml = data;
+                self.versioning_config_updated_at = updated;
+            }
+            BUCKET_REPLICATION_CONFIG => {
+                self.replication_config_xml = data;
+                self.replication_config_updated_at = updated;
+            }
+            BUCKET_TARGETS_FILE => {
+                // let x = data.clone();
+                // let str = std::str::from_utf8(&x).expect("Invalid UTF-8");
+                // println!("update config:{}", str);
+                self.bucket_targets_config_json = data.clone();
+                self.bucket_targets_config_updated_at = updated;
+            }
+            _ => return Err(Error::other(format!("config file not found : {config_file}"))),
+        }
+
+        Ok(updated)
+    }
+
+    pub fn set_created(&mut self, created: Option<OffsetDateTime>) {
+        self.created = created.unwrap_or_else(OffsetDateTime::now_utc)
+    }
+
+    pub async fn save(&mut self) -> Result<()> {
+        let Some(store) = new_object_layer_fn() else {
+            return Err(Error::other("errServerNotInitialized"));
+        };
+
+        self.parse_all_configs(store.clone())?;
+
+        let mut buf: Vec<u8> = vec![0; 4];
+
+        LittleEndian::write_u16(&mut buf[0..2], BUCKET_METADATA_FORMAT);
+
+        LittleEndian::write_u16(&mut buf[2..4], BUCKET_METADATA_VERSION);
+
+        let data = self.marshal_msg()?;
+
+        buf.extend_from_slice(&data);
+
+        save_config(store, self.save_file_path().as_str(), buf).await?;
+
+        Ok(())
+    }
+
+    fn parse_all_configs(&mut self, _api: Arc<ECStore>) -> Result<()> {
+        if !self.policy_config_json.is_empty() {
+            self.policy_config = Some(serde_json::from_slice(&self.policy_config_json)?);
+        }
+        if !self.notification_config_xml.is_empty() {
+            self.notification_config = Some(deserialize::<NotificationConfiguration>(&self.notification_config_xml)?);
+        }
+        if !self.lifecycle_config_xml.is_empty() {
+            self.lifecycle_config = Some(deserialize::<BucketLifecycleConfiguration>(&self.lifecycle_config_xml)?);
+        }
+
+        if !self.object_lock_config_xml.is_empty() {
+            self.object_lock_config = Some(deserialize::<ObjectLockConfiguration>(&self.object_lock_config_xml)?);
+        }
+        if !self.versioning_config_xml.is_empty() {
+            self.versioning_config = Some(deserialize::<VersioningConfiguration>(&self.versioning_config_xml)?);
+        }
+        if !self.encryption_config_xml.is_empty() {
+            self.sse_config = Some(deserialize::<ServerSideEncryptionConfiguration>(&self.encryption_config_xml)?);
+        }
+        if !self.tagging_config_xml.is_empty() {
+            self.tagging_config = Some(deserialize::<Tagging>(&self.tagging_config_xml)?);
+        }
+        if !self.quota_config_json.is_empty() {
+            self.quota_config = Some(BucketQuota::unmarshal(&self.quota_config_json)?);
+        }
+        if !self.replication_config_xml.is_empty() {
+            self.replication_config = Some(deserialize::<ReplicationConfiguration>(&self.replication_config_xml)?);
+        }
+        //let temp = self.bucket_targets_config_json.clone();
+        if !self.bucket_targets_config_json.is_empty() {
+            let arr: Vec<BucketTarget> = serde_json::from_slice(&self.bucket_targets_config_json)?;
+            self.bucket_target_config = Some(BucketTargets { targets: arr });
+        } else {
+            self.bucket_target_config = Some(BucketTargets::default())
+        }
+
+        Ok(())
+    }
+}
+
+pub async fn load_bucket_metadata(api: Arc<ECStore>, bucket: &str) -> Result<BucketMetadata> {
+    load_bucket_metadata_parse(api, bucket, true).await
+}
+
+pub async fn load_bucket_metadata_parse(api: Arc<ECStore>, bucket: &str, parse: bool) -> Result<BucketMetadata> {
+    let mut bm = match read_bucket_metadata(api.clone(), bucket).await {
+        Ok(res) => res,
+        Err(err) => {
+            if err != Error::ConfigNotFound {
+                return Err(err);
+            }
+
+            // info!("bucketmeta {} not found with err {:?}, start to init ", bucket, &err);
+
+            BucketMetadata::new(bucket)
+        }
+    };
+
+    bm.default_timestamps();
+
+    if parse {
+        bm.parse_all_configs(api)?;
+    }
+
+    // TODO: parse_all_configs
+
+    Ok(bm)
+}
+
+async fn read_bucket_metadata(api: Arc<ECStore>, bucket: &str) -> Result<BucketMetadata> {
+    if bucket.is_empty() {
+        error!("bucket name empty");
+        return Err(Error::other("invalid argument"));
+    }
+
+    let bm = BucketMetadata::new(bucket);
+    let file_path = bm.save_file_path();
+
+    let data = read_config(api, &file_path).await?;
+
+    BucketMetadata::check_header(&data)?;
+
+    let bm = BucketMetadata::unmarshal(&data[4..])?;
+
+    Ok(bm)
+}
+
+fn _write_time<S>(t: &OffsetDateTime, s: S) -> std::result::Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let mut buf = vec![0x0; 15];
+
+    let sec = t.unix_timestamp() - 62135596800;
+    let nsec = t.nanosecond();
+    buf[0] = 0xc7; // mext8
+    buf[1] = 0x0c; // 长度
+    buf[2] = 0x05; // 时间扩展类型
+    BigEndian::write_u64(&mut buf[3..], sec as u64);
+    BigEndian::write_u32(&mut buf[11..], nsec);
+    s.serialize_bytes(&buf)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn marshal_msg() {
+        // write_time(OffsetDateTime::UNIX_EPOCH).unwrap();
+
+        let bm = BucketMetadata::new("dada");
+
+        let buf = bm.marshal_msg().unwrap();
+
+        let new = BucketMetadata::unmarshal(&buf).unwrap();
+
+        assert_eq!(bm.name, new.name);
+    }
+}

crates/ecstore/src/bucket/metadata_sys.rs

@@ -0,0 +1,551 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::StorageAPI;
+use crate::bucket::metadata::{BUCKET_LIFECYCLE_CONFIG, load_bucket_metadata_parse};
+use crate::bucket::utils::{deserialize, is_meta_bucketname};
+use crate::cmd::bucket_targets;
+use crate::error::{Error, Result, is_err_bucket_not_found};
+use crate::global::{GLOBAL_Endpoints, is_dist_erasure, is_erasure, new_object_layer_fn};
+use crate::heal::heal_commands::HealOpts;
+use crate::store::ECStore;
+use futures::future::join_all;
+use rustfs_policy::policy::BucketPolicy;
+use s3s::dto::{
+    BucketLifecycleConfiguration, NotificationConfiguration, ObjectLockConfiguration, ReplicationConfiguration,
+    ServerSideEncryptionConfiguration, Tagging, VersioningConfiguration,
+};
+use std::collections::HashSet;
+use std::sync::OnceLock;
+use std::time::Duration;
+use std::{collections::HashMap, sync::Arc};
+use time::OffsetDateTime;
+use tokio::sync::RwLock;
+use tokio::time::sleep;
+use tracing::error;
+
+use super::metadata::{BucketMetadata, load_bucket_metadata};
+use super::quota::BucketQuota;
+use super::target::BucketTargets;
+
+use lazy_static::lazy_static;
+
+lazy_static! {
+    pub static ref GLOBAL_BucketMetadataSys: OnceLock<Arc<RwLock<BucketMetadataSys>>> = OnceLock::new();
+}
+
+pub async fn init_bucket_metadata_sys(api: Arc<ECStore>, buckets: Vec<String>) {
+    let mut sys = BucketMetadataSys::new(api);
+    sys.init(buckets).await;
+
+    let sys = Arc::new(RwLock::new(sys));
+
+    GLOBAL_BucketMetadataSys.set(sys).unwrap();
+}
+
+// panic if not init
+pub(super) fn get_bucket_metadata_sys() -> Result<Arc<RwLock<BucketMetadataSys>>> {
+    if let Some(sys) = GLOBAL_BucketMetadataSys.get() {
+        Ok(sys.clone())
+    } else {
+        Err(Error::other("GLOBAL_BucketMetadataSys not init"))
+    }
+}
+
+pub async fn set_bucket_metadata(bucket: String, bm: BucketMetadata) -> Result<()> {
+    let sys = get_bucket_metadata_sys()?;
+    let lock = sys.write().await;
+    lock.set(bucket, Arc::new(bm)).await;
+    Ok(())
+}
+
+pub async fn get(bucket: &str) -> Result<Arc<BucketMetadata>> {
+    let sys = get_bucket_metadata_sys()?;
+    let lock = sys.read().await;
+    lock.get(bucket).await
+}
+
+pub async fn update(bucket: &str, config_file: &str, data: Vec<u8>) -> Result<OffsetDateTime> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let mut bucket_meta_sys = bucket_meta_sys_lock.write().await;
+
+    bucket_meta_sys.update(bucket, config_file, data).await
+}
+
+pub async fn delete(bucket: &str, config_file: &str) -> Result<OffsetDateTime> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let mut bucket_meta_sys = bucket_meta_sys_lock.write().await;
+
+    bucket_meta_sys.delete(bucket, config_file).await
+}
+
+pub async fn get_bucket_policy(bucket: &str) -> Result<(BucketPolicy, OffsetDateTime)> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_bucket_policy(bucket).await
+}
+
+pub async fn get_quota_config(bucket: &str) -> Result<(BucketQuota, OffsetDateTime)> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_quota_config(bucket).await
+}
+
+pub async fn get_bucket_targets_config(bucket: &str) -> Result<BucketTargets> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_bucket_targets_config(bucket).await
+}
+
+pub async fn get_tagging_config(bucket: &str) -> Result<(Tagging, OffsetDateTime)> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_tagging_config(bucket).await
+}
+
+pub async fn get_lifecycle_config(bucket: &str) -> Result<(BucketLifecycleConfiguration, OffsetDateTime)> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_lifecycle_config(bucket).await
+}
+
+pub async fn get_sse_config(bucket: &str) -> Result<(ServerSideEncryptionConfiguration, OffsetDateTime)> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_sse_config(bucket).await
+}
+
+pub async fn get_object_lock_config(bucket: &str) -> Result<(ObjectLockConfiguration, OffsetDateTime)> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_object_lock_config(bucket).await
+}
+
+pub async fn get_replication_config(bucket: &str) -> Result<(ReplicationConfiguration, OffsetDateTime)> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_replication_config(bucket).await
+}
+
+pub async fn get_notification_config(bucket: &str) -> Result<Option<NotificationConfiguration>> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_notification_config(bucket).await
+}
+
+pub async fn get_versioning_config(bucket: &str) -> Result<(VersioningConfiguration, OffsetDateTime)> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_versioning_config(bucket).await
+}
+
+pub async fn get_config_from_disk(bucket: &str) -> Result<BucketMetadata> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.get_config_from_disk(bucket).await
+}
+
+pub async fn created_at(bucket: &str) -> Result<OffsetDateTime> {
+    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+    let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+    bucket_meta_sys.created_at(bucket).await
+}
+
+#[derive(Debug)]
+pub struct BucketMetadataSys {
+    metadata_map: RwLock<HashMap<String, Arc<BucketMetadata>>>,
+    api: Arc<ECStore>,
+    initialized: RwLock<bool>,
+}
+
+impl BucketMetadataSys {
+    pub fn new(api: Arc<ECStore>) -> Self {
+        Self {
+            metadata_map: RwLock::new(HashMap::new()),
+            api,
+            initialized: RwLock::new(false),
+        }
+    }
+
+    pub async fn init(&mut self, buckets: Vec<String>) {
+        let _ = self.init_internal(buckets).await;
+    }
+    async fn init_internal(&self, buckets: Vec<String>) -> Result<()> {
+        let count = {
+            if let Some(endpoints) = GLOBAL_Endpoints.get() {
+                endpoints.es_count() * 10
+            } else {
+                return Err(Error::other("GLOBAL_Endpoints not init"));
+            }
+        };
+
+        let mut failed_buckets: HashSet<String> = HashSet::new();
+        let mut buckets = buckets.as_slice();
+
+        loop {
+            if buckets.len() < count {
+                self.concurrent_load(buckets, &mut failed_buckets).await;
+                break;
+            }
+
+            self.concurrent_load(&buckets[..count], &mut failed_buckets).await;
+
+            buckets = &buckets[count..]
+        }
+
+        let mut initialized = self.initialized.write().await;
+        *initialized = true;
+
+        if is_dist_erasure().await {
+            // TODO: refresh_buckets_metadata_loop
+        }
+
+        Ok(())
+    }
+
+    async fn concurrent_load(&self, buckets: &[String], failed_buckets: &mut HashSet<String>) {
+        let mut futures = Vec::new();
+
+        for bucket in buckets.iter() {
+            // TODO: HealBucket
+            let api = self.api.clone();
+            let bucket = bucket.clone();
+            futures.push(async move {
+                sleep(Duration::from_millis(30)).await;
+                let _ = api
+                    .heal_bucket(
+                        &bucket,
+                        &HealOpts {
+                            recreate: true,
+                            ..Default::default()
+                        },
+                    )
+                    .await;
+                load_bucket_metadata(self.api.clone(), bucket.as_str()).await
+            });
+        }
+
+        let results = join_all(futures).await;
+
+        let mut idx = 0;
+
+        let mut mp = self.metadata_map.write().await;
+
+        // TODO:EventNotifier,BucketTargetSys
+        for res in results {
+            match res {
+                Ok(res) => {
+                    if let Some(bucket) = buckets.get(idx) {
+                        let x = Arc::new(res);
+                        mp.insert(bucket.clone(), x.clone());
+                        bucket_targets::init_bucket_targets(bucket, x.clone()).await;
+                    }
+                }
+                Err(e) => {
+                    error!("Unable to load bucket metadata, will be retried: {:?}", e);
+                    if let Some(bucket) = buckets.get(idx) {
+                        failed_buckets.insert(bucket.clone());
+                    }
+                }
+            }
+
+            idx += 1;
+        }
+    }
+
+    pub async fn get(&self, bucket: &str) -> Result<Arc<BucketMetadata>> {
+        if is_meta_bucketname(bucket) {
+            return Err(Error::ConfigNotFound);
+        }
+
+        let map = self.metadata_map.read().await;
+        if let Some(bm) = map.get(bucket) {
+            Ok(bm.clone())
+        } else {
+            Err(Error::ConfigNotFound)
+        }
+    }
+
+    pub async fn set(&self, bucket: String, bm: Arc<BucketMetadata>) {
+        if !is_meta_bucketname(&bucket) {
+            let mut map = self.metadata_map.write().await;
+            map.insert(bucket, bm);
+        }
+    }
+
+    async fn _reset(&mut self) {
+        let mut map = self.metadata_map.write().await;
+        map.clear();
+    }
+
+    pub async fn update(&mut self, bucket: &str, config_file: &str, data: Vec<u8>) -> Result<OffsetDateTime> {
+        self.update_and_parse(bucket, config_file, data, true).await
+    }
+
+    pub async fn delete(&mut self, bucket: &str, config_file: &str) -> Result<OffsetDateTime> {
+        if config_file == BUCKET_LIFECYCLE_CONFIG {
+            let meta = match self.get_config_from_disk(bucket).await {
+                Ok(res) => res,
+                Err(err) => {
+                    if err != Error::ConfigNotFound {
+                        return Err(err);
+                    } else {
+                        BucketMetadata::new(bucket)
+                    }
+                }
+            };
+
+            if !meta.lifecycle_config_xml.is_empty() {
+                let cfg = deserialize::<BucketLifecycleConfiguration>(&meta.lifecycle_config_xml)?;
+                // TODO: FIXME:
+                // for _v in cfg.rules.iter() {
+                //     break;
+                // }
+                if let Some(_v) = cfg.rules.first() {}
+            }
+
+            // TODO: other lifecycle handle
+        }
+
+        self.update_and_parse(bucket, config_file, Vec::new(), false).await
+    }
+
+    async fn update_and_parse(&mut self, bucket: &str, config_file: &str, data: Vec<u8>, parse: bool) -> Result<OffsetDateTime> {
+        let Some(store) = new_object_layer_fn() else {
+            return Err(Error::other("errServerNotInitialized"));
+        };
+
+        if is_meta_bucketname(bucket) {
+            return Err(Error::other("errInvalidArgument"));
+        }
+
+        let mut bm = match load_bucket_metadata_parse(store, bucket, parse).await {
+            Ok(res) => res,
+            Err(err) => {
+                if !is_erasure().await && !is_dist_erasure().await && is_err_bucket_not_found(&err) {
+                    BucketMetadata::new(bucket)
+                } else {
+                    return Err(err);
+                }
+            }
+        };
+
+        let updated = bm.update_config(config_file, data)?;
+
+        self.save(bm).await?;
+
+        Ok(updated)
+    }
+
+    async fn save(&self, bm: BucketMetadata) -> Result<()> {
+        if is_meta_bucketname(&bm.name) {
+            return Err(Error::other("errInvalidArgument"));
+        }
+
+        let mut bm = bm;
+
+        bm.save().await?;
+
+        self.set(bm.name.clone(), Arc::new(bm)).await;
+
+        Ok(())
+    }
+
+    pub async fn get_config_from_disk(&self, bucket: &str) -> Result<BucketMetadata> {
+        if is_meta_bucketname(bucket) {
+            return Err(Error::other("errInvalidArgument"));
+        }
+
+        load_bucket_metadata(self.api.clone(), bucket).await
+    }
+
+    pub async fn get_config(&self, bucket: &str) -> Result<(Arc<BucketMetadata>, bool)> {
+        let has_bm = {
+            let map = self.metadata_map.read().await;
+            map.get(&bucket.to_string()).cloned()
+        };
+
+        if let Some(bm) = has_bm {
+            Ok((bm, false))
+        } else {
+            let bm = match load_bucket_metadata(self.api.clone(), bucket).await {
+                Ok(res) => res,
+                Err(err) => {
+                    return if *self.initialized.read().await {
+                        Err(Error::other("errBucketMetadataNotInitialized"))
+                    } else {
+                        Err(err)
+                    };
+                }
+            };
+
+            let mut map = self.metadata_map.write().await;
+
+            let bm = Arc::new(bm);
+            map.insert(bucket.to_string(), bm.clone());
+
+            Ok((bm, true))
+        }
+    }
+
+    pub async fn get_versioning_config(&self, bucket: &str) -> Result<(VersioningConfiguration, OffsetDateTime)> {
+        let bm = match self.get_config(bucket).await {
+            Ok((res, _)) => res,
+            Err(err) => {
+                return if err == Error::ConfigNotFound {
+                    Ok((VersioningConfiguration::default(), OffsetDateTime::UNIX_EPOCH))
+                } else {
+                    Err(err)
+                };
+            }
+        };
+
+        if let Some(config) = &bm.versioning_config {
+            Ok((config.clone(), bm.versioning_config_updated_at))
+        } else {
+            Ok((VersioningConfiguration::default(), bm.versioning_config_updated_at))
+        }
+    }
+
+    pub async fn get_bucket_policy(&self, bucket: &str) -> Result<(BucketPolicy, OffsetDateTime)> {
+        let (bm, _) = self.get_config(bucket).await?;
+
+        if let Some(config) = &bm.policy_config {
+            Ok((config.clone(), bm.policy_config_updated_at))
+        } else {
+            Err(Error::ConfigNotFound)
+        }
+    }
+
+    pub async fn get_tagging_config(&self, bucket: &str) -> Result<(Tagging, OffsetDateTime)> {
+        let (bm, _) = self.get_config(bucket).await?;
+
+        if let Some(config) = &bm.tagging_config {
+            Ok((config.clone(), bm.tagging_config_updated_at))
+        } else {
+            Err(Error::ConfigNotFound)
+        }
+    }
+
+    pub async fn get_object_lock_config(&self, bucket: &str) -> Result<(ObjectLockConfiguration, OffsetDateTime)> {
+        let (bm, _) = self.get_config(bucket).await?;
+
+        if let Some(config) = &bm.object_lock_config {
+            Ok((config.clone(), bm.object_lock_config_updated_at))
+        } else {
+            Err(Error::ConfigNotFound)
+        }
+    }
+
+    pub async fn get_lifecycle_config(&self, bucket: &str) -> Result<(BucketLifecycleConfiguration, OffsetDateTime)> {
+        let (bm, _) = self.get_config(bucket).await?;
+
+        if let Some(config) = &bm.lifecycle_config {
+            if config.rules.is_empty() {
+                Err(Error::ConfigNotFound)
+            } else {
+                Ok((config.clone(), bm.lifecycle_config_updated_at))
+            }
+        } else {
+            Err(Error::ConfigNotFound)
+        }
+    }
+
+    pub async fn get_notification_config(&self, bucket: &str) -> Result<Option<NotificationConfiguration>> {
+        let bm = match self.get_config(bucket).await {
+            Ok((bm, _)) => bm.notification_config.clone(),
+            Err(err) => {
+                if err == Error::ConfigNotFound {
+                    None
+                } else {
+                    return Err(err);
+                }
+            }
+        };
+
+        Ok(bm)
+    }
+
+    pub async fn get_sse_config(&self, bucket: &str) -> Result<(ServerSideEncryptionConfiguration, OffsetDateTime)> {
+        let (bm, _) = self.get_config(bucket).await?;
+
+        if let Some(config) = &bm.sse_config {
+            Ok((config.clone(), bm.encryption_config_updated_at))
+        } else {
+            Err(Error::ConfigNotFound)
+        }
+    }
+
+    pub async fn created_at(&self, bucket: &str) -> Result<OffsetDateTime> {
+        let bm = match self.get_config(bucket).await {
+            Ok((bm, _)) => bm.created,
+            Err(err) => {
+                return Err(err);
+            }
+        };
+
+        Ok(bm)
+    }
+
+    pub async fn get_quota_config(&self, bucket: &str) -> Result<(BucketQuota, OffsetDateTime)> {
+        let (bm, _) = self.get_config(bucket).await?;
+
+        if let Some(config) = &bm.quota_config {
+            Ok((config.clone(), bm.quota_config_updated_at))
+        } else {
+            Err(Error::ConfigNotFound)
+        }
+    }
+
+    pub async fn get_replication_config(&self, bucket: &str) -> Result<(ReplicationConfiguration, OffsetDateTime)> {
+        let (bm, reload) = self.get_config(bucket).await?;
+
+        if let Some(config) = &bm.replication_config {
+            if reload {
+                // TODO: globalBucketTargetSys
+            }
+            //println!("549 {:?}", config.clone());
+            Ok((config.clone(), bm.replication_config_updated_at))
+        } else {
+            Err(Error::ConfigNotFound)
+        }
+    }
+
+    pub async fn get_bucket_targets_config(&self, bucket: &str) -> Result<BucketTargets> {
+        let (bm, reload) = self.get_config(bucket).await?;
+
+        if let Some(config) = &bm.bucket_target_config {
+            if reload {
+                // TODO: globalBucketTargetSys
+                //config.
+            }
+
+            Ok(config.clone())
+        } else {
+            Err(Error::ConfigNotFound)
+        }
+    }
+}

crates/ecstore/src/bucket/mod.rs

@@ -0,0 +1,27 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub mod error;
+pub mod lifecycle;
+pub mod metadata;
+pub mod metadata_sys;
+pub mod object_lock;
+pub mod policy_sys;
+pub mod quota;
+pub mod replication;
+pub mod tagging;
+pub mod target;
+pub mod utils;
+pub mod versioning;
+pub mod versioning_sys;

crates/ecstore/src/bucket/msgpkg.md

@@ -0,0 +1,31 @@
+
+BucketMetadata::new("dada")
+
+```go
+func WriteTime(t time.Time) error {
+    t = t.UTC()
+    o :=0
+    mw.buf[o] =  0xc7 //mext8 // 0xc7
+    mw.buf[o+1] = 12 // 0c
+    mw.buf[o+2] = 0x05 TimeExtension // 05
+    putUnix(mw.buf[o+3:], t.Unix(), int32(t.Nanosecond()))
+    return nil
+}
+
+// 0001-01-01 00:00:00 +0000 UTC == -62135596800 0 (sec() - 62135596800) -62135596800   c70c0b fffffff1886e090000000000 c70c05
+// 2024-10-01 00:00:00 +0000 UTC == 1727740800 0 0 (sec() - 62135596800)
+func putUnix(b []byte, sec int64, nsec int32) {
+    binary.BigEndian.PutUint64(b, uint64(sec))
+    binary.BigEndian.PutUint32(b[8:], uint32(nsec))
+}
+```
+
+# go
+
+de0019a44e616d65a464616461a743726561746564c70c05fffffff1886e090000000000ab4c6f636b456e61626c6564c2b0506f6c696379436f6e6669674a534f4ec400b54e6f74696669636174696f6e436f6e666967584d4cc400b24c6966656379636c65436f6e666967584d4cc400b34f626a6563744c6f636b436f6e666967584d4cc400b356657273696f6e696e67436f6e666967584d4cc400b3456e6372797074696f6e436f6e666967584d4cc400b054616767696e67436f6e666967584d4cc400af51756f7461436f6e6669674a534f4ec400b45265706c69636174696f6e436f6e666967584d4cc400b74275636b657454617267657473436f6e6669674a534f4ec400bb4275636b657454617267657473436f6e6669674d6574614a534f4ec400b5506f6c696379436f6e666967557064617465644174c70c05fffffff1886e090000000000b94f626a6563744c6f636b436f6e666967557064617465644174c70c05fffffff1886e090000000000b9456e6372797074696f6e436f6e666967557064617465644174c70c05fffffff1886e090000000000b654616767696e67436f6e666967557064617465644174c70c05fffffff1886e090000000000b451756f7461436f6e666967557064617465644174c70c05fffffff1886e090000000000ba5265706c69636174696f6e436f6e666967557064617465644174c70c05fffffff1886e090000000000b956657273696f6e696e67436f6e666967557064617465644174c70c05fffffff1886e090000000000b84c6966656379636c65436f6e666967557064617465644174c70c05fffffff1886e090000000000bb4e6f74696669636174696f6e436f6e666967557064617465644174c70c05fffffff1886e090000000000bc4275636b657454617267657473436f6e666967557064617465644174c70c05fffffff1886e090000000000d9204275636b657454617267657473436f6e6669674d657461557064617465644174c70c05fffffff1886e090000000000
+
+de0019a44e616d65a464616461a743726561746564 c40f c70c05fffffff1886e090000000000ab4c6f636b456e61626c6564c2b0506f6c696379436f6e6669674a736f6e90b54e6f74696669636174696f6e436f6e666967586d6c90b24c6966656379636c65436f6e666967586d6c90b34f626a6563744c6f636b436f6e666967586d6c90b356657273696f6e696e67436f6e666967586d6c90b3456e6372797074696f6e436f6e666967586d6c90b054616767696e67436f6e666967586d6c90af51756f7461436f6e6669674a736f6e90b45265706c69636174696f6e436f6e666967586d6c90b74275636b657454617267657473436f6e6669674a736f6e90bb4275636b657454617267657473436f6e6669674d6574614a736f6e90b5506f6c696379436f6e666967557064617465644174c40fc70c05fffffff1886e090000000000b94f626a6563744c6f636b436f6e666967557064617465644174c40fc70c05fffffff1886e090000000000b9456e6372797074696f6e436f6e666967557064617465644174c40fc70c05fffffff1886e090000000000b654616767696e67436f6e666967557064617465644174c40fc70c05fffffff1886e090000000000b451756f7461436f6e666967557064617465644174c40fc70c05fffffff1886e090000000000ba5265706c69636174696f6e436f6e666967557064617465644174c40fc70c05fffffff1886e090000000000b956657273696f6e696e67436f6e666967557064617465644174c40fc70c05fffffff1886e090000000000b84c6966656379636c65436f6e666967557064617465644174c40fc70c05fffffff1886e090000000000bb4e6f74696669636174696f6e436f6e666967557064617465644174c40fc70c05fffffff1886e090000000000bc4275636b657454617267657473436f6e666967557064617465644174c40fc70c05fffffff1886e090000000000d9204275636b657454617267657473436f6e6669674d657461557064617465644174c40fc70c05fffffff1886e090000000000
+
+# rust
+
+de0019a44e616d65 a464616461 a743726561746564 c0 ab4c6f636b456e61626c6564 c2b0506f6c696379436f6e6669674a736f6e90b54e6f74696669636174696f6e436f6e666967586d6c90b24c6966656379636c65436f6e666967586d6c90b34f626a6563744c6f636b436f6e666967586d6c90b356657273696f6e696e67436f6e666967586d6c90b3456e6372797074696f6e436f6e666967586d6c90b054616767696e67436f6e666967586d6c90af51756f7461436f6e6669674a736f6e90b45265706c69636174696f6e436f6e666967586d6c90b74275636b657454617267657473436f6e6669674a736f6e90bb4275636b657454617267657473436f6e6669674d6574614a736f6e90b5506f6c696379436f6e666967557064617465644174c0b94f626a6563744c6f636b436f6e666967557064617465644174c0b9456e6372797074696f6e436f6e666967557064617465644174c0b654616767696e67436f6e666967557064617465644174c0b451756f7461436f6e666967557064617465644174c0ba5265706c69636174696f6e436f6e666967557064617465644174c0b956657273696f6e696e67436f6e666967557064617465644174c0b84c6966656379636c65436f6e666967557064617465644174c0bb4e6f74696669636174696f6e436f6e666967557064617465644174c0bc4275636b657454617267657473436f6e666967557064617465644174c0d9204275636b657454617267657473436f6e6669674d657461557064617465644174c0

crates/ecstore/src/bucket/object_lock/mod.rs

@@ -0,0 +1,30 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub mod objectlock;
+pub mod objectlock_sys;
+
+use s3s::dto::{ObjectLockConfiguration, ObjectLockEnabled};
+
+pub trait ObjectLockApi {
+    fn enabled(&self) -> bool;
+}
+
+impl ObjectLockApi for ObjectLockConfiguration {
+    fn enabled(&self) -> bool {
+        self.object_lock_enabled
+            .as_ref()
+            .is_some_and(|v| v.as_str() == ObjectLockEnabled::ENABLED)
+    }
+}

crates/ecstore/src/bucket/object_lock/objectlock.rs

@@ -0,0 +1,94 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::HashMap;
+use time::{OffsetDateTime, format_description};
+
+use s3s::dto::{Date, ObjectLockLegalHold, ObjectLockLegalHoldStatus, ObjectLockRetention, ObjectLockRetentionMode};
+use s3s::header::{X_AMZ_OBJECT_LOCK_LEGAL_HOLD, X_AMZ_OBJECT_LOCK_MODE, X_AMZ_OBJECT_LOCK_RETAIN_UNTIL_DATE};
+
+const _ERR_MALFORMED_BUCKET_OBJECT_CONFIG: &str = "invalid bucket object lock config";
+const _ERR_INVALID_RETENTION_DATE: &str = "date must be provided in ISO 8601 format";
+const _ERR_PAST_OBJECTLOCK_RETAIN_DATE: &str = "the retain until date must be in the future";
+const _ERR_UNKNOWN_WORMMODE_DIRECTIVE: &str = "unknown WORM mode directive";
+const _ERR_OBJECTLOCK_MISSING_CONTENT_MD5: &str =
+    "content-MD5 HTTP header is required for Put Object requests with Object Lock parameters";
+const _ERR_OBJECTLOCK_INVALID_HEADERS: &str =
+    "x-amz-object-lock-retain-until-date and x-amz-object-lock-mode must both be supplied";
+const _ERR_MALFORMED_XML: &str = "the XML you provided was not well-formed or did not validate against our published schema";
+
+pub fn utc_now_ntp() -> OffsetDateTime {
+    OffsetDateTime::now_utc()
+}
+
+pub fn get_object_retention_meta(meta: HashMap<String, String>) -> ObjectLockRetention {
+    let mut retain_until_date: Date = Date::from(OffsetDateTime::UNIX_EPOCH);
+
+    let mut mode_str = meta.get(X_AMZ_OBJECT_LOCK_MODE.as_str().to_lowercase().as_str());
+    if mode_str.is_none() {
+        mode_str = Some(&meta[X_AMZ_OBJECT_LOCK_MODE.as_str()]);
+    }
+    let mode = if let Some(mode_str) = mode_str {
+        parse_ret_mode(mode_str.as_str())
+    } else {
+        return ObjectLockRetention {
+            mode: None,
+            retain_until_date: None,
+        };
+    };
+
+    let mut till_str = meta.get(X_AMZ_OBJECT_LOCK_RETAIN_UNTIL_DATE.as_str().to_lowercase().as_str());
+    if till_str.is_none() {
+        till_str = Some(&meta[X_AMZ_OBJECT_LOCK_RETAIN_UNTIL_DATE.as_str()]);
+    }
+    if let Some(till_str) = till_str {
+        let t = OffsetDateTime::parse(till_str, &format_description::well_known::Iso8601::DEFAULT);
+        if t.is_err() {
+            retain_until_date = Date::from(t.expect("err")); //TODO: utc
+        }
+    }
+    ObjectLockRetention {
+        mode: Some(mode),
+        retain_until_date: Some(retain_until_date),
+    }
+}
+
+pub fn get_object_legalhold_meta(meta: HashMap<String, String>) -> ObjectLockLegalHold {
+    let mut hold_str = meta.get(X_AMZ_OBJECT_LOCK_LEGAL_HOLD.as_str().to_lowercase().as_str());
+    if hold_str.is_none() {
+        hold_str = Some(&meta[X_AMZ_OBJECT_LOCK_LEGAL_HOLD.as_str()]);
+    }
+    if let Some(hold_str) = hold_str {
+        return ObjectLockLegalHold {
+            status: Some(parse_legalhold_status(hold_str)),
+        };
+    }
+    ObjectLockLegalHold { status: None }
+}
+
+pub fn parse_ret_mode(mode_str: &str) -> ObjectLockRetentionMode {
+    match mode_str.to_uppercase().as_str() {
+        "GOVERNANCE" => ObjectLockRetentionMode::from_static(ObjectLockRetentionMode::GOVERNANCE),
+        "COMPLIANCE" => ObjectLockRetentionMode::from_static(ObjectLockRetentionMode::COMPLIANCE),
+        _ => unreachable!(),
+    }
+}
+
+pub fn parse_legalhold_status(hold_str: &str) -> ObjectLockLegalHoldStatus {
+    match hold_str {
+        "ON" => ObjectLockLegalHoldStatus::from_static(ObjectLockLegalHoldStatus::ON),
+        "OFF" => ObjectLockLegalHoldStatus::from_static(ObjectLockLegalHoldStatus::OFF),
+        _ => unreachable!(),
+    }
+}

crates/ecstore/src/bucket/object_lock/objectlock_sys.rs

@@ -0,0 +1,67 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::Arc;
+use time::OffsetDateTime;
+
+use s3s::dto::{DefaultRetention, ObjectLockLegalHoldStatus, ObjectLockRetentionMode};
+
+use crate::bucket::metadata_sys::get_object_lock_config;
+use crate::store_api::ObjectInfo;
+
+use super::objectlock;
+
+pub struct BucketObjectLockSys {}
+
+impl BucketObjectLockSys {
+    #[allow(clippy::new_ret_no_self)]
+    pub async fn new() -> Arc<Self> {
+        Arc::new(Self {})
+    }
+
+    pub async fn get(bucket: &str) -> Option<DefaultRetention> {
+        if let Ok(object_lock_config) = get_object_lock_config(bucket).await {
+            if let Some(object_lock_rule) = object_lock_config.0.rule {
+                return object_lock_rule.default_retention;
+            }
+        }
+        None
+    }
+}
+
+pub fn enforce_retention_for_deletion(obj_info: &ObjectInfo) -> bool {
+    if obj_info.delete_marker {
+        return false;
+    }
+
+    let lhold = objectlock::get_object_legalhold_meta(obj_info.user_defined.clone());
+    match lhold.status {
+        Some(st) if st.as_str() == ObjectLockLegalHoldStatus::ON => {
+            return true;
+        }
+        _ => (),
+    }
+
+    let ret = objectlock::get_object_retention_meta(obj_info.user_defined.clone());
+    match ret.mode {
+        Some(r) if (r.as_str() == ObjectLockRetentionMode::COMPLIANCE || r.as_str() == ObjectLockRetentionMode::GOVERNANCE) => {
+            let t = objectlock::utc_now_ntp();
+            if OffsetDateTime::from(ret.retain_until_date.expect("err!")).unix_timestamp() > t.unix_timestamp() {
+                return true;
+            }
+        }
+        _ => (),
+    }
+    false
+}

crates/ecstore/src/bucket/policy_sys.rs

@@ -0,0 +1,44 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::{error::BucketMetadataError, metadata_sys::get_bucket_metadata_sys};
+use crate::error::Result;
+use rustfs_policy::policy::{BucketPolicy, BucketPolicyArgs};
+use tracing::warn;
+
+pub struct PolicySys {}
+
+impl PolicySys {
+    pub async fn is_allowed(args: &BucketPolicyArgs<'_>) -> bool {
+        match Self::get(args.bucket).await {
+            Ok(cfg) => return cfg.is_allowed(args),
+            Err(err) => {
+                let berr: BucketMetadataError = err.into();
+                if berr != BucketMetadataError::BucketPolicyNotFound {
+                    warn!("config get err {:?}", berr);
+                }
+            }
+        }
+
+        args.is_owner
+    }
+    pub async fn get(bucket: &str) -> Result<BucketPolicy> {
+        let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+        let bucket_meta_sys = bucket_meta_sys_lock.read().await;
+
+        let (cfg, _) = bucket_meta_sys.get_bucket_policy(bucket).await?;
+
+        Ok(cfg)
+    }
+}

crates/ecstore/src/bucket/quota/mod.rs

@@ -0,0 +1,52 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::error::Result;
+use rmp_serde::Serializer as rmpSerializer;
+use serde::{Deserialize, Serialize};
+
+// 定义 QuotaType 枚举类型
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum QuotaType {
+    Hard,
+}
+
+// 定义 BucketQuota 结构体
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
+pub struct BucketQuota {
+    quota: Option<u64>, // 使用 Option 来表示可能不存在的字段
+
+    size: u64,
+
+    rate: u64,
+
+    requests: u64,
+
+    quota_type: Option<QuotaType>,
+}
+
+impl BucketQuota {
+    pub fn marshal_msg(&self) -> Result<Vec<u8>> {
+        let mut buf = Vec::new();
+
+        self.serialize(&mut rmpSerializer::new(&mut buf).with_struct_map())?;
+
+        Ok(buf)
+    }
+
+    pub fn unmarshal(buf: &[u8]) -> Result<Self> {
+        let t: BucketQuota = rmp_serde::from_slice(buf)?;
+        Ok(t)
+    }
+}

crates/ecstore/src/bucket/replication/datatypes.rs

@@ -0,0 +1,41 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Replication status type for x-amz-replication-status header
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum StatusType {
+    Pending,
+    Completed,
+    CompletedLegacy,
+    Failed,
+    Replica,
+}
+
+impl StatusType {
+    // Converts the enum variant to its string representation
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            StatusType::Pending => "PENDING",
+            StatusType::Completed => "COMPLETED",
+            StatusType::CompletedLegacy => "COMPLETE",
+            StatusType::Failed => "FAILED",
+            StatusType::Replica => "REPLICA",
+        }
+    }
+
+    // Checks if the status is empty (not set)
+    pub fn is_empty(&self) -> bool {
+        matches!(self, StatusType::Pending) // Adjust this as needed
+    }
+}

crates/ecstore/src/bucket/replication/mod.rs

@@ -0,0 +1,15 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub mod datatypes;

crates/ecstore/src/bucket/tagging/mod.rs

@@ -0,0 +1,48 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use s3s::dto::Tag;
+use url::form_urlencoded;
+
+pub fn decode_tags(tags: &str) -> Vec<Tag> {
+    let values = form_urlencoded::parse(tags.as_bytes());
+
+    let mut list = Vec::new();
+
+    for (k, v) in values {
+        if k.is_empty() || v.is_empty() {
+            continue;
+        }
+
+        list.push(Tag {
+            key: Some(k.to_string()),
+            value: Some(v.to_string()),
+        });
+    }
+
+    list
+}
+
+pub fn encode_tags(tags: Vec<Tag>) -> String {
+    let mut encoded = form_urlencoded::Serializer::new(String::new());
+
+    for tag in tags.iter() {
+        if let (Some(k), Some(v)) = (tag.key.as_ref(), tag.value.as_ref()) {
+            //encoded.append_pair(k.as_ref().unwrap().as_str(), v.as_ref().unwrap().as_str());
+            encoded.append_pair(k.as_str(), v.as_str());
+        }
+    }
+
+    encoded.finish()
+}

crates/ecstore/src/bucket/target/mod.rs

@@ -0,0 +1,135 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::error::Result;
+use rmp_serde::Serializer as rmpSerializer;
+use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
+
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
+pub struct Credentials {
+    #[serde(rename = "accessKey")]
+    pub access_key: String,
+    #[serde(rename = "secretKey")]
+    pub secret_key: String,
+    pub session_token: Option<String>,
+    pub expiration: Option<chrono::DateTime<chrono::Utc>>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
+pub enum ServiceType {
+    #[default]
+    Replication,
+}
+
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
+pub struct LatencyStat {
+    curr: u64, // 当前延迟
+    avg: u64,  // 平均延迟
+    max: u64,  // 最大延迟
+}
+
+// 定义 BucketTarget 结构体
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
+pub struct BucketTarget {
+    #[serde(rename = "sourcebucket")]
+    pub source_bucket: String,
+
+    pub endpoint: String,
+
+    pub credentials: Option<Credentials>,
+    #[serde(rename = "targetbucket")]
+    pub target_bucket: String,
+
+    secure: bool,
+    pub path: Option<String>,
+
+    api: Option<String>,
+
+    pub arn: Option<String>,
+    #[serde(rename = "type")]
+    pub type_: Option<String>,
+
+    pub region: Option<String>,
+
+    bandwidth_limit: Option<i64>,
+
+    #[serde(rename = "replicationSync")]
+    replication_sync: bool,
+
+    storage_class: Option<String>,
+    #[serde(rename = "healthCheckDuration")]
+    health_check_duration: u64,
+    #[serde(rename = "disableProxy")]
+    disable_proxy: bool,
+
+    #[serde(rename = "resetBeforeDate")]
+    reset_before_date: String,
+    reset_id: Option<String>,
+    #[serde(rename = "totalDowntime")]
+    total_downtime: u64,
+
+    last_online: Option<OffsetDateTime>,
+    #[serde(rename = "isOnline")]
+    online: bool,
+
+    latency: Option<LatencyStat>,
+
+    deployment_id: Option<String>,
+
+    edge: bool,
+    #[serde(rename = "edgeSyncBeforeExpiry")]
+    edge_sync_before_expiry: bool,
+}
+
+impl BucketTarget {
+    pub fn is_empty(self) -> bool {
+        //self.target_bucket.is_empty() && self.endpoint.is_empty() && self.arn.is_empty()
+        self.target_bucket.is_empty() && self.endpoint.is_empty() && self.arn.is_none()
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
+pub struct BucketTargets {
+    pub targets: Vec<BucketTarget>,
+}
+
+impl BucketTargets {
+    pub fn marshal_msg(&self) -> Result<Vec<u8>> {
+        let mut buf = Vec::new();
+
+        self.serialize(&mut rmpSerializer::new(&mut buf).with_struct_map())?;
+
+        Ok(buf)
+    }
+
+    pub fn unmarshal(buf: &[u8]) -> Result<Self> {
+        let t: BucketTargets = rmp_serde::from_slice(buf)?;
+        Ok(t)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        if self.targets.is_empty() {
+            return true;
+        }
+
+        for target in &self.targets {
+            if !target.clone().is_empty() {
+                return false;
+            }
+        }
+
+        true
+    }
+}

crates/ecstore/src/bucket/utils.rs

@@ -0,0 +1,115 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::disk::RUSTFS_META_BUCKET;
+use crate::error::{Error, Result};
+use s3s::xml;
+
+pub fn is_meta_bucketname(name: &str) -> bool {
+    name.starts_with(RUSTFS_META_BUCKET)
+}
+
+use regex::Regex;
+
+lazy_static::lazy_static! {
+    static ref VALID_BUCKET_NAME: Regex = Regex::new(r"^[A-Za-z0-9][A-Za-z0-9\.\-\_\:]{1,61}[A-Za-z0-9]$").unwrap();
+    static ref VALID_BUCKET_NAME_STRICT: Regex = Regex::new(r"^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$").unwrap();
+    static ref IP_ADDRESS: Regex = Regex::new(r"^(\d+\.){3}\d+$").unwrap();
+}
+
+pub fn check_bucket_name_common(bucket_name: &str, strict: bool) -> Result<()> {
+    let bucket_name_trimmed = bucket_name.trim();
+
+    if bucket_name_trimmed.is_empty() {
+        return Err(Error::other("Bucket name cannot be empty"));
+    }
+    if bucket_name_trimmed.len() < 3 {
+        return Err(Error::other("Bucket name cannot be shorter than 3 characters"));
+    }
+    if bucket_name_trimmed.len() > 63 {
+        return Err(Error::other("Bucket name cannot be longer than 63 characters"));
+    }
+
+    if bucket_name_trimmed == "rustfs" {
+        return Err(Error::other("Bucket name cannot be rustfs"));
+    }
+
+    if IP_ADDRESS.is_match(bucket_name_trimmed) {
+        return Err(Error::other("Bucket name cannot be an IP address"));
+    }
+    if bucket_name_trimmed.contains("..") || bucket_name_trimmed.contains(".-") || bucket_name_trimmed.contains("-.") {
+        return Err(Error::other("Bucket name contains invalid characters"));
+    }
+    if strict {
+        if !VALID_BUCKET_NAME_STRICT.is_match(bucket_name_trimmed) {
+            return Err(Error::other("Bucket name contains invalid characters"));
+        }
+    } else if !VALID_BUCKET_NAME.is_match(bucket_name_trimmed) {
+        return Err(Error::other("Bucket name contains invalid characters"));
+    }
+    Ok(())
+}
+
+pub fn check_valid_bucket_name(bucket_name: &str) -> Result<()> {
+    check_bucket_name_common(bucket_name, false)
+}
+
+pub fn check_valid_bucket_name_strict(bucket_name: &str) -> Result<()> {
+    check_bucket_name_common(bucket_name, true)
+}
+
+pub fn check_valid_object_name_prefix(object_name: &str) -> Result<()> {
+    if object_name.len() > 1024 {
+        return Err(Error::other("Object name cannot be longer than 1024 characters"));
+    }
+    if !object_name.is_ascii() {
+        return Err(Error::other("Object name with non-UTF-8 strings are not supported"));
+    }
+    Ok(())
+}
+
+pub fn check_valid_object_name(object_name: &str) -> Result<()> {
+    if object_name.trim().is_empty() {
+        return Err(Error::other("Object name cannot be empty"));
+    }
+    check_valid_object_name_prefix(object_name)
+}
+
+pub fn deserialize<T>(input: &[u8]) -> xml::DeResult<T>
+where
+    T: for<'xml> xml::Deserialize<'xml>,
+{
+    let mut d = xml::Deserializer::new(input);
+    let ans = T::deserialize(&mut d)?;
+    d.expect_eof()?;
+    Ok(ans)
+}
+
+pub fn serialize_content<T: xml::SerializeContent>(val: &T) -> xml::SerResult<String> {
+    let mut buf = Vec::with_capacity(256);
+    {
+        let mut ser = xml::Serializer::new(&mut buf);
+        val.serialize_content(&mut ser)?;
+    }
+    Ok(String::from_utf8(buf).unwrap())
+}
+
+pub fn serialize<T: xml::Serialize>(val: &T) -> xml::SerResult<Vec<u8>> {
+    let mut buf = Vec::with_capacity(256);
+    {
+        let mut ser = xml::Serializer::new(&mut buf);
+        val.serialize(&mut ser)?;
+    }
+    Ok(buf)
+}

crates/ecstore/src/bucket/versioning/mod.rs

@@ -0,0 +1,96 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use s3s::dto::{BucketVersioningStatus, VersioningConfiguration};
+
+use rustfs_utils::string::match_simple;
+
+pub trait VersioningApi {
+    fn enabled(&self) -> bool;
+    fn prefix_enabled(&self, prefix: &str) -> bool;
+    fn prefix_suspended(&self, prefix: &str) -> bool;
+    fn versioned(&self, prefix: &str) -> bool;
+    fn suspended(&self) -> bool;
+}
+
+impl VersioningApi for VersioningConfiguration {
+    fn enabled(&self) -> bool {
+        self.status == Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED))
+    }
+    fn prefix_enabled(&self, prefix: &str) -> bool {
+        if self.status != Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)) {
+            return false;
+        }
+
+        if prefix.is_empty() {
+            return true;
+        }
+
+        if let Some(exclude_folders) = self.exclude_folders {
+            if exclude_folders && prefix.ends_with('/') {
+                return false;
+            }
+        }
+
+        if let Some(ref excluded_prefixes) = self.excluded_prefixes {
+            for p in excluded_prefixes.iter() {
+                if let Some(ref sprefix) = p.prefix {
+                    let pattern = format!("{sprefix}*");
+                    if match_simple(&pattern, prefix) {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        true
+    }
+
+    fn prefix_suspended(&self, prefix: &str) -> bool {
+        if self.status == Some(BucketVersioningStatus::from_static(BucketVersioningStatus::SUSPENDED)) {
+            return true;
+        }
+
+        if self.status == Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)) {
+            if prefix.is_empty() {
+                return false;
+            }
+
+            if let Some(exclude_folders) = self.exclude_folders {
+                if exclude_folders && prefix.ends_with('/') {
+                    return true;
+                }
+            }
+
+            if let Some(ref excluded_prefixes) = self.excluded_prefixes {
+                for p in excluded_prefixes.iter() {
+                    if let Some(ref sprefix) = p.prefix {
+                        let pattern = format!("{sprefix}*");
+                        if match_simple(&pattern, prefix) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+
+        false
+    }
+    fn versioned(&self, prefix: &str) -> bool {
+        self.prefix_enabled(prefix) || self.prefix_suspended(prefix)
+    }
+    fn suspended(&self) -> bool {
+        self.status == Some(BucketVersioningStatus::from_static(BucketVersioningStatus::SUSPENDED))
+    }
+}

crates/ecstore/src/bucket/versioning_sys.rs

@@ -0,0 +1,85 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::{metadata_sys::get_bucket_metadata_sys, versioning::VersioningApi};
+use crate::disk::RUSTFS_META_BUCKET;
+use crate::error::Result;
+use s3s::dto::VersioningConfiguration;
+use tracing::warn;
+
+pub struct BucketVersioningSys {}
+
+impl Default for BucketVersioningSys {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl BucketVersioningSys {
+    pub fn new() -> Self {
+        Self {}
+    }
+    pub async fn enabled(bucket: &str) -> bool {
+        match Self::get(bucket).await {
+            Ok(res) => res.enabled(),
+            Err(err) => {
+                warn!("{:?}", err);
+                false
+            }
+        }
+    }
+
+    pub async fn prefix_enabled(bucket: &str, prefix: &str) -> bool {
+        match Self::get(bucket).await {
+            Ok(res) => res.prefix_enabled(prefix),
+            Err(err) => {
+                warn!("{:?}", err);
+                false
+            }
+        }
+    }
+
+    pub async fn suspended(bucket: &str) -> bool {
+        match Self::get(bucket).await {
+            Ok(res) => res.suspended(),
+            Err(err) => {
+                warn!("{:?}", err);
+                false
+            }
+        }
+    }
+
+    pub async fn prefix_suspended(bucket: &str, prefix: &str) -> bool {
+        match Self::get(bucket).await {
+            Ok(res) => res.prefix_suspended(prefix),
+            Err(err) => {
+                warn!("{:?}", err);
+                false
+            }
+        }
+    }
+
+    pub async fn get(bucket: &str) -> Result<VersioningConfiguration> {
+        if bucket == RUSTFS_META_BUCKET || bucket.starts_with(RUSTFS_META_BUCKET) {
+            return Ok(VersioningConfiguration::default());
+        }
+
+        let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
+        let bucket_meta_sys = bucket_meta_sys_lock.write().await;
+
+        let (cfg, _) = bucket_meta_sys.get_versioning_config(bucket).await?;
+
+        Ok(cfg)
+    }
+}