Merge pull request #114 from rustfs/dev

cargo fmt

common/protos/src/generated/flatbuffers_generated/models.rs

@@ -1,10 +1,9 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 
-
 // @generated
 
-use core::mem;
 use core::cmp::Ordering;
+use core::mem;
 
 extern crate flatbuffers;
 use self::flatbuffers::{EndianScalar, Follow};
@@ -12,112 +11,114 @@ use self::flatbuffers::{EndianScalar, Follow};
 #[allow(unused_imports, dead_code)]
 pub mod models {
 
-  use core::mem;
+    use core::cmp::Ordering;
-  use core::cmp::Ordering;
+    use core::mem;
 
-  extern crate flatbuffers;
+    extern crate flatbuffers;
-  use self::flatbuffers::{EndianScalar, Follow};
+    use self::flatbuffers::{EndianScalar, Follow};
 
-pub enum PingBodyOffset {}
+    pub enum PingBodyOffset {}
-#[derive(Copy, Clone, PartialEq)]
+    #[derive(Copy, Clone, PartialEq)]
 
-pub struct PingBody<'a> {
+    pub struct PingBody<'a> {
-  pub _tab: flatbuffers::Table<'a>,
+        pub _tab: flatbuffers::Table<'a>,
-}
-
-impl<'a> flatbuffers::Follow<'a> for PingBody<'a> {
-  type Inner = PingBody<'a>;
-  #[inline]
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self { _tab: flatbuffers::Table::new(buf, loc) }
-  }
-}
-
-impl<'a> PingBody<'a> {
-  pub const VT_PAYLOAD: flatbuffers::VOffsetT = 4;
-
-  pub const fn get_fully_qualified_name() -> &'static str {
-    "models.PingBody"
-  }
-
-  #[inline]
-  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
-    PingBody { _tab: table }
-  }
-  #[allow(unused_mut)]
-  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
-    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
-    args: &'args PingBodyArgs<'args>
-  ) -> flatbuffers::WIPOffset<PingBody<'bldr>> {
-    let mut builder = PingBodyBuilder::new(_fbb);
-    if let Some(x) = args.payload { builder.add_payload(x); }
-    builder.finish()
-  }
-
-
-  #[inline]
-  pub fn payload(&self) -> Option<flatbuffers::Vector<'a, u8>> {
-    // Safety:
-    // Created from valid Table for this object
-    // which contains a valid value in this slot
-    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(PingBody::VT_PAYLOAD, None)}
-  }
-}
-
-impl flatbuffers::Verifiable for PingBody<'_> {
-  #[inline]
-  fn run_verifier(
-    v: &mut flatbuffers::Verifier, pos: usize
-  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-    use self::flatbuffers::Verifiable;
-    v.visit_table(pos)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("payload", Self::VT_PAYLOAD, false)?
-     .finish();
-    Ok(())
-  }
-}
-pub struct PingBodyArgs<'a> {
-    pub payload: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-}
-impl<'a> Default for PingBodyArgs<'a> {
-  #[inline]
-  fn default() -> Self {
-    PingBodyArgs {
-      payload: None,
     }
-  }
-}
 
-pub struct PingBodyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
+    impl<'a> flatbuffers::Follow<'a> for PingBody<'a> {
-  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+        type Inner = PingBody<'a>;
-  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+        #[inline]
-}
+        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> PingBodyBuilder<'a, 'b, A> {
+            Self {
-  #[inline]
+                _tab: flatbuffers::Table::new(buf, loc),
-  pub fn add_payload(&mut self, payload: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
+            }
-    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PingBody::VT_PAYLOAD, payload);
+        }
-  }
-  #[inline]
-  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PingBodyBuilder<'a, 'b, A> {
-    let start = _fbb.start_table();
-    PingBodyBuilder {
-      fbb_: _fbb,
-      start_: start,
     }
-  }
-  #[inline]
-  pub fn finish(self) -> flatbuffers::WIPOffset<PingBody<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    flatbuffers::WIPOffset::new(o.value())
-  }
-}
 
-impl core::fmt::Debug for PingBody<'_> {
+    impl<'a> PingBody<'a> {
-  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        pub const VT_PAYLOAD: flatbuffers::VOffsetT = 4;
-    let mut ds = f.debug_struct("PingBody");
-      ds.field("payload", &self.payload());
-      ds.finish()
-  }
-}
-}  // pub mod models
 
