feat(replication): bound DeleteObjects queue admission (#5637)

feat(replication): batch DeleteObjects queue admission

crates/replication/src/queue.rs

@@ -39,6 +39,32 @@ impl ReplicationQueueAdmission {
     }
 }
 
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct ReplicationBatchAdmission {
+    pub total: usize,
+    pub queued: usize,
+    pub missed: usize,
+}
+
+impl ReplicationBatchAdmission {
+    pub fn record(&mut self, admission: ReplicationQueueAdmission) {
+        self.total += 1;
+        match admission {
+            ReplicationQueueAdmission::Queued => self.queued += 1,
+            ReplicationQueueAdmission::Missed | ReplicationQueueAdmission::Skipped => self.missed += 1,
+        }
+    }
+
+    pub fn outcome(self) -> &'static str {
+        match (self.queued, self.missed) {
+            (0, 0) => "empty",
+            (_, 0) => "all_queued",
+            (0, _) => "all_missed",
+            _ => "partial",
+        }
+    }
+}
+
 pub fn mrf_save_admission(saved: bool) -> ReplicationQueueAdmission {
     if saved {
         ReplicationQueueAdmission::Queued
@@ -267,7 +293,8 @@ mod tests {
     use uuid::Uuid;
 
     use super::{
-        ReplicationHealQueueAction, ReplicationOperation, ReplicationPriority, ReplicationQueueAdmission, ReplicationWorkerQueue,
+        ReplicationBatchAdmission, ReplicationHealQueueAction, ReplicationOperation, ReplicationPriority,
+        ReplicationQueueAdmission, ReplicationWorkerQueue,
     };
     use crate::storage_api::DeletedObject;
     use crate::{
@@ -297,6 +324,25 @@ mod tests {
         assert_eq!(mrf_save_admission(false), ReplicationQueueAdmission::Missed);
     }
 
+    #[test]
+    fn replication_batch_admission_classifies_all_partial_and_empty_batches() {
+        let mut all = ReplicationBatchAdmission::default();
+        all.record(ReplicationQueueAdmission::Queued);
+        assert_eq!(all.outcome(), "all_queued");
+
+        let mut partial = ReplicationBatchAdmission::default();
+        partial.record(ReplicationQueueAdmission::Queued);
+        partial.record(ReplicationQueueAdmission::Missed);
+        assert_eq!(partial.outcome(), "partial");
+
+        let mut all_missed = ReplicationBatchAdmission::default();
+        all_missed.record(ReplicationQueueAdmission::Missed);
+        assert_eq!(all_missed.outcome(), "all_missed");
+
+        let empty = ReplicationBatchAdmission::default();
+        assert_eq!(empty.outcome(), "empty");
+    }
+
     #[test]
     fn worker_queue_routes_heal_and_existing_objects_to_mrf() {
         assert_eq!(worker_queue_for_replication_type(&ReplicationType::Heal), ReplicationWorkerQueue::Mrf);