add admin policy check for user operation

ecstore/src/config/storageclass.rs

@@ -189,13 +189,7 @@ pub fn lookup_config(kvs: &KVS, set_drive_count: usize) -> Result<Config> {
 
     validate_parity_inner(standard.parity, rrs.parity, set_drive_count)?;
 
-    let optimize = {
-        if let Ok(ev) = env::var(OPTIMIZE_ENV) {
-            Some(ev)
-        } else {
-            None
-        }
-    };
+    let optimize = { env::var(OPTIMIZE_ENV).ok() };
 
     let inline_block = {
         if let Ok(ev) = env::var(INLINE_BLOCK_ENV) {

ecstore/src/disk/local.rs

@@ -1232,7 +1232,7 @@ impl DiskAPI for LocalDisk {
                 .join(path)
                 .join(fi.data_dir.map_or("".to_string(), |dir| dir.to_string()))
                 .join(format!("part.{}", part.number));
-            let err = match self
+            let err = (self
                 .bitrot_verify(
                     &part_path,
                     erasure.shard_file_size(part.size),
@@ -1240,11 +1240,8 @@ impl DiskAPI for LocalDisk {
                     &checksum_info.hash,
                     erasure.shard_size(erasure.block_size),
                 )
-                .await
-            {
-                Ok(_) => None,
-                Err(err) => Some(err),
-            };
+                .await)
+                .err();
             resp.results[i] = conv_part_err_to_int(&err);
             if resp.results[i] == CHECK_PART_UNKNOWN {
                 if let Some(err) = err {

ecstore/src/heal/heal_ops.rs

@@ -406,10 +406,7 @@ impl HealSequence {
 
     async fn traverse_and_heal(h: Arc<HealSequence>) {
         let buckets_only = false;
-        let result = match Self::heal_items(h.clone(), buckets_only).await {
-            Ok(_) => None,
-            Err(err) => Some(err),
-        };
+        let result = (Self::heal_items(h.clone(), buckets_only).await).err();
         let _ = h.traverse_and_heal_done_tx.read().await.send(result).await;
     }
 

ecstore/src/peer.rs

@@ -80,12 +80,7 @@ impl S3PeerSys {
         let mut futures = Vec::with_capacity(self.clients.len());
         for client in self.clients.iter() {
             // client_clon
-            futures.push(async move {
-                match client.get_bucket_info(bucket, &BucketOptions::default()).await {
-                    Ok(_) => None,
-                    Err(err) => Some(err),
-                }
-            });
+            futures.push(async move { (client.get_bucket_info(bucket, &BucketOptions::default()).await).err() });
         }
         let errs = join_all(futures).await;
 

ecstore/src/set_disk.rs

@@ -1230,7 +1230,7 @@ impl SetDisks {
 
         let shallow_versions: Vec<Vec<FileMetaShallowVersion>> = metadata_shallow_versions.iter().flatten().cloned().collect();
 
-        let read_quorum = (fileinfos.len() + 1) / 2;
+        let read_quorum = fileinfos.len().div_ceil(2);
         let versions = merge_file_meta_versions(read_quorum, false, 1, &shallow_versions);
         let meta = FileMeta {
             versions,
@@ -5085,7 +5085,7 @@ fn is_object_dang_ling(
     });
 
     if !valid_meta.is_valid() {
-        let data_blocks = (meta_arr.len() + 1) / 2;
+        let data_blocks = meta_arr.len().div_ceil(2);
         if not_found_parts_errs > data_blocks {
             return Ok(valid_meta);
         }
@@ -5098,7 +5098,7 @@ fn is_object_dang_ling(
     }
 
     if valid_meta.deleted {
-        let data_blocks = (errs.len() + 1) / 2;
+        let data_blocks = errs.len().div_ceil(2);
         if not_found_meta_errs > data_blocks {
             return Ok(valid_meta);
         }
@@ -5313,7 +5313,7 @@ async fn disks_with_all_parts(
             if let Some(data) = &meta.data {
                 let checksum_info = meta.erasure.get_checksum_info(meta.parts[0].number);
                 let data_len = data.len();
-                let verify_err = match bitrot_verify(
+                let verify_err = (bitrot_verify(
                     Box::new(Cursor::new(data.clone())),
                     data_len,
                     meta.erasure.shard_file_size(meta.size),
@@ -5321,11 +5321,8 @@ async fn disks_with_all_parts(
                     checksum_info.hash,
                     meta.erasure.shard_size(meta.erasure.block_size),
                 )
-                .await
-                {
-                    Ok(_) => None,
-                    Err(err) => Some(err),
-                };
+                .await)
+                    .err();
 
                 if let Some(vec) = data_errs_by_part.get_mut(&0) {
                     if index < vec.len() {

ecstore/src/store_list_objects.rs

@@ -698,7 +698,7 @@ impl ECStore {
                 futures.push(async move {
                     let mut ask_disks = get_list_quorum(&opts.ask_disks, set.set_drive_count as i32);
                     if ask_disks == -1 {
-                        let new_disks = get_quorum_disks(&disks, &infos, (disks.len() + 1) / 2);
+                        let new_disks = get_quorum_disks(&disks, &infos, disks.len().div_ceil(2));
                         if !new_disks.is_empty() {
                             disks = new_disks;
                         } else {
@@ -1156,13 +1156,7 @@ async fn merge_entry_channels(
             if let Some(entry) = &best {
                 let mut versions = Vec::with_capacity(to_merge.len() + 1);
 
-                let mut has_xl = {
-                    if let Ok(meta) = entry.clone().xl_meta() {
-                        Some(meta)
-                    } else {
-                        None
-                    }
-                };
+                let mut has_xl = { entry.clone().xl_meta().ok() };
 
                 if let Some(x) = &has_xl {
                     versions.push(x.versions.clone());
@@ -1229,7 +1223,7 @@ impl SetDisks {
 
         let mut ask_disks = get_list_quorum(&opts.ask_disks, self.set_drive_count as i32);
         if ask_disks == -1 {
-            let new_disks = get_quorum_disks(&disks, &infos, (disks.len() + 1) / 2);
+            let new_disks = get_quorum_disks(&disks, &infos, disks.len().div_ceil(2));
             if !new_disks.is_empty() {
                 disks = new_disks;
                 ask_disks = 1;