+        pub const fn get_fully_qualified_name() -> &'static str {
+            "models.PingBody"
+        }
+
+        #[inline]
+        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+            PingBody { _tab: table }
+        }
+        #[allow(unused_mut)]
+        pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
+            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            args: &'args PingBodyArgs<'args>,
+        ) -> flatbuffers::WIPOffset<PingBody<'bldr>> {
+            let mut builder = PingBodyBuilder::new(_fbb);
+            if let Some(x) = args.payload {
+                builder.add_payload(x);
+            }
+            builder.finish()
+        }
+
+        #[inline]
+        pub fn payload(&self) -> Option<flatbuffers::Vector<'a, u8>> {
+            // Safety:
+            // Created from valid Table for this object
+            // which contains a valid value in this slot
+            unsafe {
+                self._tab
+                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(PingBody::VT_PAYLOAD, None)
+            }
+        }
+    }
+
+    impl flatbuffers::Verifiable for PingBody<'_> {
+        #[inline]
+        fn run_verifier(v: &mut flatbuffers::Verifier, pos: usize) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+            use self::flatbuffers::Verifiable;
+            v.visit_table(pos)?
+                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("payload", Self::VT_PAYLOAD, false)?
+                .finish();
+            Ok(())
+        }
+    }
+    pub struct PingBodyArgs<'a> {
+        pub payload: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+    }
+    impl<'a> Default for PingBodyArgs<'a> {
+        #[inline]
+        fn default() -> Self {
+            PingBodyArgs { payload: None }
+        }
+    }
+
+    pub struct PingBodyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
+        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    }
+    impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> PingBodyBuilder<'a, 'b, A> {
+        #[inline]
+        pub fn add_payload(&mut self, payload: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+            self.fbb_
+                .push_slot_always::<flatbuffers::WIPOffset<_>>(PingBody::VT_PAYLOAD, payload);
+        }
+        #[inline]
+        pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PingBodyBuilder<'a, 'b, A> {
+            let start = _fbb.start_table();
+            PingBodyBuilder {
+                fbb_: _fbb,
+                start_: start,
+            }
+        }
+        #[inline]
+        pub fn finish(self) -> flatbuffers::WIPOffset<PingBody<'a>> {
+            let o = self.fbb_.end_table(self.start_);
+            flatbuffers::WIPOffset::new(o.value())
+        }
+    }
+
+    impl core::fmt::Debug for PingBody<'_> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            let mut ds = f.debug_struct("PingBody");
+            ds.field("payload", &self.payload());
+            ds.finish()
+        }
+    }
+} // pub mod models

ecstore/src/cache_value/metacache_set.rs

@@ -152,7 +152,7 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
                 None => {
                     at_eof += 1;
                     continue;
-                },
+                }
             };
             // If no current, add it.
             if current.name.is_empty() {
@@ -177,7 +177,7 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
                 continue;
             }
             // We got a new, better current.
-			// Clear existing entries.
+            // Clear existing entries.
             top_entries.clear();
             agree += 1;
             top_entries.insert(i, entry.clone());
@@ -189,16 +189,14 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
                 finished_fn(&errs);
             }
             let mut combined_err = Vec::new();
