fix(lifecycle): bind delete replication admission (#5621)

crates/ecstore/src/bucket/lifecycle/replication_sink.rs

@@ -15,15 +15,14 @@
 use rustfs_common::metrics::IlmAction;
 
 use crate::bucket::lifecycle::lifecycle::ObjectOpts;
+pub(crate) use crate::bucket::replication::ReplicationStatusType;
 #[cfg(test)]
-pub(crate) use crate::bucket::replication::ReplicateTargetDecision;
+pub(crate) use crate::bucket::replication::VersionPurgeStatusType;
 pub(crate) use crate::bucket::replication::{
-    ReplicateDecision, ReplicationState, ReplicationStatusType, VersionPurgeStatusType, replication_state_to_filemeta,
-    replication_statuses_map, version_purge_statuses_map,
+    DeleteReplicationConfigSnapshot, ReplicationObjectBridge, replication_state_to_filemeta,
 };
 use crate::bucket::replication::{ReplicationLifecycleBridge, ReplicationLifecycleConfig};
-use crate::object_api::{ObjectInfo, ObjectOptions};
-use crate::storage_api_contracts::object::{DeletedObject, ObjectToDelete};
+use crate::storage_api_contracts::object::DeletedObject;
 
 pub(crate) type LifecycleReplicationConfig = ReplicationLifecycleConfig;
 
@@ -57,15 +56,6 @@ pub(crate) fn lifecycle_action_waits_for_replication(action: IlmAction) -> bool
     )
 }
 
-pub(crate) async fn check_delete_replication(
-    bucket: &str,
-    object: ObjectToDelete,
-    source: &ObjectInfo,
-    opts: &ObjectOptions,
-) -> ReplicateDecision {
-    ReplicationLifecycleBridge::check_delete_replication(bucket, &object, source, opts).await
-}
-
 pub(crate) async fn schedule_delete(bucket: String, delete_object: DeletedObject) {
     ReplicationLifecycleBridge::schedule_delete(bucket, delete_object).await;
 }
@@ -74,7 +64,16 @@ pub(crate) async fn schedule_delete(bucket: String, delete_object: DeletedObject
 mod tests {
     use std::collections::HashMap;
 
+    use crate::bucket::replication::{DeleteReplicationConfigSnapshot, ReplicationObjectBridge};
+    use crate::object_api::{ObjectInfo, ObjectOptions};
+    use crate::storage_api_contracts::object::ObjectToDelete;
     use rustfs_common::metrics::IlmAction;
+    use s3s::dto::{
+        BucketVersioningStatus, DeleteMarkerReplication, DeleteMarkerReplicationStatus, DeleteReplication,
+        DeleteReplicationStatus, Destination, ReplicationConfiguration, ReplicationRule, ReplicationRuleStatus,
+        VersioningConfiguration,
+    };
+    use uuid::Uuid;
 
     use super::*;
 
@@ -139,4 +138,97 @@ mod tests {
         assert!(lifecycle_action_waits_for_replication(IlmAction::TransitionVersionAction));
         assert!(!lifecycle_action_waits_for_replication(IlmAction::NoneAction));
     }
+
+    #[test]
+    fn lifecycle_delete_admission_uses_marker_and_version_switches_for_all_purges() {
+        for marker_enabled in [false, true] {
+            for purge_enabled in [false, true] {
+                let snapshot = DeleteReplicationConfigSnapshot::from_configs_for_test(
+                    VersioningConfiguration {
+                        status: Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)),
+                        ..Default::default()
+                    },
+                    Some(ReplicationConfiguration {
+                        role: String::new(),
+                        rules: vec![ReplicationRule {
+                            delete_marker_replication: Some(DeleteMarkerReplication {
+                                status: Some(if marker_enabled {
+                                    DeleteMarkerReplicationStatus::from_static(DeleteMarkerReplicationStatus::ENABLED)
+                                } else {
+                                    DeleteMarkerReplicationStatus::from_static(DeleteMarkerReplicationStatus::DISABLED)
+                                }),
+                            }),
+                            delete_replication: Some(DeleteReplication {
+                                status: if purge_enabled {
+                                    DeleteReplicationStatus::from_static(DeleteReplicationStatus::ENABLED)
+                                } else {
+                                    DeleteReplicationStatus::from_static(DeleteReplicationStatus::DISABLED)
+                                },
+                            }),
+                            destination: Destination {
+                                bucket: "arn:rustfs:replication:target".to_string(),
+                                ..Default::default()
+                            },
+                            existing_object_replication: None,
+                            filter: None,
+                            id: Some("lifecycle-delete-switches".to_string()),
+                            prefix: Some(String::new()),
+                            priority: Some(1),
+                            source_selection_criteria: None,
+                            status: ReplicationRuleStatus::from_static(ReplicationRuleStatus::ENABLED),
+                        }],
+                    }),
+                );
+                let source = ObjectInfo {
+                    bucket: "bucket".to_string(),
+                    name: "logs/object".to_string(),
+                    ..Default::default()
+                };
+                let marker = ObjectToDelete {
+                    object_name: source.name.clone(),
+                    ..Default::default()
+                };
+                let marker_opts = ObjectOptions {
+                    versioned: true,
+                    ..Default::default()
+                };
+                assert_eq!(
+                    ReplicationObjectBridge::check_delete_with_snapshot(&marker, &source, &marker_opts, false, &snapshot)
+                        .replicate_any(),
+                    marker_enabled
+                );
+
+                for delete_marker in [false, true] {
+                    for version_id in [Uuid::new_v4(), Uuid::nil()] {
+                        let purge = ObjectToDelete {
+                            object_name: source.name.clone(),
+                            version_id: Some(version_id),
+                            ..Default::default()
+                        };
+                        let purge_source = ObjectInfo {
+                            delete_marker,
+                            ..source.clone()
+                        };
+                        let purge_opts = ObjectOptions {
+                            version_id: Some(version_id.to_string()),
+                            versioned: true,
+                            ..Default::default()
+                        };
+                        assert_eq!(
+                            ReplicationObjectBridge::check_delete_with_snapshot(
+                                &purge,
+                                &purge_source,
+                                &purge_opts,
+                                false,
+                                &snapshot,
+                            )
+                            .replicate_any(),
+                            purge_enabled,
+                            "delete marker={delete_marker}, version_id={version_id}"
+                        );
+                    }
+                }
+            }
+        }
+    }
 }