Fix/main (#508)

* fix error

* fix

* fix cargo

* fix openssl cfg

* fix clippy

* fix clippy

* fix

* fix clippy

* fix clippy

ecstore/src/client/api_bucket_policy.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use bytes::Bytes;
 use http::{HeaderMap, StatusCode};
 use std::collections::HashMap;

ecstore/src/client/api_error_response.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use http::StatusCode;
 use serde::{Deserialize, Serialize};
 use serde::{de::Deserializer, ser::Serializer};
@@ -7,7 +14,7 @@ use std::fmt::Display;
 use s3s::Body;
 use s3s::S3ErrorCode;
 
-const REPORT_ISSUE: &str = "Please report this issue at https://github.com/rustfs/rustfs/issues.";
+const _REPORT_ISSUE: &str = "Please report this issue at https://github.com/rustfs/rustfs/issues.";
 
 #[derive(Serialize, Deserialize, Debug, Clone, thiserror::Error, PartialEq, Eq)]
 #[serde(default, rename_all = "PascalCase")]
@@ -26,7 +33,7 @@ pub struct ErrorResponse {
     pub status_code: StatusCode,
 }
 
-fn serialize_code<S>(data: &S3ErrorCode, s: S) -> Result<S::Ok, S::Error>
+fn serialize_code<S>(_data: &S3ErrorCode, s: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
 {

ecstore/src/client/api_get_object.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use bytes::Bytes;
 use http::HeaderMap;
 use std::io::Cursor;
@@ -169,7 +176,7 @@ impl Object {
         if !self.is_started || !self.object_info_set {
             let seek_req = GetRequest {
                 is_read_op: false,
-                offset: offset,
+                offset,
                 is_first_req: true,
                 ..Default::default()
             };

ecstore/src/client/api_get_options.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use http::{HeaderMap, HeaderName, HeaderValue};
 use std::collections::HashMap;
 use time::OffsetDateTime;

ecstore/src/client/api_list.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use bytes::Bytes;
 use http::{HeaderMap, StatusCode};
 use std::collections::HashMap;

ecstore/src/client/api_put_object.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use bytes::Bytes;
 use http::{HeaderMap, HeaderName, HeaderValue};
 use std::{collections::HashMap, sync::Arc};
@@ -206,10 +213,8 @@ impl PutObjectOptions {
                 if let Ok(header_name) = HeaderName::from_bytes(k.as_bytes()) {
                     header.insert(header_name, HeaderValue::from_str(&v).unwrap());
                 }
-            } else {
-                if let Ok(header_name) = HeaderName::from_bytes(format!("x-amz-meta-{}", k).as_bytes()) {
-                    header.insert(header_name, HeaderValue::from_str(&v).unwrap());
-                }
+            } else if let Ok(header_name) = HeaderName::from_bytes(format!("x-amz-meta-{}", k).as_bytes()) {
+                header.insert(header_name, HeaderValue::from_str(&v).unwrap());
             }
         }
 
@@ -239,7 +244,7 @@ impl TransitionClient {
         self: Arc<Self>,
         bucket_name: &str,
         object_name: &str,
-        mut reader: ReaderImpl,
+        reader: ReaderImpl,
         object_size: i64,
         opts: &PutObjectOptions,
     ) -> Result<UploadInfo, std::io::Error> {
@@ -255,7 +260,7 @@ impl TransitionClient {
         self: Arc<Self>,
         bucket_name: &str,
         object_name: &str,
-        mut reader: ReaderImpl,
+        reader: ReaderImpl,
         size: i64,
         opts: &PutObjectOptions,
     ) -> Result<UploadInfo, std::io::Error> {
@@ -346,7 +351,7 @@ impl TransitionClient {
             let mut md5_base64: String = "".to_string();
             if opts.send_content_md5 {
                 let mut md5_hasher = self.md5_hasher.lock().unwrap();
-                let mut hash = md5_hasher.as_mut().expect("err");
+                let hash = md5_hasher.as_mut().expect("err");
                 hash.write(&buf[..length]);
                 md5_base64 = base64_encode(hash.sum().as_bytes());
             } else {
@@ -406,7 +411,7 @@ impl TransitionClient {
 
         compl_multipart_upload.parts.sort();
 
-        let mut opts = PutObjectOptions {
+        let opts = PutObjectOptions {
             //server_side_encryption: opts.server_side_encryption,
             auto_checksum: opts.auto_checksum,
             ..Default::default()

ecstore/src/client/api_put_object_common.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use crate::client::{
     api_error_response::{err_entity_too_large, err_invalid_argument},
     api_put_object::PutObjectOptions,
@@ -47,12 +54,10 @@ pub fn optimal_part_info(object_size: i64, configured_part_size: u64) -> Result<
             )));
         }
 
-        if !unknown_size {
-            if object_size > (configured_part_size as i64 * MAX_PARTS_COUNT) {
-                return Err(std::io::Error::other(err_invalid_argument(
-                    "Part size * max_parts(10000) is lesser than input objectSize.",
-                )));
-            }
+        if !unknown_size && object_size > (configured_part_size as i64 * MAX_PARTS_COUNT) {
+            return Err(std::io::Error::other(err_invalid_argument(
+                "Part size * max_parts(10000) is lesser than input objectSize.",
+            )));
         }
 
         if (configured_part_size as i64) < ABS_MIN_PART_SIZE {

ecstore/src/client/api_put_object_multipart.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use bytes::Bytes;
 use http::{HeaderMap, HeaderName, HeaderValue, StatusCode};
 use s3s::S3ErrorCode;
@@ -104,8 +111,8 @@ impl TransitionClient {
             //let rd = newHook(bytes.NewReader(buf[..length]), opts.progress);
             let rd = Bytes::from(buf.clone());
 
-            let mut md5_base64: String;
-            let mut sha256_hex: String;
+            let md5_base64: String;
+            let sha256_hex: String;
 
             //if hash_sums["md5"] != nil {
             md5_base64 = base64_encode(&hash_sums["md5"]);
@@ -166,7 +173,7 @@ impl TransitionClient {
         }
 
         compl_multipart_upload.parts.sort();
-        let mut opts = PutObjectOptions {
+        let opts = PutObjectOptions {
             //server_side_encryption: opts.server_side_encryption,
             auto_checksum: opts.auto_checksum,
             ..Default::default()
@@ -199,7 +206,7 @@ impl TransitionClient {
             url_values.insert("versionId".to_string(), opts.internal.source_version_id.clone());
         }
 
-        let mut custom_header = opts.header();
+        let custom_header = opts.header();
 
         let mut req_metadata = RequestMetadata {
             bucket_name: bucket_name.to_string(),
@@ -339,7 +346,7 @@ impl TransitionClient {
         url_values.insert("uploadId".to_string(), upload_id.to_string());
         let complete_multipart_upload_bytes = complete.marshal_msg()?.as_bytes().to_vec();
 
-        let mut headers = opts.header();
+        let headers = opts.header();
 
         let complete_multipart_upload_buffer = Bytes::from(complete_multipart_upload_bytes);
         let mut req_metadata = RequestMetadata {

ecstore/src/client/api_put_object_streaming.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use bytes::Bytes;
 use futures::future::join_all;
 use http::{HeaderMap, HeaderName, HeaderValue, StatusCode};
@@ -41,7 +48,7 @@ impl TransitionClient {
         self: Arc<Self>,
         bucket_name: &str,
         object_name: &str,
-        mut reader: ReaderImpl,
+        reader: ReaderImpl,
         size: i64,
         opts: &PutObjectOptions,
     ) -> Result<UploadInfo, std::io::Error> {
@@ -67,7 +74,7 @@ impl TransitionClient {
         &self,
         bucket_name: &str,
         object_name: &str,
-        mut reader: ReaderImpl,
+        reader: ReaderImpl,
         size: i64,
         opts: &PutObjectOptions,
     ) -> Result<UploadInfo, std::io::Error> {
@@ -132,7 +139,7 @@ impl TransitionClient {
 
             if opts.send_content_md5 {
                 let mut md5_hasher = self.md5_hasher.lock().unwrap();
-                let mut md5_hash = md5_hasher.as_mut().expect("err");
+                let md5_hash = md5_hasher.as_mut().expect("err");
                 md5_hash.reset();
                 md5_hash.write(&buf[..length]);
                 md5_base64 = base64_encode(md5_hash.sum().as_bytes());
@@ -173,15 +180,13 @@ impl TransitionClient {
             total_uploaded_size += part_size as i64;
         }
 
-        if size > 0 {
-            if total_uploaded_size != size {
-                return Err(std::io::Error::other(err_unexpected_eof(
-                    total_uploaded_size,
-                    size,
-                    bucket_name,
-                    object_name,
-                )));
-            }
+        if size > 0 && total_uploaded_size != size {
+            return Err(std::io::Error::other(err_unexpected_eof(
+                total_uploaded_size,
+                size,
+                bucket_name,
+                object_name,
+            )));
         }
 
         let mut compl_multipart_upload = CompleteMultipartUpload::default();
@@ -242,7 +247,7 @@ impl TransitionClient {
         opts.user_metadata.remove("X-Amz-Checksum-Algorithm");
 
         let mut total_uploaded_size: i64 = 0;
-        let mut parts_info = Arc::new(RwLock::new(HashMap::<i64, ObjectPart>::new()));
+        let parts_info = Arc::new(RwLock::new(HashMap::<i64, ObjectPart>::new()));
 
         let n_buffers = opts.num_threads;
         let (bufs_tx, mut bufs_rx) = mpsc::channel(n_buffers as usize);
@@ -315,7 +320,7 @@ impl TransitionClient {
 
                 if opts.send_content_md5 {
                     let mut md5_hasher = clone_self.md5_hasher.lock().unwrap();
-                    let mut md5_hash = md5_hasher.as_mut().expect("err");
+                    let md5_hash = md5_hasher.as_mut().expect("err");
                     md5_hash.write(&buf[..length]);
                     md5_base64 = base64_encode(md5_hash.sum().as_bytes());
                 }
@@ -357,7 +362,7 @@ impl TransitionClient {
 
         let mut compl_multipart_upload = CompleteMultipartUpload::default();
 
-        let mut part_number: i64 = total_parts_count;
+        let part_number: i64 = total_parts_count;
         let mut all_parts = Vec::<ObjectPart>::with_capacity(parts_info.read().unwrap().len());
         for i in 1..part_number {
             let part = parts_info.read().unwrap()[&i].clone();
@@ -396,7 +401,7 @@ impl TransitionClient {
         &self,
         bucket_name: &str,
         object_name: &str,
-        mut reader: ReaderImpl,
+        reader: ReaderImpl,
         size: i64,
         opts: &PutObjectOptions,
     ) -> Result<UploadInfo, std::io::Error> {
@@ -405,7 +410,7 @@ impl TransitionClient {
             opts.send_content_md5 = false;
         }
 
-        let mut md5_base64: String = "".to_string();
+        let md5_base64: String = "".to_string();
         let progress_reader = reader; //newHook(reader, opts.progress);
 
         self.put_object_do(bucket_name, object_name, progress_reader, &md5_base64, "", size, &opts)
@@ -492,7 +497,7 @@ impl TransitionClient {
             } else {
                 "".to_string()
             },
-            size: size,
+            size,
             expiration: exp_time,
             expiration_rule_id: rule_id,
             checksum_crc32: if let Some(h_checksum_crc32) = h.get(ChecksumMode::ChecksumCRC32.key()) {

ecstore/src/client/api_remove.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use bytes::Bytes;
 use http::{HeaderMap, HeaderValue, Method, StatusCode};
 use s3s::S3ErrorCode;
@@ -55,7 +62,7 @@ pub struct RemoveObjectOptions {
 
 impl TransitionClient {
     pub async fn remove_bucket_with_options(&self, bucket_name: &str, opts: &RemoveBucketOptions) -> Result<(), std::io::Error> {
-        let mut headers = HeaderMap::new();
+        let headers = HeaderMap::new();
         /*if opts.force_delete {
             headers.insert(rustFSForceDelete, "true");
         }*/
@@ -189,7 +196,7 @@ impl TransitionClient {
         objects_rx: Receiver<ObjectInfo>,
         opts: RemoveObjectsOptions,
     ) -> Receiver<RemoveObjectResult> {
-        let (result_tx, mut result_rx) = mpsc::channel(1);
+        let (result_tx, result_rx) = mpsc::channel(1);
 
         let self_clone = Arc::clone(&self);
         let bucket_name_owned = bucket_name.to_string();
@@ -208,7 +215,7 @@ impl TransitionClient {
         objects_rx: Receiver<ObjectInfo>,
         opts: RemoveObjectsOptions,
     ) -> Receiver<RemoveObjectError> {
-        let (error_tx, mut error_rx) = mpsc::channel(1);
+        let (error_tx, error_rx) = mpsc::channel(1);
 
         let self_clone = Arc::clone(&self);
         let bucket_name_owned = bucket_name.to_string();

ecstore/src/client/api_s3_datatypes.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use s3s::dto::Owner;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;

ecstore/src/client/bucket_cache.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use http::Request;
 use hyper::StatusCode;
 use hyper::body::Incoming;

ecstore/src/client/constants.rs

@@ -1,4 +1,10 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+
 use lazy_static::lazy_static;
 use std::{collections::HashMap, sync::Arc};
 use time::{format_description::FormatItem, macros::format_description};
@@ -20,6 +26,6 @@ pub const SIGN_V4_ALGORITHM: &str = "AWS4-HMAC-SHA256";
 pub const ISO8601_DATEFORMAT: &[FormatItem<'_>] =
     format_description!("[year]-[month]-[day]T[hour]:[minute]:[second].[subsecond]Z");
 
-const GetObjectAttributesTags: &str = "ETag,Checksum,StorageClass,ObjectSize,ObjectParts";
-const GetObjectAttributesMaxParts: i64 = 1000;
+pub const GET_OBJECT_ATTRIBUTES_TAGS: &str = "ETag,Checksum,StorageClass,ObjectSize,ObjectParts";
+pub const GET_OBJECT_ATTRIBUTES_MAX_PARTS: i64 = 1000;
 const RUSTFS_BUCKET_SOURCE_MTIME: &str = "X-RustFs-Source-Mtime";

ecstore/src/client/credentials.rs

@@ -1,3 +1,10 @@
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use std::fmt::{Display, Formatter};
 
 use time::OffsetDateTime;
@@ -22,7 +29,7 @@ pub struct Credentials<P: Provider + Default> {
 impl<P: Provider + Default> Credentials<P> {
     pub fn new(provider: P) -> Self {
         Self {
-            provider: provider,
+            provider,
             force_refresh: true,
             ..Default::default()
         }

ecstore/src/client/object_api_utils.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use http::HeaderMap;
 use std::io::Cursor;
 use std::{collections::HashMap, sync::Arc};
@@ -55,8 +62,8 @@ fn part_number_to_rangespec(oi: ObjectInfo, part_number: usize) -> Option<HTTPRa
     }
 
     Some(HTTPRangeSpec {
-        start: start,
-        end: end,
+        start,
+        end,
         is_suffix_length: false,
     })
 }

ecstore/src/client/object_handlers_common.rs

@@ -6,12 +6,9 @@ use crate::store::ECStore;
 use crate::store_api::{ObjectOptions, ObjectToDelete};
 use lock::local_locker::MAX_DELETE_LIST;
 
-pub async fn delete_object_versions(api: ECStore, bucket: &str, to_del: &[ObjectToDelete], lc_event: lifecycle::Event) {
+pub async fn delete_object_versions(api: ECStore, bucket: &str, to_del: &[ObjectToDelete], _lc_event: lifecycle::Event) {
     let mut remaining = to_del;
     loop {
-        if remaining.len() <= 0 {
-            break;
-        };
         let mut to_del = remaining;
         if to_del.len() > MAX_DELETE_LIST {
             remaining = &to_del[MAX_DELETE_LIST..];
@@ -20,7 +17,7 @@ pub async fn delete_object_versions(api: ECStore, bucket: &str, to_del: &[Object
             remaining = &[];
         }
         let vc = BucketVersioningSys::get(bucket).await.expect("err!");
-        let deleted_objs = api.delete_objects(
+        let _deleted_objs = api.delete_objects(
             bucket,
             to_del.to_vec(),
             ObjectOptions {

ecstore/src/client/transition_api.rs

@@ -1,4 +1,11 @@
 #![allow(clippy::map_entry)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
 use bytes::Bytes;
 use futures::Future;
 use http::{HeaderMap, HeaderName};
@@ -300,7 +307,7 @@ impl TransitionClient {
             return Err(std::io::Error::other(s));
         }
 
-        let mut retryable: bool;
+        let retryable: bool;
         //let mut body_seeker: BufferReader;
         let mut req_retry = self.max_retries;
         let mut resp: http::Response<Body>;
@@ -348,11 +355,9 @@ impl TransitionClient {
                                 bucket_loc_cache.set(&metadata.bucket_name, &err_response.region);
                                 //continue;
                             }
-                        } else {
-                            if err_response.region != metadata.bucket_location {
-                                metadata.bucket_location = err_response.region.clone();
-                                //continue;
-                            }
+                        } else if err_response.region != metadata.bucket_location {
+                            metadata.bucket_location = err_response.region.clone();
+                            //continue;
                         }
                         return Err(std::io::Error::other(err_response));
                     }
@@ -374,10 +379,8 @@ impl TransitionClient {
         metadata: &mut RequestMetadata,
     ) -> Result<http::Request<Body>, std::io::Error> {
         let location = metadata.bucket_location.clone();
-        if location == "" {
-            if metadata.bucket_name != "" {
-                let location = self.get_bucket_location(&metadata.bucket_name).await?;
-            }
+        if location == "" && metadata.bucket_name != "" {
+            let location = self.get_bucket_location(&metadata.bucket_name).await?;
         }
 
         let is_makebucket = metadata.object_name == "" && method == http::Method::PUT && metadata.query_values.len() == 0;
@@ -538,7 +541,7 @@ impl TransitionClient {
     }
 
     pub fn set_user_agent(&self, req: &mut Builder) {
-        let mut headers = req.headers_mut().expect("err");
+        let headers = req.headers_mut().expect("err");
         headers.insert("User-Agent", C_USER_AGENT.parse().expect("err"));
         /*if self.app_info.app_name != "" && self.app_info.app_version != "" {
             headers.insert("User-Agent", C_USER_AGENT+" "+self.app_info.app_name+"/"+self.app_info.app_version);
@@ -771,7 +774,7 @@ impl TransitionCore {
             part_number: part_id,
             md5_base64: opts.md5_base64,
             sha256_hex: opts.sha256_hex,
-            size: size,
+            size,
             //sse:           opts.sse,
             stream_sha256: !opts.disable_content_sha256,
             custom_header: opts.custom_header,