Merge branch 'main' of github.com:rustfs/s3-rustfs into feature/observability-metrics

# Conflicts:
#	.github/workflows/build.yml
#	.github/workflows/ci.yml
#	Cargo.lock
#	Cargo.toml
#	appauth/src/token.rs
#	crates/config/src/config.rs
#	crates/event-notifier/examples/simple.rs
#	crates/event-notifier/src/global.rs
#	crates/event-notifier/src/lib.rs
#	crates/event-notifier/src/notifier.rs
#	crates/event-notifier/src/store.rs
#	crates/filemeta/src/filemeta.rs
#	crates/notify/examples/webhook.rs
#	crates/utils/Cargo.toml
#	ecstore/Cargo.toml
#	ecstore/src/cmd/bucket_replication.rs
#	ecstore/src/config/com.rs
#	ecstore/src/disk/error.rs
#	ecstore/src/disk/mod.rs
#	ecstore/src/set_disk.rs
#	ecstore/src/store_api.rs
#	ecstore/src/store_list_objects.rs
#	iam/Cargo.toml
#	iam/src/manager.rs
#	policy/Cargo.toml
#	rustfs/src/admin/rpc.rs
#	rustfs/src/main.rs
#	rustfs/src/storage/mod.rs

ecstore/src/bucket/error.rs

@@ -1,6 +1,6 @@
-use common::error::Error;
+use crate::error::Error;
 
