fix: clippy

ecstore/src/client/api_error_response.rs

@@ -89,7 +89,6 @@ pub fn http_resp_to_error_response(
     object_name: &str,
 ) -> ErrorResponse {
     let err_body = String::from_utf8(b).unwrap();
-    //let err_body = xml_decode_and_body(resp.body, &err_resp);
     let err_resp_ = serde_xml_rs::from_str::<ErrorResponse>(&err_body);
     let mut err_resp = ErrorResponse::default();
     if err_resp_.is_err() {

ecstore/src/client/api_put_object.rs

@@ -28,10 +28,10 @@ use crate::client::{
     constants::{ISO8601_DATEFORMAT, MAX_MULTIPART_PUT_OBJECT_SIZE, MIN_PART_SIZE, TOTAL_WORKERS},
     credentials::SignatureType,
     transition_api::{ReaderImpl, TransitionClient, UploadInfo},
+    utils::{is_amz_header, is_minio_header, is_rustfs_header, is_standard_header, is_storageclass_header},
 };
 use rustfs_utils::{
     crypto::base64_encode,
-    net::{is_amz_header, is_minio_header, is_rustfs_header, is_standard_header, is_storageclass_header},
 };
 
 #[derive(Debug, Clone)]

ecstore/src/client/api_remove.rs

@@ -64,9 +64,6 @@ pub struct RemoveObjectOptions {
 impl TransitionClient {
     pub async fn remove_bucket_with_options(&self, bucket_name: &str, opts: &RemoveBucketOptions) -> Result<(), std::io::Error> {
         let headers = HeaderMap::new();
-        /*if opts.force_delete {
-            headers.insert(rustFSForceDelete, "true");
-        }*/
 
         let resp = self
             .execute_method(

ecstore/src/client/mod.rs

@@ -16,3 +16,4 @@ pub mod credentials;
 pub mod object_api_utils;
 pub mod object_handlers_common;
 pub mod transition_api;
+pub mod utils;

ecstore/src/client/utils.rs

@@ -0,0 +1,78 @@
+use lazy_static::lazy_static;
+use std::collections::{HashMap, HashSet};
+
+use s3s::header::X_AMZ_STORAGE_CLASS;
+
+lazy_static! {
+    static ref SUPPORTED_QUERY_VALUES: HashMap<String, bool> = {
+        let mut m = HashMap::new();
+        m.insert("attributes".to_string(), true);
+        m.insert("partNumber".to_string(), true);
+        m.insert("versionId".to_string(), true);
+        m.insert("response-cache-control".to_string(), true);
+        m.insert("response-content-disposition".to_string(), true);
+        m.insert("response-content-encoding".to_string(), true);
+        m.insert("response-content-language".to_string(), true);
+        m.insert("response-content-type".to_string(), true);
+        m.insert("response-expires".to_string(), true);
+        m
+    };
+    static ref SUPPORTED_HEADERS: HashMap<String, bool> = {
+        let mut m = HashMap::new();
+        m.insert("content-type".to_string(), true);
+        m.insert("cache-control".to_string(), true);
+        m.insert("content-encoding".to_string(), true);
+        m.insert("content-disposition".to_string(), true);
+        m.insert("content-language".to_string(), true);
+        m.insert("x-amz-website-redirect-location".to_string(), true);
+        m.insert("x-amz-object-lock-mode".to_string(), true);
+        m.insert("x-amz-metadata-directive".to_string(), true);
+        m.insert("x-amz-object-lock-retain-until-date".to_string(), true);
+        m.insert("expires".to_string(), true);
+        m.insert("x-amz-replication-status".to_string(), true);
+        m
+    };
+    static ref SSE_HEADERS: HashMap<String, bool> = {
+        let mut m = HashMap::new();
+        m.insert("x-amz-server-side-encryption".to_string(), true);
+        m.insert("x-amz-server-side-encryption-aws-kms-key-id".to_string(), true);
+        m.insert("x-amz-server-side-encryption-context".to_string(), true);
+        m.insert("x-amz-server-side-encryption-customer-algorithm".to_string(), true);
+        m.insert("x-amz-server-side-encryption-customer-key".to_string(), true);
+        m.insert("x-amz-server-side-encryption-customer-key-md5".to_string(), true);
+        m
+    };
+}
+
+pub fn is_standard_query_value(qs_key: &str) -> bool {
+    SUPPORTED_QUERY_VALUES[qs_key]
+}
+
+pub fn is_storageclass_header(header_key: &str) -> bool {
+    header_key.to_lowercase() == X_AMZ_STORAGE_CLASS.as_str().to_lowercase()
+}
+
+pub fn is_standard_header(header_key: &str) -> bool {
+    *SUPPORTED_HEADERS.get(&header_key.to_lowercase()).unwrap_or(&false)
+}
+
+pub fn is_sse_header(header_key: &str) -> bool {
+    *SSE_HEADERS.get(&header_key.to_lowercase()).unwrap_or(&false)
+}
+
+pub fn is_amz_header(header_key: &str) -> bool {
+    let key = header_key.to_lowercase();
+    key.starts_with("x-amz-meta-")
+        || key.starts_with("x-amz-grant-")
+        || key == "x-amz-acl"
+        || is_sse_header(header_key)
+        || key.starts_with("x-amz-checksum-")
+}
+
+pub fn is_rustfs_header(header_key: &str) -> bool {
+    header_key.to_lowercase().starts_with("x-rustfs-")
+}
+
+pub fn is_minio_header(header_key: &str) -> bool {
+    header_key.to_lowercase().starts_with("x-minio-")
+}

ecstore/src/error.rs

@@ -817,30 +817,9 @@ pub fn error_resp_to_object_err(err: ErrorResponse, params: Vec<&str>) -> std::i
     let version_id = version_id.to_string();
 
     match r_err.code {
-        /*S3ErrorCode::SlowDownWrite => {
-            err = StorageError::InsufficientWriteQuorum;//{bucket: bucket, object: object};
-        }*/
-        /*S3ErrorCode::SlowDown/* SlowDownRead */ => {
-            err = std::io::Error::other(StorageError::InsufficientReadQuorum.to_string());
-        }*/
-        /*S3ErrorCode::PreconditionFailed => {
-            err = Error::from(StorageError::PreConditionFailed);
-        }*/
-        /*S3ErrorCode::InvalidRange => {
-            err = Error::from(StorageError::InvalidRange);
-        }*/
-        /*S3ErrorCode::BucketAlreadyOwnedByYou => {
-            err = Error::from(StorageError::BucketAlreadyOwnedByYou);
-        }*/
         S3ErrorCode::BucketNotEmpty => {
             err = std::io::Error::other(StorageError::BucketNotEmpty("".to_string()).to_string());
         }
-        /*S3ErrorCode::NoSuchBucketPolicy => {
-            err = Error::from(StorageError::BucketPolicyNotFound);
-        }*/
-        /*S3ErrorCode::NoSuchLifecycleConfiguration => {
-            err = Error::from(StorageError::BucketLifecycleNotFound);
-        }*/
         S3ErrorCode::InvalidBucketName => {
             err = std::io::Error::other(StorageError::BucketNameInvalid(bucket));
         }
@@ -864,24 +843,12 @@ pub fn error_resp_to_object_err(err: ErrorResponse, params: Vec<&str>) -> std::i
                 err = std::io::Error::other(StorageError::BucketNotFound(bucket));
             }
         }
-        /*S3ErrorCode::XRustFsInvalidObjectName => {
-            err = Error::from(StorageError::ObjectNameInvalid(bucket, object));
-        }*/
         S3ErrorCode::AccessDenied => {
             err = std::io::Error::other(StorageError::PrefixAccessDenied(bucket, object));
         }
-        /*S3ErrorCode::XAmzContentSHA256Mismatch => {
-            err = hash.SHA256Mismatch{};
-        }*/
         S3ErrorCode::NoSuchUpload => {
             err = std::io::Error::other(StorageError::InvalidUploadID(bucket, object, version_id));
         }
-        /*S3ErrorCode::EntityTooSmall => {
-            err = std::io::Error::other(StorageError::PartTooSmall);
-        }*/
-        /*S3ErrorCode::ReplicationPermissionCheck => {
-            err = std::io::Error::other(StorageError::ReplicationPermissionCheck);
-        }*/
         _ => {
             err = err_;
         }

ecstore/src/tier/tier_config.rs

@@ -110,8 +110,6 @@ impl Clone for TierConfig {
             tier_type: self.tier_type.clone(),
             name: self.name.clone(),
             s3,
-            //azure:   az,
-            //gcs:     gcs,
             rustfs: r,
             minio: m,
         }

ecstore/src/tier/warm_backend_minio.rs

@@ -63,7 +63,6 @@ impl WarmBackendMinIO {
         let default_port = if scheme == "https" { 443 } else { 80 };
         let client =
             TransitionClient::new(&format!("{}:{}", u.host_str().expect("err"), u.port().unwrap_or(default_port)), opts).await?;
-        //client.set_appinfo(format!("minio-tier-{}", tier), ReleaseTag);
 
         let client = Arc::new(client);
         let core = TransitionCore(Arc::clone(&client));

ecstore/src/tier/warm_backend_rustfs.rs

@@ -60,7 +60,6 @@ impl WarmBackendRustFS {
         let default_port = if scheme == "https" { 443 } else { 80 };
         let client =
             TransitionClient::new(&format!("{}:{}", u.host_str().expect("err"), u.port().unwrap_or(default_port)), opts).await?;
-        //client.set_appinfo(format!("rustfs-tier-{}", tier), ReleaseTag);
 
         let client = Arc::new(client);
         let core = TransitionCore(Arc::clone(&client));