fix:rm object versions (#385)

crates/ecstore/src/set_disk.rs

@@ -17,6 +17,8 @@
 
 use crate::bitrot::{create_bitrot_reader, create_bitrot_writer};
 use crate::bucket::lifecycle::lifecycle::TRANSITION_COMPLETE;
+use crate::bucket::versioning::VersioningApi;
+use crate::bucket::versioning_sys::BucketVersioningSys;
 use crate::client::{object_api_utils::extract_etag, transition_api::ReaderImpl};
 use crate::disk::STORAGE_FORMAT_FILE;
 use crate::disk::error_reduce::{OBJECT_OP_IGNORED_ERRS, reduce_read_quorum_errs, reduce_write_quorum_errs};
@@ -2027,6 +2029,24 @@ impl SetDisks {
 
         Ok((fi, parts_metadata, op_online_disks))
     }
+    async fn get_object_info_and_quorum(&self, bucket: &str, object: &str, opts: &ObjectOptions) -> Result<(ObjectInfo, usize)> {
+        let (fi, _, _) = self.get_object_fileinfo(bucket, object, opts, false).await?;
+
+        let write_quorum = fi.write_quorum(self.default_write_quorum());
+
+        let oi = ObjectInfo::from_file_info(&fi, bucket, object, opts.versioned || opts.version_suspended);
+        // TODO: replicatio
+
+        if fi.deleted {
+            if opts.version_id.is_none() || opts.delete_marker {
+                return Err(to_object_err(StorageError::FileNotFound, vec![bucket, object]));
+            } else {
+                return Err(to_object_err(StorageError::MethodNotAllowed, vec![bucket, object]));
+            }
+        }
+
+        Ok((oi, write_quorum))
+    }
 
     #[allow(clippy::too_many_arguments)]
     #[tracing::instrument(
@@ -3769,39 +3789,47 @@ impl StorageAPI for SetDisks {
         }
 
         // Per-object guards to keep until function end
-        let mut _guards: Vec<Option<rustfs_lock::LockGuard>> = Vec::with_capacity(objects.len());
+        let mut _guards: HashMap<String, rustfs_lock::LockGuard> = HashMap::new();
         // Acquire locks for all objects first; mark errors for failures
         for (i, dobj) in objects.iter().enumerate() {
-            match self
-                .namespace_lock
-                .lock_guard(&dobj.object_name, &self.locker_owner, Duration::from_secs(5), Duration::from_secs(10))
-                .await?
-            {
-                Some(g) => _guards.push(Some(g)),
-                None => {
-                    del_errs[i] = Some(Error::other("can not get lock. please retry"));
-                    _guards.push(None);
+            if !_guards.contains_key(&dobj.object_name) {
+                match self
+                    .namespace_lock
+                    .lock_guard(&dobj.object_name, &self.locker_owner, Duration::from_secs(5), Duration::from_secs(10))
+                    .await?
+                {
+                    Some(g) => {
+                        _guards.insert(dobj.object_name.clone(), g);
+                    }
+                    None => {
+                        del_errs[i] = Some(Error::other("can not get lock. please retry"));
+                    }
                 }
             }
         }
 
         // let mut del_fvers = Vec::with_capacity(objects.len());
 
+        let ver_cfg = BucketVersioningSys::get(bucket).await.unwrap_or_default();
+
         let mut vers_map: HashMap<&String, FileInfoVersions> = HashMap::new();
 
         for (i, dobj) in objects.iter().enumerate() {
             let mut vr = FileInfo {
                 name: dobj.object_name.clone(),
                 version_id: dobj.version_id,
+                idx: i,
                 ..Default::default()
             };
 
-            // 删除
-            del_objects[i].object_name.clone_from(&vr.name);
-            del_objects[i].version_id = vr.version_id.map(|v| v.to_string());
+            vr.set_tier_free_version_id(&Uuid::new_v4().to_string());
 
-            if del_objects[i].version_id.is_none() {
-                let (suspended, versioned) = (opts.version_suspended, opts.versioned);
+            // 删除
+            // del_objects[i].object_name.clone_from(&vr.name);
+            // del_objects[i].version_id = vr.version_id.map(|v| v.to_string());
+
+            if dobj.version_id.is_none() {
+                let (suspended, versioned) = (ver_cfg.suspended(), ver_cfg.prefix_enabled(dobj.object_name.as_str()));
                 if suspended || versioned {
                     vr.mod_time = Some(OffsetDateTime::now_utc());
                     vr.deleted = true;
@@ -3842,15 +3870,22 @@ impl StorageAPI for SetDisks {
             }
 
             // Only add to vers_map if we hold the lock
-            if _guards[i].is_some() {
+            if _guards.contains_key(&dobj.object_name) {
                 vers_map.insert(&dobj.object_name, v);
             }
         }
 
         let mut vers = Vec::with_capacity(vers_map.len());
 
-        for (_, ver) in vers_map {
-            vers.push(ver);
+        for (_, mut fi_vers) in vers_map {
+            fi_vers.versions.sort_by(|a, b| a.deleted.cmp(&b.deleted));
+            fi_vers.versions.reverse();
+
+            if let Some(index) = fi_vers.versions.iter().position(|fi| fi.deleted) {
+                fi_vers.versions.truncate(index + 1);
+            }
+
+            vers.push(fi_vers);
         }
 
         let disks = self.disks.read().await;
@@ -3906,6 +3941,61 @@ impl StorageAPI for SetDisks {
             return Ok(ObjectInfo::default());
         }
 
+        let (oi, write_quorum) = match self.get_object_info_and_quorum(bucket, object, &opts).await {
+            Ok((oi, wq)) => (oi, wq),
+            Err(e) => {
+                return Err(to_object_err(e, vec![bucket, object]));
+            }
+        };
+
+        let mark_delete = oi.version_id.is_some();
+
+        let mut delete_marker = opts.versioned;
+
+        let mod_time = if let Some(mt) = opts.mod_time {
+            mt
+        } else {
+            OffsetDateTime::now_utc()
+        };
+
+        let find_vid = Uuid::new_v4();
+
+        if mark_delete && (opts.versioned || opts.version_suspended) {
+            if !delete_marker {
+                delete_marker = opts.version_suspended && opts.version_id.is_none();
+            }
+
+            let mut fi = FileInfo {
+                name: object.to_string(),
+                deleted: delete_marker,
+                mark_deleted: mark_delete,
+                mod_time: Some(mod_time),
+                ..Default::default() // TODO: replication
+            };
+
+            fi.set_tier_free_version_id(&find_vid.to_string());
+
+            if opts.skip_free_version {
+                fi.set_skip_tier_free_version();
+            }
+
+            fi.version_id = if let Some(vid) = opts.version_id {
+                Some(Uuid::parse_str(vid.as_str())?)
+            } else if opts.versioned {
+                Some(Uuid::new_v4())
+            } else {
+                None
+            };
+
+            self.delete_object_version(bucket, object, &fi, opts.delete_marker)
+                .await
+                .map_err(|e| to_object_err(e, vec![bucket, object]))?;
+
+            return Ok(ObjectInfo::from_file_info(&fi, bucket, object, opts.versioned || opts.version_suspended));
+        }
+
+        let version_id = opts.version_id.as_ref().and_then(|v| Uuid::parse_str(v).ok());
+
         // Create a single object deletion request
         let mut vr = FileInfo {
             name: object.to_string(),