-#[derive(Debug, thiserror::Error, PartialEq, Eq)]
+#[derive(Debug, thiserror::Error)]
 pub enum BucketMetadataError {
     #[error("tagging not found")]
     TaggingNotFound,
@@ -18,18 +18,58 @@ pub enum BucketMetadataError {
     BucketReplicationConfigNotFound,
     #[error("bucket remote target not found")]
     BucketRemoteTargetNotFound,
+
+    #[error("Io error: {0}")]
+    Io(std::io::Error),
 }
 
 impl BucketMetadataError {
-    pub fn is(&self, err: &Error) -> bool {
-        if let Some(e) = err.downcast_ref::<BucketMetadataError>() {
-            e == self
-        } else {
-            false
+    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<BucketMetadataError> for Error {
+    fn from(e: BucketMetadataError) -> Self {
+        match e {
+            BucketMetadataError::BucketPolicyNotFound => Error::BucketPolicyNotFound,
+            _ => Error::other(e),
         }
     }
 }
 
+impl From<Error> for BucketMetadataError {
+    fn from(e: Error) -> Self {
+        match e {
+            Error::BucketPolicyNotFound => BucketMetadataError::BucketPolicyNotFound,
+            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 {
@@ -41,6 +81,7 @@ impl BucketMetadataError {
             BucketMetadataError::BucketQuotaConfigNotFound => 0x06,
             BucketMetadataError::BucketReplicationConfigNotFound => 0x07,
             BucketMetadataError::BucketRemoteTargetNotFound => 0x08,
+            BucketMetadataError::Io(_) => 0x09,
         }
     }
 
@@ -54,6 +95,7 @@ impl BucketMetadataError {
             0x06 => Some(BucketMetadataError::BucketQuotaConfigNotFound),
             0x07 => Some(BucketMetadataError::BucketReplicationConfigNotFound),
             0x08 => Some(BucketMetadataError::BucketRemoteTargetNotFound),
+            0x09 => Some(BucketMetadataError::Io(std::io::Error::other("Io error"))),
             _ => None,
         }
     }

ecstore/src/bucket/metadata.rs

@@ -17,13 +17,13 @@ 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::{config, new_object_layer_fn};
-use common::error::{Error, Result};
+use crate::error::{Error, Result};
+use crate::new_object_layer_fn;
 
 use crate::disk::BUCKET_META_PREFIX;
 use crate::store::ECStore;
-use crate::utils::xml::deserialize;
 
 pub const BUCKET_METADATA_FILE: &str = ".metadata.bin";
 pub const BUCKET_METADATA_FORMAT: u16 = 1;
@@ -178,7 +178,7 @@ impl BucketMetadata {
 
     pub fn check_header(buf: &[u8]) -> Result<()> {
         if buf.len() <= 4 {
-            return Err(Error::msg("read_bucket_metadata: data invalid"));
+            return Err(Error::other("read_bucket_metadata: data invalid"));
         }
 
         let format = LittleEndian::read_u16(&buf[0..2]);
@@ -186,12 +186,12 @@ impl BucketMetadata {
 
         match format {
             BUCKET_METADATA_FORMAT => {}
-            _ => return Err(Error::msg("read_bucket_metadata: format invalid")),
+            _ => return Err(Error::other("read_bucket_metadata: format invalid")),
         }
 
         match version {
             BUCKET_METADATA_VERSION => {}
-            _ => return Err(Error::msg("read_bucket_metadata: version invalid")),
+            _ => return Err(Error::other("read_bucket_metadata: version invalid")),
         }
 
         Ok(())
@@ -285,7 +285,7 @@ impl BucketMetadata {
                 self.bucket_targets_config_json = data.clone();
                 self.bucket_targets_config_updated_at = updated;
             }
-            _ => return Err(Error::msg(format!("config file not found : {}", config_file))),
+            _ => return Err(Error::other(format!("config file not found : {}", config_file))),
         }
 
         Ok(updated)
@@ -296,7 +296,9 @@ impl BucketMetadata {
     }
 
     pub async fn save(&mut self) -> Result<()> {
-        let Some(store) = new_object_layer_fn() else { return Err(Error::msg("errServerNotInitialized")) };
+        let Some(store) = new_object_layer_fn() else {
+            return Err(Error::other("errServerNotInitialized"));
+        };
 
         self.parse_all_configs(store.clone())?;
 
@@ -364,7 +366,7 @@ pub async fn load_bucket_metadata_parse(api: Arc<ECStore>, bucket: &str, parse:
     let mut bm = match read_bucket_metadata(api.clone(), bucket).await {
         Ok(res) => res,
         Err(err) => {
-            if !config::error::is_err_config_not_found(&err) {
+            if err != Error::ConfigNotFound {
                 return Err(err);
             }
 
@@ -388,7 +390,7 @@ pub async fn load_bucket_metadata_parse(api: Arc<ECStore>, bucket: &str, parse:
 async fn read_bucket_metadata(api: Arc<ECStore>, bucket: &str) -> Result<BucketMetadata> {
     if bucket.is_empty() {
         error!("bucket name empty");
-        return Err(Error::msg("invalid argument"));
+        return Err(Error::other("invalid argument"));
     }
 
     let bm = BucketMetadata::new(bucket);
@@ -403,7 +405,7 @@ async fn read_bucket_metadata(api: Arc<ECStore>, bucket: &str) -> Result<BucketM
     Ok(bm)
 }
 
-fn _write_time<S>(t: &OffsetDateTime, s: S) -> Result<S::Ok, S::Error>
+fn _write_time<S>(t: &OffsetDateTime, s: S) -> std::result::Result<S::Ok, S::Error>
 where
     S: Serializer,
 {

ecstore/src/bucket/metadata_sys.rs

@@ -3,18 +3,15 @@ use std::sync::OnceLock;
 use std::time::Duration;
 use std::{collections::HashMap, sync::Arc};
 
+use crate::StorageAPI;
 use crate::bucket::error::BucketMetadataError;
-use crate::bucket::metadata::{load_bucket_metadata_parse, BUCKET_LIFECYCLE_CONFIG};
-use crate::bucket::utils::is_meta_bucketname;
+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::config::error::ConfigError;
-use crate::disk::error::DiskError;
-use crate::global::{is_dist_erasure, is_erasure, new_object_layer_fn, GLOBAL_Endpoints};
+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 crate::utils::xml::deserialize;
-use crate::{config, StorageAPI};
-use common::error::{Error, Result};
 use futures::future::join_all;
 use policy::policy::BucketPolicy;
 use s3s::dto::{
@@ -26,7 +23,7 @@ use tokio::sync::RwLock;
 use tokio::time::sleep;
 use tracing::{error, warn};
 
-use super::metadata::{load_bucket_metadata, BucketMetadata};
+use super::metadata::{BucketMetadata, load_bucket_metadata};
 use super::quota::BucketQuota;
 use super::target::BucketTargets;
 
@@ -50,7 +47,7 @@ pub(super) fn get_bucket_metadata_sys() -> Result<Arc<RwLock<BucketMetadataSys>>
     if let Some(sys) = GLOBAL_BucketMetadataSys.get() {
         Ok(sys.clone())
     } else {
-        Err(Error::msg("GLOBAL_BucketMetadataSys not init"))
+        Err(Error::other("GLOBAL_BucketMetadataSys not init"))
     }
 }
 
@@ -168,7 +165,7 @@ impl BucketMetadataSys {
             if let Some(endpoints) = GLOBAL_Endpoints.get() {
                 endpoints.es_count() * 10
             } else {
-                return Err(Error::msg("GLOBAL_Endpoints not init"));
+                return Err(Error::other("GLOBAL_Endpoints not init"));
             }
         };
 
@@ -248,14 +245,14 @@ impl BucketMetadataSys {
 
     pub async fn get(&self, bucket: &str) -> Result<Arc<BucketMetadata>> {
         if is_meta_bucketname(bucket) {
-            return Err(Error::new(ConfigError::NotFound));
+            return Err(Error::ConfigNotFound);
         }
 
         let map = self.metadata_map.read().await;
         if let Some(bm) = map.get(bucket) {
             Ok(bm.clone())
         } else {
-            Err(Error::new(ConfigError::NotFound))
+            Err(Error::ConfigNotFound)
         }
     }
 
@@ -280,7 +277,7 @@ impl BucketMetadataSys {
             let meta = match self.get_config_from_disk(bucket).await {
                 Ok(res) => res,
                 Err(err) => {
-                    if !config::error::is_err_config_not_found(&err) {
+                    if err != Error::ConfigNotFound {
                         return Err(err);
                     } else {
                         BucketMetadata::new(bucket)
@@ -304,16 +301,18 @@ impl BucketMetadataSys {
     }
 
     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::msg("errServerNotInitialized")) };
+        let Some(store) = new_object_layer_fn() else {
+            return Err(Error::other("errServerNotInitialized"));
+        };
 
         if is_meta_bucketname(bucket) {
-            return Err(Error::msg("errInvalidArgument"));
+            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 && DiskError::VolumeNotFound.is(&err) {
+                if !is_erasure().await && !is_dist_erasure().await && is_err_bucket_not_found(&err) {
                     BucketMetadata::new(bucket)
                 } else {
                     return Err(err);
@@ -330,7 +329,7 @@ impl BucketMetadataSys {
 
     async fn save(&self, bm: BucketMetadata) -> Result<()> {
         if is_meta_bucketname(&bm.name) {
-            return Err(Error::msg("errInvalidArgument"));
+            return Err(Error::other("errInvalidArgument"));
         }
 
         let mut bm = bm;
@@ -345,7 +344,7 @@ impl BucketMetadataSys {
     pub async fn get_config_from_disk(&self, bucket: &str) -> Result<BucketMetadata> {
         println!("load data from disk");
         if is_meta_bucketname(bucket) {
-            return Err(Error::msg("errInvalidArgument"));
+            return Err(Error::other("errInvalidArgument"));
         }
 
         load_bucket_metadata(self.api.clone(), bucket).await
@@ -364,10 +363,10 @@ impl BucketMetadataSys {
                 Ok(res) => res,
                 Err(err) => {
                     return if *self.initialized.read().await {
-                        Err(Error::msg("errBucketMetadataNotInitialized"))
+                        Err(Error::other("errBucketMetadataNotInitialized"))
                     } else {
                         Err(err)
-                    }
+                    };
                 }
             };
 
@@ -385,7 +384,7 @@ impl BucketMetadataSys {
             Ok((res, _)) => res,
             Err(err) => {
                 warn!("get_versioning_config err {:?}", &err);
-                return if config::error::is_err_config_not_found(&err) {
+                return if err == Error::ConfigNotFound {
                     Ok((VersioningConfiguration::default(), OffsetDateTime::UNIX_EPOCH))
                 } else {
                     Err(err)
@@ -405,8 +404,8 @@ impl BucketMetadataSys {
             Ok((res, _)) => res,
             Err(err) => {
                 warn!("get_bucket_policy err {:?}", &err);
-                return if config::error::is_err_config_not_found(&err) {
-                    Err(Error::new(BucketMetadataError::BucketPolicyNotFound))
+                return if err == Error::ConfigNotFound {
+                    Err(BucketMetadataError::BucketPolicyNotFound.into())
                 } else {
                     Err(err)
                 };
@@ -416,7 +415,7 @@ impl BucketMetadataSys {
         if let Some(config) = &bm.policy_config {
             Ok((config.clone(), bm.policy_config_updated_at))
         } else {
-            Err(Error::new(BucketMetadataError::BucketPolicyNotFound))
+            Err(BucketMetadataError::BucketPolicyNotFound.into())
         }
     }
 
@@ -425,8 +424,8 @@ impl BucketMetadataSys {
             Ok((res, _)) => res,
             Err(err) => {
                 warn!("get_tagging_config err {:?}", &err);
-                return if config::error::is_err_config_not_found(&err) {
-                    Err(Error::new(BucketMetadataError::TaggingNotFound))
+                return if err == Error::ConfigNotFound {
+                    Err(BucketMetadataError::TaggingNotFound.into())
                 } else {
                     Err(err)
                 };
@@ -436,7 +435,7 @@ impl BucketMetadataSys {
         if let Some(config) = &bm.tagging_config {
             Ok((config.clone(), bm.tagging_config_updated_at))
         } else {
-            Err(Error::new(BucketMetadataError::TaggingNotFound))
+            Err(BucketMetadataError::TaggingNotFound.into())
         }
     }
 
@@ -444,9 +443,8 @@ impl BucketMetadataSys {
         let bm = match self.get_config(bucket).await {
             Ok((res, _)) => res,
             Err(err) => {
-                warn!("get_object_lock_config err {:?}", &err);
-                return if config::error::is_err_config_not_found(&err) {
-                    Err(Error::new(BucketMetadataError::BucketObjectLockConfigNotFound))
+                return if err == Error::ConfigNotFound {
+                    Err(BucketMetadataError::BucketObjectLockConfigNotFound.into())
                 } else {
                     Err(err)
                 };
@@ -456,7 +454,7 @@ impl BucketMetadataSys {
         if let Some(config) = &bm.object_lock_config {
             Ok((config.clone(), bm.object_lock_config_updated_at))
         } else {
-            Err(Error::new(BucketMetadataError::BucketObjectLockConfigNotFound))
+            Err(BucketMetadataError::BucketObjectLockConfigNotFound.into())
         }
     }
 
@@ -465,8 +463,8 @@ impl BucketMetadataSys {
             Ok((res, _)) => res,
             Err(err) => {
                 warn!("get_lifecycle_config err {:?}", &err);
-                return if config::error::is_err_config_not_found(&err) {
-                    Err(Error::new(BucketMetadataError::BucketLifecycleNotFound))
+                return if err == Error::ConfigNotFound {
+                    Err(BucketMetadataError::BucketLifecycleNotFound.into())
                 } else {
                     Err(err)
                 };
@@ -475,12 +473,12 @@ impl BucketMetadataSys {
 
         if let Some(config) = &bm.lifecycle_config {
             if config.rules.is_empty() {
-                Err(Error::new(BucketMetadataError::BucketLifecycleNotFound))
+                Err(BucketMetadataError::BucketLifecycleNotFound.into())
             } else {
                 Ok((config.clone(), bm.lifecycle_config_updated_at))
             }
         } else {
-            Err(Error::new(BucketMetadataError::BucketLifecycleNotFound))
+            Err(BucketMetadataError::BucketLifecycleNotFound.into())
         }
     }
 
@@ -489,7 +487,7 @@ impl BucketMetadataSys {
             Ok((bm, _)) => bm.notification_config.clone(),
             Err(err) => {
                 warn!("get_notification_config err {:?}", &err);
-                if config::error::is_err_config_not_found(&err) {
+                if err == Error::ConfigNotFound {
                     None
                 } else {
                     return Err(err);
@@ -505,8 +503,8 @@ impl BucketMetadataSys {
             Ok((res, _)) => res,
             Err(err) => {
                 warn!("get_sse_config err {:?}", &err);
-                return if config::error::is_err_config_not_found(&err) {
-                    Err(Error::new(BucketMetadataError::BucketSSEConfigNotFound))
+                return if err == Error::ConfigNotFound {
+                    Err(BucketMetadataError::BucketSSEConfigNotFound.into())
                 } else {
                     Err(err)
                 };
@@ -516,7 +514,7 @@ impl BucketMetadataSys {
         if let Some(config) = &bm.sse_config {
             Ok((config.clone(), bm.encryption_config_updated_at))
         } else {
-            Err(Error::new(BucketMetadataError::BucketSSEConfigNotFound))
+            Err(BucketMetadataError::BucketSSEConfigNotFound.into())
         }
     }
 
@@ -536,8 +534,8 @@ impl BucketMetadataSys {
             Ok((res, _)) => res,
             Err(err) => {
                 warn!("get_quota_config err {:?}", &err);
-                return if config::error::is_err_config_not_found(&err) {
-                    Err(Error::new(BucketMetadataError::BucketQuotaConfigNotFound))
+                return if err == Error::ConfigNotFound {
+                    Err(BucketMetadataError::BucketQuotaConfigNotFound.into())
                 } else {
                     Err(err)
                 };
@@ -547,7 +545,7 @@ impl BucketMetadataSys {
         if let Some(config) = &bm.quota_config {
             Ok((config.clone(), bm.quota_config_updated_at))
         } else {
-            Err(Error::new(BucketMetadataError::BucketQuotaConfigNotFound))
+            Err(BucketMetadataError::BucketQuotaConfigNotFound.into())
         }
     }
 
@@ -555,14 +553,14 @@ impl BucketMetadataSys {
         let (bm, reload) = match self.get_config(bucket).await {
             Ok(res) => {
                 if res.0.replication_config.is_none() {
-                    return Err(Error::new(BucketMetadataError::BucketReplicationConfigNotFound));
+                    return Err(BucketMetadataError::BucketReplicationConfigNotFound.into());
                 }
                 res
             }
             Err(err) => {
                 warn!("get_replication_config err {:?}", &err);
-                return if config::error::is_err_config_not_found(&err) {
-                    Err(Error::new(BucketMetadataError::BucketReplicationConfigNotFound))
+                return if err == Error::ConfigNotFound {
+                    Err(BucketMetadataError::BucketReplicationConfigNotFound.into())
                 } else {
                     Err(err)
                 };
@@ -576,7 +574,7 @@ impl BucketMetadataSys {
             //println!("549 {:?}", config.clone());
             Ok((config.clone(), bm.replication_config_updated_at))
         } else {
-            Err(Error::new(BucketMetadataError::BucketReplicationConfigNotFound))
+            Err(BucketMetadataError::BucketReplicationConfigNotFound.into())
         }
     }
 
@@ -585,8 +583,8 @@ impl BucketMetadataSys {
             Ok(res) => res,
             Err(err) => {
                 warn!("get_replication_config err {:?}", &err);
-                return if config::error::is_err_config_not_found(&err) {
-                    Err(Error::new(BucketMetadataError::BucketRemoteTargetNotFound))
+                return if err == Error::ConfigNotFound {
+                    Err(BucketMetadataError::BucketRemoteTargetNotFound.into())
                 } else {
                     Err(err)
                 };
@@ -603,7 +601,7 @@ impl BucketMetadataSys {
 
             Ok(config.clone())
         } else {
-            Err(Error::new(BucketMetadataError::BucketRemoteTargetNotFound))
+            Err(BucketMetadataError::BucketRemoteTargetNotFound.into())
         }
     }
 }

ecstore/src/bucket/policy_sys.rs

@@ -1,5 +1,5 @@
 use super::{error::BucketMetadataError, metadata_sys::get_bucket_metadata_sys};
-use common::error::Result;
+use crate::error::Result;
 use policy::policy::{BucketPolicy, BucketPolicyArgs};
 use tracing::warn;
 
@@ -10,8 +10,9 @@ impl PolicySys {
         match Self::get(args.bucket).await {
             Ok(cfg) => return cfg.is_allowed(args),
             Err(err) => {
-                if !BucketMetadataError::BucketPolicyNotFound.is(&err) {
-                    warn!("config get err {:?}", err);
+                let berr: BucketMetadataError = err.into();
+                if berr != BucketMetadataError::BucketPolicyNotFound {
+                    warn!("config get err {:?}", berr);
                 }
             }
         }

ecstore/src/bucket/quota/mod.rs

@@ -1,4 +1,4 @@
-use common::error::Result;
+use crate::error::Result;
 use rmp_serde::Serializer as rmpSerializer;
 use serde::{Deserialize, Serialize};
 

ecstore/src/bucket/target/mod.rs

@@ -1,4 +1,4 @@
-use common::error::Result;
+use crate::error::Result;
 use rmp_serde::Serializer as rmpSerializer;
 use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;

ecstore/src/bucket/utils.rs

@@ -1,5 +1,6 @@
 use crate::disk::RUSTFS_META_BUCKET;
-use common::error::{Error, Result};
+use crate::error::{Error, Result};
+use s3s::xml;
 
 pub fn is_meta_bucketname(name: &str) -> bool {
     name.starts_with(RUSTFS_META_BUCKET)
@@ -13,60 +14,88 @@ lazy_static::lazy_static! {
     static ref IP_ADDRESS: Regex = Regex::new(r"^(\d+\.){3}\d+$").unwrap();
 }
 
-pub fn check_bucket_name_common(bucket_name: &str, strict: bool) -> Result<(), Error> {
+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::msg("Bucket name cannot be empty"));
+        return Err(Error::other("Bucket name cannot be empty"));
     }
     if bucket_name_trimmed.len() < 3 {
-        return Err(Error::msg("Bucket name cannot be shorter than 3 characters"));
+        return Err(Error::other("Bucket name cannot be shorter than 3 characters"));
     }
     if bucket_name_trimmed.len() > 63 {
-        return Err(Error::msg("Bucket name cannot be longer than 63 characters"));
+        return Err(Error::other("Bucket name cannot be longer than 63 characters"));
     }
 
     if bucket_name_trimmed == "rustfs" {
-        return Err(Error::msg("Bucket name cannot be rustfs"));
+        return Err(Error::other("Bucket name cannot be rustfs"));
     }
 
     if IP_ADDRESS.is_match(bucket_name_trimmed) {
-        return Err(Error::msg("Bucket name cannot be an IP address"));
+        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::msg("Bucket name contains invalid characters"));
+        return Err(Error::other("Bucket name contains invalid characters"));
     }
     if strict {
         if !VALID_BUCKET_NAME_STRICT.is_match(bucket_name_trimmed) {
-            return Err(Error::msg("Bucket name contains invalid characters"));
+            return Err(Error::other("Bucket name contains invalid characters"));
         }
     } else if !VALID_BUCKET_NAME.is_match(bucket_name_trimmed) {
-        return Err(Error::msg("Bucket name contains invalid characters"));
+        return Err(Error::other("Bucket name contains invalid characters"));
     }
     Ok(())
 }
 
-pub fn check_valid_bucket_name(bucket_name: &str) -> Result<(), Error> {
+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<(), Error> {
+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<(), Error> {
+pub fn check_valid_object_name_prefix(object_name: &str) -> Result<()> {
     if object_name.len() > 1024 {
-        return Err(Error::msg("Object name cannot be longer than 1024 characters"));
+        return Err(Error::other("Object name cannot be longer than 1024 characters"));
     }
     if !object_name.is_ascii() {
-        return Err(Error::msg("Object name with non-UTF-8 strings are not supported"));
+        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<(), Error> {
+pub fn check_valid_object_name(object_name: &str) -> Result<()> {
     if object_name.trim().is_empty() {
-        return Err(Error::msg("Object name cannot be 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)
+}

ecstore/src/bucket/versioning/mod.rs

@@ -1,6 +1,6 @@
 use s3s::dto::{BucketVersioningStatus, VersioningConfiguration};
 
-use crate::utils::wildcard;
+use rustfs_utils::string::match_simple;
 
 pub trait VersioningApi {
     fn enabled(&self) -> bool;
@@ -33,7 +33,7 @@ impl VersioningApi for VersioningConfiguration {
             for p in excluded_prefixes.iter() {
                 if let Some(ref sprefix) = p.prefix {
                     let pattern = format!("{}*", sprefix);
-                    if wildcard::match_simple(&pattern, prefix) {
+                    if match_simple(&pattern, prefix) {
                         return false;
                     }
                 }
@@ -63,7 +63,7 @@ impl VersioningApi for VersioningConfiguration {
                 for p in excluded_prefixes.iter() {
                     if let Some(ref sprefix) = p.prefix {
                         let pattern = format!("{}*", sprefix);
-                        if wildcard::match_simple(&pattern, prefix) {
+                        if match_simple(&pattern, prefix) {
                             return true;
                         }
                     }

ecstore/src/bucket/versioning_sys.rs

@@ -1,6 +1,6 @@
 use super::{metadata_sys::get_bucket_metadata_sys, versioning::VersioningApi};
 use crate::disk::RUSTFS_META_BUCKET;
-use common::error::Result;
+use crate::error::Result;
 use s3s::dto::VersioningConfiguration;
 use tracing::warn;