stash

ecstore/src/bucket/encryption/mod.rs

@@ -21,20 +21,20 @@ impl std::str::FromStr for Algorithm {
 }
 
 // 定义EncryptionAction结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct EncryptionAction {
     algorithm: Option<Algorithm>,
     master_key_id: Option<String>,
 }
 
 // 定义Rule结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Rule {
     default_encryption_action: EncryptionAction,
 }
 
 // 定义BucketSSEConfig结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct BucketSSEConfig {
     xml_ns: String,
     xml_name: String,

ecstore/src/bucket/event/mod.rs

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 use name::Name;
 
 // 定义common结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 struct Common {
     pub id: String,
     pub filter: S3Key,
@@ -13,57 +13,57 @@ struct Common {
 }
 
 // 定义Queue结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 struct Queue {
     pub common: Common,
     pub arn: ARN,
 }
 
 // 定义ARN结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct ARN {
     pub target_id: TargetID,
     pub region: String,
 }
 
 // 定义TargetID结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct TargetID {
     pub id: String,
     pub name: String,
 }
 
 // 定义FilterRule结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct FilterRule {
     pub name: String,
     pub value: String,
 }
 
 // 定义FilterRuleList结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct FilterRuleList {
     pub rules: Vec<FilterRule>,
 }
 
 // 定义S3Key结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct S3Key {
     pub rule_list: FilterRuleList,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Lambda {
     arn: String,
 }
 
 // 定义Topic结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Topic {
     arn: String,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Config {
     queue_list: Vec<Queue>,
     lambda_list: Vec<Lambda>,

ecstore/src/bucket/lifecycle/and.rs

@@ -1,6 +1,6 @@
 use super::{prefix::Prefix, tag::Tag};
 use serde::{Deserialize, Serialize};
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct And {
     pub object_size_greater_than: i64,
     pub object_size_less_than: i64,

ecstore/src/bucket/lifecycle/delmarker.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct DelMarkerExpiration {
     pub days: usize,
 }

ecstore/src/bucket/lifecycle/expiration.rs

@@ -3,21 +3,21 @@ use time::OffsetDateTime;
 // ExpirationDays is a type alias to unmarshal Days in Expiration
 pub type ExpirationDays = usize;
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct ExpirationDate(Option<OffsetDateTime>);
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct ExpireDeleteMarker {
     pub marker: Boolean,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Boolean {
     pub val: bool,
     pub set: bool,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Expiration {
     pub days: Option<ExpirationDays>,
     pub date: Option<ExpirationDate>,

ecstore/src/bucket/lifecycle/fileter.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use super::{and::And, prefix::Prefix, tag::Tag};
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Filter {
     pub set: bool,
 

ecstore/src/bucket/lifecycle/lifecycle.rs

@@ -2,7 +2,7 @@ use super::rule::Rule;
 use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Lifecycle {
     pub rules: Vec<Rule>,
     pub expiry_updated_at: Option<OffsetDateTime>,

ecstore/src/bucket/lifecycle/noncurrentversion.rs

@@ -1,14 +1,14 @@
 use super::{expiration::ExpirationDays, transition::TransitionDays};
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct NoncurrentVersionExpiration {
     pub noncurrent_days: ExpirationDays,
     pub newer_noncurrent_versions: usize,
     set: bool,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct NoncurrentVersionTransition {
     pub noncurrent_days: TransitionDays,
     pub storage_class: String,

ecstore/src/bucket/lifecycle/prefix.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Prefix {
     pub val: String,
     pub set: bool,

ecstore/src/bucket/lifecycle/rule.rs

@@ -8,14 +8,14 @@ use super::{
 };
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub enum Status {
     #[default]
     Enabled,
     Disabled,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Rule {
     pub id: String,
     pub status: Status,

ecstore/src/bucket/lifecycle/tag.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Tag {
     pub key: String,
     pub value: String,

ecstore/src/bucket/lifecycle/transition.rs

@@ -3,10 +3,10 @@ use time::OffsetDateTime;
 
 pub type TransitionDays = usize;
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct TransitionDate(Option<OffsetDateTime>);
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Transition {
     pub days: Option<TransitionDays>,
     pub date: Option<TransitionDate>,

ecstore/src/bucket/metadata.rs

@@ -1,32 +1,34 @@
-use byteorder::{BigEndian, ByteOrder};
+use super::{
+    encryption::BucketSSEConfig, event, lifecycle::lifecycle::Lifecycle, objectlock, policy::bucket_policy::BucketPolicy,
+    quota::BucketQuota, replication, tags::Tags, target::BucketTargets, versioning::Versioning,
+};
+use byteorder::{BigEndian, ByteOrder, LittleEndian};
 use rmp_serde::Serializer as rmpSerializer;
 use serde::Serializer;
 use serde::{Deserialize, Deserializer, Serialize};
 use std::collections::HashMap;
 use std::fmt::Display;
 use std::str::FromStr;
-use time::macros::datetime;
 use time::OffsetDateTime;
+use tracing::error;
 
-use super::{
-    encryption::BucketSSEConfig, event, lifecycle::lifecycle::Lifecycle, objectlock, policy::bucket_policy::BucketPolicy,
-    quota::BucketQuota, replication, tags::Tags, target::BucketTargets, versioning::Versioning,
-};
-
-use crate::error::Result;
+use crate::bucket::tags;
+use crate::config::common::{read_config, save_config};
+use crate::config::error::ConfigError;
+use crate::error::{Error, Result};
 
 use crate::disk::BUCKET_META_PREFIX;
-use crate::utils::crypto::hex;
+use crate::store::ECStore;
+use crate::store_api::StorageAPI;
 
 pub const BUCKET_METADATA_FILE: &str = ".metadata.bin";
 pub const BUCKET_METADATA_FORMAT: u16 = 1;
 pub const BUCKET_METADATA_VERSION: u16 = 1;
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 #[serde(rename_all = "PascalCase", default)]
 pub struct BucketMetadata {
     pub name: String,
-    #[serde(serialize_with = "write_times")]
     pub created: OffsetDateTime,
     pub lock_enabled: bool, // 虽然标记为不使用，但可能需要保留
     pub policy_config_json: Vec<u8>,
@@ -41,27 +43,16 @@ pub struct BucketMetadata {
     pub bucket_targets_config_json: Vec<u8>,
     pub bucket_targets_config_meta_json: Vec<u8>,
 
-    #[serde(serialize_with = "write_times")]
     pub policy_config_updated_at: OffsetDateTime,
-    #[serde(serialize_with = "write_times")]
     pub object_lock_config_updated_at: OffsetDateTime,
-    #[serde(serialize_with = "write_times")]
     pub encryption_config_updated_at: OffsetDateTime,
-    #[serde(serialize_with = "write_times")]
     pub tagging_config_updated_at: OffsetDateTime,
-    #[serde(serialize_with = "write_times")]
     pub quota_config_updated_at: OffsetDateTime,
-    #[serde(serialize_with = "write_times")]
     pub replication_config_updated_at: OffsetDateTime,
-    #[serde(serialize_with = "write_times")]
     pub versioning_config_updated_at: OffsetDateTime,
-    #[serde(serialize_with = "write_times")]
     pub lifecycle_config_updated_at: OffsetDateTime,
-    #[serde(serialize_with = "write_times")]
     pub notification_config_updated_at: OffsetDateTime,
-    #[serde(serialize_with = "write_times")]
     pub bucket_targets_config_updated_at: OffsetDateTime,
-    #[serde(serialize_with = "write_times")]
     pub bucket_targets_config_meta_updated_at: OffsetDateTime,
 
     #[serde(skip)]
@@ -147,9 +138,9 @@ impl BucketMetadata {
         format!("{}/{}/{}", BUCKET_META_PREFIX, self.name.as_str(), BUCKET_METADATA_FILE)
     }
 
-    fn msg_size(&self) -> usize {
-        unimplemented!()
-    }
+    // fn msg_size(&self) -> usize {
+    //     unimplemented!()
+    // }
 
     pub fn marshal_msg(&self) -> Result<Vec<u8>> {
         let mut buf = Vec::new();
@@ -159,12 +150,99 @@ impl BucketMetadata {
         Ok(buf)
     }
 
-    pub fn unmarshal(_buf: &[u8]) -> Result<Self> {
-        unimplemented!()
+    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::msg("read_bucket_metadata: data invalid"));
+        }
+
+        // TODO: check version
+        Ok(())
+    }
+
+    fn default_timestamps(&mut self) {
+        if self.tagging_config_updated_at == OffsetDateTime::UNIX_EPOCH {
+            self.tagging_config_updated_at = self.created
+        }
+    }
+
+    async fn save(&mut self, api: &ECStore) -> Result<()> {
+        self.parse_all_configs(api)?;
+
+        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(api, self.save_file_path().as_str(), &buf).await?;
+
+        Ok(())
+    }
+
+    fn parse_all_configs(&mut self, _api: &ECStore) -> Result<()> {
+        if !self.tagging_config_xml.is_empty() {
+            self.tagging_config = Some(tags::Tags::unmarshal(&self.tagging_config_xml)?);
+        }
+
+        Ok(())
     }
 }
 
-fn deserialize_from_str<'de, S, D>(deserializer: D) -> core::result::Result<S, D::Error>
+pub async fn load_bucket_metadata(api: &ECStore, bucket: &str) -> Result<BucketMetadata> {
+    load_bucket_metadata_parse(api, bucket, true).await
+}
+
+async fn load_bucket_metadata_parse(api: &ECStore, bucket: &str, parse: bool) -> Result<BucketMetadata> {
+    let mut bm = match read_bucket_metadata(api, bucket).await {
+        Ok(res) => res,
+        Err(err) => {
+            if let Some(e) = err.downcast_ref::<ConfigError>() {
+                if !ConfigError::is_not_found(&e) {
+                    return Err(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: &ECStore, bucket: &str) -> Result<BucketMetadata> {
+    if bucket.is_empty() {
+        error!("bucket name empty");
+        return Err(Error::msg("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)?;
+
+    BucketMetadata::unmarshal(&data[4..])
+}
+
+fn _deserialize_from_str<'de, S, D>(deserializer: D) -> core::result::Result<S, D::Error>
 where
     S: FromStr,
     S::Err: Display,
@@ -175,7 +253,7 @@ where
     unimplemented!()
 }
 
-fn write_times<S>(t: &OffsetDateTime, s: S) -> Result<S::Ok, S::Error>
+fn _write_time<S>(t: &OffsetDateTime, s: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
 {
@@ -183,47 +261,16 @@ where
 
     let sec = t.unix_timestamp() - 62135596800;
     let nsec = t.nanosecond();
-    buf[0] = 0xc7;
-    buf[1] = 0x0c;
-    buf[2] = 0x05;
+    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 as u32);
     s.serialize_bytes(&buf)
 }
 
-fn write_time(t: OffsetDateTime) -> Result<(), String> {
-    // let t = t.saturating_sub(0); // 转换为自 UNIX_EPOCH 以来的时间
-    println!("t:{:?}", t);
-    println!("offset:{:?}", datetime!(0-01-01 0:00 UTC));
-
-    let mut buf = vec![0x0; 15];
-
-    let sec = t.unix_timestamp() - 62135596800;
-    let nsec = t.nanosecond();
-
-    println!("sec:{:?}", sec);
-    println!("nsec:{:?}", nsec);
-
-    buf[0] = 0xc7;
-    buf[1] = 0x0c;
-    buf[2] = 0x05;
-    // 扩展格式的时间类型
-    // buf.push(0xc7); // mext8
-    // buf.push(12); // 长度
-    // buf.push(0x05); // 时间扩展类型
-
-    // 将 Unix 时间戳和纳秒部分写入缓冲区
-    BigEndian::write_u64(&mut buf[3..], sec as u64);
-    BigEndian::write_u32(&mut buf[11..], nsec as u32);
-
-    println!("hex:{:?}", hex(buf));
-
-    Ok(())
-}
-
 #[cfg(test)]
 mod test {
-    use crate::utils::crypto::hex;
 
     use super::*;
 
@@ -235,6 +282,8 @@ mod test {
 
         let buf = bm.marshal_msg().unwrap();
 
-        println!("{:?}", hex(buf))
+        let new = BucketMetadata::unmarshal(&buf).unwrap();
+
+        assert_eq!(bm.name, new.name);
     }
 }

ecstore/src/bucket/metadata_sys.rs

@@ -0,0 +1,82 @@
+use std::{collections::HashMap, sync::Arc};
+
+use crate::error::{Error, Result};
+use crate::store::ECStore;
+use lazy_static::lazy_static;
+use time::OffsetDateTime;
+use tokio::sync::RwLock;
+
+use super::metadata::{load_bucket_metadata, BucketMetadata};
+use super::tags;
+
+lazy_static! {
+    pub static ref GLOBAL_BucketMetadataSys: Arc<Option<BucketMetadataSys>> = Arc::new(Some(BucketMetadataSys::new()));
+}
+
+pub fn get_bucket_metadata_sys() -> Arc<Option<BucketMetadataSys>> {
+    GLOBAL_BucketMetadataSys.clone()
+}
+
+#[derive(Debug, Default)]
+pub struct BucketMetadataSys {
+    metadata_map: RwLock<HashMap<String, BucketMetadata>>,
+    api: Option<Arc<ECStore>>,
+    initialized: RwLock<bool>,
+}
+
+impl BucketMetadataSys {
+    fn new() -> Self {
+        Self { ..Default::default() }
+    }
+
+    pub fn init(&mut self, api: Arc<ECStore>, buckets: Vec<String>) {
+        self.api = Some(api);
+
+        unimplemented!()
+    }
+
+    async fn reset(&mut self) {
+        let mut map = self.metadata_map.write().await;
+        map.clear();
+    }
+
+    pub async fn get_config(&self, bucket: String) -> Result<(BucketMetadata, bool)> {
+        if let Some(api) = self.api.as_ref() {
+            let has_bm = {
+                let map = self.metadata_map.read().await;
+                if let Some(bm) = map.get(&bucket) {
+                    Some(bm.clone())
+                } else {
+                    None
+                }
+            };
+
+            if let Some(bm) = has_bm {
+                return Ok((bm, false));
+            } else {
+                let bm = match load_bucket_metadata(&api, bucket.as_str()).await {
+                    Ok(res) => res,
+                    Err(err) => {
+                        if *self.initialized.read().await {
+                            return Err(Error::msg("errBucketMetadataNotInitialized"));
+                        } else {
+                            return Err(err);
+                        }
+                    }
+                };
+
+                let mut map = self.metadata_map.write().await;
+
+                map.insert(bucket, bm.clone());
+
+                Ok((bm, true))
+            }
+        } else {
+            Err(Error::msg("errBucketMetadataNotInitialized"))
+        }
+    }
+
+    pub async fn get_tagging_config(&self, bucket: String) -> Result<(tags::Tags, Option<OffsetDateTime>)> {
+        unimplemented!()
+    }
+}

ecstore/src/bucket/mod.rs

@@ -1,7 +1,8 @@
 mod encryption;
 mod event;
 mod lifecycle;
-mod metadata;
+pub mod metadata;
+mod metadata_sys;
 mod objectlock;
 mod policy;
 mod quota;
@@ -10,4 +11,4 @@ mod tags;
 mod target;
 mod versioning;
 
-pub use metadata::BucketMetadata;
+pub use metadata_sys::get_bucket_metadata_sys;

ecstore/src/bucket/objectlock/mod.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize, Default, PartialEq, Eq, Hash)]
+#[derive(Debug, Deserialize, Serialize, Default, PartialEq, Eq, Hash, Clone)]
 pub enum RetMode {
     #[default]
     Govenance,
@@ -20,19 +20,19 @@ impl std::str::FromStr for RetMode {
     }
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct DefaultRetention {
     pub mode: RetMode,
     pub days: Option<usize>,
     pub years: Option<usize>,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct Rule {
     pub default_retention: DefaultRetention,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct Config {
     pub object_lock_enabled: String,
     pub rule: Option<Rule>,

ecstore/src/bucket/policy/action.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct ActionSet(HashSet<Action>);
 
 impl ActionSet {}

ecstore/src/bucket/policy/bucket_policy.rs

@@ -9,7 +9,7 @@ use super::{
     resource::ResourceSet,
 };
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct BucketPolicyArgs {
     account_name: String,
     groups: Vec<String>,
@@ -20,7 +20,7 @@ pub struct BucketPolicyArgs {
     object_name: String,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct BPStatement {
     sid: String,
     effect: Effect,
@@ -32,7 +32,7 @@ pub struct BPStatement {
     conditions: Option<Functions>,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct BucketPolicy {
     pub id: String,
     pub version: String,

ecstore/src/bucket/policy/condition/function.rs

@@ -41,14 +41,14 @@ pub trait FunctionApi {
 //     }
 // }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 enum Function {
     #[default]
     Test,
 }
 
 // 定义Functions类型
-#[derive(Deserialize, Serialize, Default)]
+#[derive(Deserialize, Serialize, Default, Clone)]
 pub struct Functions(Vec<Function>);
 
 impl Debug for Functions {

ecstore/src/bucket/policy/resource.rs

@@ -15,11 +15,11 @@ const RESOURCE_ARN_PREFIX: &str = "arn:aws:s3:::";
 const RESOURCE_ARN_KMS_PREFIX: &str = "arn:rustfs:kms::::";
 
 // 定义Resource结构体
-#[derive(Debug, Deserialize, Serialize, Default, PartialEq, Eq, Hash)]
+#[derive(Debug, Deserialize, Serialize, Default, PartialEq, Eq, Hash, Clone)]
 pub struct Resource {
     pattern: String,
     r#type: ResourceARNType,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct ResourceSet(HashSet<Resource>);

ecstore/src/bucket/quota/mod.rs

@@ -7,7 +7,7 @@ pub enum QuotaType {
 }
 
 // 定义BucketQuota结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct BucketQuota {
     quota: Option<u64>, // 使用Option来表示可能不存在的字段
 

ecstore/src/bucket/replication/and.rs

@@ -2,7 +2,7 @@ use super::tag::Tag;
 use serde::{Deserialize, Serialize};
 
 // 定义And结构体
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct And {
     prefix: Option<String>,
     tags: Option<Vec<Tag>>,

ecstore/src/bucket/replication/filter.rs

@@ -3,7 +3,7 @@ use super::tag::Tag;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Filter {
     prefix: String,
     and: And,

ecstore/src/bucket/replication/mod.rs

@@ -6,7 +6,7 @@ mod tag;
 use rule::Rule;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Config {
     rules: Vec<Rule>,
     role_arn: String,

ecstore/src/bucket/replication/rule.rs

@@ -1,29 +1,29 @@
 use super::filter::Filter;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub enum Status {
     #[default]
     Enabled,
     Disabled,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct DeleteMarkerReplication {
     pub status: Status,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct DeleteReplication {
     pub status: Status,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct ExistingObjectReplication {
     pub status: Status,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Destination {
     pub bucket: String,
     pub storage_class: String,
@@ -31,18 +31,18 @@ pub struct Destination {
 }
 
 // 定义ReplicaModifications结构体
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct ReplicaModifications {
     status: Status,
 }
 
 // 定义SourceSelectionCriteria结构体
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct SourceSelectionCriteria {
     replica_modifications: ReplicaModifications,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Rule {
     pub id: String,
     pub status: Status,

ecstore/src/bucket/replication/tag.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Tag {
     pub key: Option<String>,
     pub value: Option<String>,

ecstore/src/bucket/tags/mod.rs

@@ -1,8 +1,10 @@
+use crate::error::{Error, Result};
+use rmp_serde::Serializer as rmpSerializer;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
 // 定义tagSet结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct TagSet {
     #[serde(rename = "Tag")]
     tag_map: HashMap<String, String>,
@@ -10,10 +12,25 @@ pub struct TagSet {
 }
 
 // 定义tagging结构体
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Debug, Deserialize, Serialize, Default, Clone)]
 pub struct Tags {
     #[serde(rename = "Tagging")]
     xml_name: String,
     #[serde(rename = "TagSet")]
     tag_set: Option<TagSet>,
 }
+
+impl Tags {
+    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: Tags = rmp_serde::from_slice(buf)?;
+        Ok(t)
+    }
+}

ecstore/src/bucket/target/mod.rs

@@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use time::OffsetDateTime;
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Credentials {
     access_key: String,
     secret_key: String,
@@ -10,13 +10,13 @@ pub struct Credentials {
     expiration: Option<OffsetDateTime>,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub enum ServiceType {
     #[default]
     Replication,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct LatencyStat {
     curr: Duration, // 当前延迟
     avg: Duration,  // 平均延迟
@@ -24,7 +24,7 @@ pub struct LatencyStat {
 }
 
 // 定义BucketTarget结构体
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct BucketTarget {
     source_bucket: String,
 
@@ -73,7 +73,7 @@ pub struct BucketTarget {
     edge: bool,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct BucketTargets {
     pub targets: Vec<BucketTarget>,
 }

ecstore/src/bucket/versioning/mod.rs

@@ -25,12 +25,12 @@ impl std::fmt::Display for State {
     }
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct ExcludedPrefix {
     pub prefix: String,
 }
 
-#[derive(Debug, Deserialize, Serialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default,Clone)]
 pub struct Versioning {
     pub status: State,
     pub excluded_prefixes: Vec<ExcludedPrefix>,