feat: add ImportBucketMetadata handler

ecstore/src/bucket/metadata_sys.rs

@@ -19,7 +19,7 @@ use std::{collections::HashMap, sync::Arc};
 use time::OffsetDateTime;
 use tokio::sync::RwLock;
 use tokio::time::sleep;
-use tracing::{error, warn};
+use tracing::error;
 
 use super::metadata::{BucketMetadata, load_bucket_metadata};
 use super::quota::BucketQuota;
@@ -56,7 +56,7 @@ pub async fn set_bucket_metadata(bucket: String, bm: BucketMetadata) -> Result<(
     Ok(())
 }
 
-pub(crate) async fn get(bucket: &str) -> Result<Arc<BucketMetadata>> {
+pub async fn get(bucket: &str) -> Result<Arc<BucketMetadata>> {
     let sys = get_bucket_metadata_sys()?;
     let lock = sys.read().await;
     lock.get(bucket).await
@@ -76,6 +76,27 @@ pub async fn delete(bucket: &str, config_file: &str) -> Result<OffsetDateTime> {
     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;
@@ -340,7 +361,6 @@ 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::other("errInvalidArgument"));
         }
@@ -381,7 +401,6 @@ impl BucketMetadataSys {
         let bm = match self.get_config(bucket).await {
             Ok((res, _)) => res,
             Err(err) => {
-                warn!("get_versioning_config err {:?}", &err);
                 return if err == Error::ConfigNotFound {
                     Ok((VersioningConfiguration::default(), OffsetDateTime::UNIX_EPOCH))
                 } else {
@@ -445,7 +464,6 @@ impl BucketMetadataSys {
         let bm = match self.get_config(bucket).await {
             Ok((bm, _)) => bm.notification_config.clone(),
             Err(err) => {
-                warn!("get_notification_config err {:?}", &err);
                 if err == Error::ConfigNotFound {
                     None
                 } else {

ecstore/src/bucket/policy_sys.rs

@@ -21,7 +21,7 @@ impl PolicySys {
     }
     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.write().await;
+        let bucket_meta_sys = bucket_meta_sys_lock.read().await;
 
         let (cfg, _) = bucket_meta_sys.get_bucket_policy(bucket).await?;
 

ecstore/src/disk/fs.rs

@@ -5,8 +5,6 @@ use tokio::{
     io,
 };
 
-pub const SLASH_SEPARATOR: &str = "/";
-
 #[cfg(not(windows))]
 pub fn same_file(f1: &Metadata, f2: &Metadata) -> bool {
     use std::os::unix::fs::MetadataExt;
@@ -522,9 +520,4 @@ mod tests {
         // Should be different files
         assert!(!same_file(&metadata1, &metadata2));
     }
-
-    #[test]
-    fn test_slash_separator() {
-        assert_eq!(SLASH_SEPARATOR, "/");
-    }
 }

ecstore/src/disk/local.rs

@@ -135,7 +135,7 @@ impl LocalDisk {
             Ok(path) => path,
             Err(e) => {
                 if e.kind() == ErrorKind::NotFound {
-                    return Err(DiskError::VolumeNotFound.into());
+                    return Err(DiskError::VolumeNotFound);
                 }
                 return Err(to_file_error(e).into());
             }
@@ -162,7 +162,7 @@ impl LocalDisk {
             let (set_idx, disk_idx) = fm.find_disk_index_by_disk_id(fm.erasure.this)?;
 
             if set_idx as i32 != ep.set_idx || disk_idx as i32 != ep.disk_idx {
-                return Err(Error::from(DiskError::InconsistentDisk));
+                return Err(DiskError::InconsistentDisk);
             }
 
             id = Some(fm.erasure.this);

ecstore/src/disk/os.rs

@@ -5,6 +5,7 @@ use std::{
 
 use super::error::Result;
 use crate::disk::error_conv::to_file_error;
+use rustfs_utils::path::SLASH_SEPARATOR;
 use tokio::fs;
 use tracing::warn;
 
@@ -90,7 +91,7 @@ pub async fn read_dir(path: impl AsRef<Path>, count: i32) -> std::io::Result<Vec
         if file_type.is_file() {
             volumes.push(name);
         } else if file_type.is_dir() {
-            volumes.push(format!("{}{}", name, super::fs::SLASH_SEPARATOR));
+            volumes.push(format!("{}{}", name, SLASH_SEPARATOR));
         }
         count -= 1;
         if count == 0 {