-            errs.iter().zip(opts.disks.iter()).for_each(|(err, disk)| {
+            errs.iter().zip(opts.disks.iter()).for_each(|(err, disk)| match (err, disk) {
-                match (err, disk) {
+                (Some(err), Some(disk)) => {
-                    (Some(err), Some(disk)) => {
+                    combined_err.push(format!("drive {} returned: {}", disk.to_string(), err));
-                        combined_err.push(format!("drive {} returned: {}", disk.to_string(), err));
-                    },
-                    (Some(err), None) => {
-                        combined_err.push(err.to_string());
-                    },
-                    _ => {},
                 }
+                (Some(err), None) => {
+                    combined_err.push(err.to_string());
+                }
+                _ => {}
             });
 
             return Err(Error::from_string(combined_err.join(", ")));

ecstore/src/config/storageclass.rs

@@ -253,12 +253,12 @@ pub fn parse_storage_class(env: &str) -> Result<StorageClass> {
 
 // ValidateParity validates standard storage class parity.
 pub fn validate_parity(ss_parity: usize, set_drive_count: usize) -> Result<()> {
-    if ss_parity > 0 && ss_parity < MIN_PARITY_DRIVES {
+    // if ss_parity > 0 && ss_parity < MIN_PARITY_DRIVES {
-        return Err(Error::msg(format!(
+    //     return Err(Error::msg(format!(
-            "parity {} should be greater than or equal to {}",
+    //         "parity {} should be greater than or equal to {}",
-            ss_parity, MIN_PARITY_DRIVES
+    //         ss_parity, MIN_PARITY_DRIVES
-        )));
+    //     )));
-    }
+    // }
 
     if ss_parity > set_drive_count / 2 {
         return Err(Error::msg(format!(
@@ -273,21 +273,21 @@ pub fn validate_parity(ss_parity: usize, set_drive_count: usize) -> Result<()> {
 
 // Validates the parity drives.
 pub fn validate_parity_inner(ss_parity: usize, rrs_parity: usize, set_drive_count: usize) -> Result<()> {
-    if ss_parity > 0 && ss_parity < MIN_PARITY_DRIVES {
+    // if ss_parity > 0 && ss_parity < MIN_PARITY_DRIVES {
-        return Err(Error::msg(format!(
+    //     return Err(Error::msg(format!(
-            "Standard storage class parity {} should be greater than or equal to {}",
+    //         "Standard storage class parity {} should be greater than or equal to {}",
-            ss_parity, MIN_PARITY_DRIVES
+    //         ss_parity, MIN_PARITY_DRIVES
-        )));
+    //     )));
-    }
+    // }
 
     // RRS parity drives should be greater than or equal to minParityDrives.
     // Parity below minParityDrives is not supported.
-    if rrs_parity > 0 && rrs_parity < MIN_PARITY_DRIVES {
+    // if rrs_parity > 0 && rrs_parity < MIN_PARITY_DRIVES {
-        return Err(Error::msg(format!(
+    //     return Err(Error::msg(format!(
-            "Reduced redundancy storage class parity {} should be greater than or equal to {}",
+    //         "Reduced redundancy storage class parity {} should be greater than or equal to {}",
-            rrs_parity, MIN_PARITY_DRIVES
+    //         rrs_parity, MIN_PARITY_DRIVES
-        )));
+    //     )));
-    }
+    // }
 
     if set_drive_count > 2 {
         if ss_parity > set_drive_count / 2 {

ecstore/src/disk/error.rs

@@ -426,9 +426,9 @@ pub fn is_all_not_found(errs: &[Option<Error>]) -> bool {
         if let Some(err) = err {
             if let Some(err) = err.downcast_ref::<DiskError>() {
                 match err {
-                    DiskError::FileNotFound | DiskError::VolumeNotFound | &DiskError::FileVersionNotFound =>{
+                    DiskError::FileNotFound | DiskError::VolumeNotFound | &DiskError::FileVersionNotFound => {
                         continue;
-                    },
+                    }
                     _ => return false,
                 }
             }

ecstore/src/heal/background_heal_ops.rs

@@ -8,11 +8,7 @@ use tokio::{
     },
 };
 
-use crate::{
+use crate::{error::Error, heal::heal_ops::NOP_HEAL, utils::path::SLASH_SEPARATOR};
-    error::Error,
-    heal::heal_ops::NOP_HEAL,
-    utils::path::SLASH_SEPARATOR,
-};
 
 use super::{
     heal_commands::{HealOpts, HealResultItem},

ecstore/src/heal/heal_commands.rs

@@ -421,12 +421,12 @@ async fn load_healing_tracker(disk: &Option<DiskStore>) -> Result<HealingTracker
                 )));
             }
             healing_tracker.id = disk_id;
-            return Ok(healing_tracker);
+            Ok(healing_tracker)
         } else {
-            return Err(Error::from_string("loadHealingTracker: disk not have id"));
+            Err(Error::from_string("loadHealingTracker: disk not have id"))
         }
     } else {
-        return Err(Error::from_string("loadHealingTracker: nil drive given"));
+        Err(Error::from_string("loadHealingTracker: nil drive given"))
     }
 }
 

ecstore/src/heal/heal_ops.rs

@@ -335,7 +335,7 @@ pub async fn heal_sequence_start(h: Arc<HealSequence>) {
                     }
                 },
                 None => {
-                    return;
+
                 }
             }
 
@@ -462,7 +462,7 @@ impl AllHealState {
             }
         }
 
-        return (None, false);
+        (None, false)
     }
 
     async fn get_heal_sequence(&self, path: &str) -> Option<HealSequence> {

ecstore/src/store.rs

@@ -1797,7 +1797,7 @@ async fn has_space_for(dis: &Vec<Option<DiskInfo>>, size: i64) -> Result<bool> {
         }
     }
 
-    if disks_num < dis.len() / 2 || disks_num <= 0 {
+    if disks_num < dis.len() / 2 || disks_num == 0 {
         return Err(Error::msg(format!(
             "not enough online disks to calculate the available space,need {}, found {}",
             (dis.len() / 2) + 1,