RamenDR · parikshithb · May 21, 2025 · May 21, 2025 · May 21, 2025 · May 21, 2025
@@ -77,6 +77,18 @@ func (a ApplicationSet) Undeploy(ctx types.TestContext) error {
 		return err
 	}
 
+	if err := util.WaitForApplicationSetDelete(ctx, ctx.Env().Hub, name, managementNamespace); err != nil {
+		return err
+	}
+
+	if err := util.WaitForConfigMapDelete(ctx, ctx.Env().Hub, name, managementNamespace); err != nil {
+		return err
+	}
+
+	if err := util.WaitForPlacementDelete(ctx, ctx.Env().Hub, name, managementNamespace); err != nil {
+		return err
+	}
+
 	log.Info("Workload undeployed")
 
 	return nil

@@ -431,7 +431,7 @@ func DeleteDiscoveredApps(ctx types.TestContext, cluster types.Cluster, namespac
 	}
 
 	cmd := exec.Command("kubectl", "delete", "-k", tempDir, "-n", namespace,
-		"--kubeconfig", cluster.Kubeconfig, "--timeout=5m", "--ignore-not-found=true")
+		"--kubeconfig", cluster.Kubeconfig, "--wait=false", "--ignore-not-found=true")
 
 	if out, err := cmd.Output(); err != nil {
 		if ee, ok := err.(*exec.ExitError); ok {

@@ -80,6 +80,7 @@ func (d DiscoveredApp) Undeploy(ctx types.TestContext) error {
 		appNamespace, ctx.Workload().GetAppName(), ctx.Env().C1.Name, ctx.Env().C2.Name)
 
 	// delete app on both clusters
+
 	if err := DeleteDiscoveredApps(ctx, ctx.Env().C1, appNamespace); err != nil {
 		return err
 	}
@@ -89,6 +90,7 @@ func (d DiscoveredApp) Undeploy(ctx types.TestContext) error {
 	}
 
 	// delete namespace on both clusters
+
 	if err := util.DeleteNamespace(ctx, ctx.Env().C1, appNamespace); err != nil {
 		return err
 	}
@@ -97,6 +99,16 @@ func (d DiscoveredApp) Undeploy(ctx types.TestContext) error {
 		return err
 	}
 
+	// wait for namespace to be deleted on both clusters
+
+	if err := util.WaitForNamespaceDelete(ctx, ctx.Env().C1, appNamespace); err != nil {
+		return err
+	}
+
+	if err := util.WaitForNamespaceDelete(ctx, ctx.Env().C2, appNamespace); err != nil {
+		return err
+	}
+
 	log.Info("Workload undeployed")
 
 	return nil

@@ -112,6 +112,10 @@ func (s Subscription) Undeploy(ctx types.TestContext) error {
 		return err
 	}
 
+	if err := util.WaitForNamespaceDelete(ctx, ctx.Env().Hub, managementNamespace); err != nil {
+		return err
+	}
+
 	log.Info("Workload undeployed")

 	return nil

@@ -127,8 +127,7 @@ func DisableProtection(ctx types.TestContext) error {
 		return err
 	}
 
-	err = waitDRPCDeleted(ctx, managementNamespace, drpcName)
-	if err != nil {
+	if err := util.WaitForDRPCDelete(ctx, ctx.Env().Hub, drpcName, managementNamespace); err != nil {
 		return err
 	}
 

@@ -96,10 +96,6 @@ func DisableProtectionDiscoveredApps(ctx types.TestContext) error {
 		return err
 	}
 
-	if err := waitDRPCDeleted(ctx, managementNamespace, drpcName); err != nil {
-		return err
-	}
-
 	// delete placement
 	if err := deployers.DeletePlacement(ctx, placementName, managementNamespace); err != nil {
 		return err
@@ -110,6 +106,19 @@ func DisableProtectionDiscoveredApps(ctx types.TestContext) error {
 		return err
 	}
 
+	if err := util.WaitForDRPCDelete(ctx, ctx.Env().Hub, drpcName, managementNamespace); err != nil {
+		return err
+	}
+
+	if err := util.WaitForPlacementDelete(ctx, ctx.Env().Hub, placementName, managementNamespace); err != nil {
+		return err
+	}
+
+	if err := util.WaitForManagedClusterSetBindingDelete(ctx, ctx.Env().Hub, config.ClusterSet,
+		managementNamespace); err != nil {
+		return err
+	}
+
 	log.Info("Workload unprotected")
 
 	return nil

@@ -7,7 +7,6 @@ import (
 	"fmt"
 
 	ramen "github.com/ramendr/ramen/api/v1alpha1"
-	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -103,30 +102,6 @@ func getTargetCluster(
 	return targetCluster, nil
 }
 
-func waitDRPCDeleted(ctx types.TestContext, namespace string, name string) error {
-	log := ctx.Logger()
-	hub := ctx.Env().Hub
-
-	log.Debugf("Waiting until drpc \"%s/%s\" is deleted in cluster %q", namespace, name, hub.Name)
-
-	for {
-		_, err := getDRPC(ctx, namespace, name)
-		if err != nil {
-			if k8serrors.IsNotFound(err) {
-				log.Debugf("drpc \"%s/%s\" is deleted in cluster %q", namespace, name, hub.Name)
-
-				return nil
-			}
-
-			log.Debugf("Failed to get drpc \"%s/%s\" in cluster %q: %s", namespace, name, hub.Name, err)
-		}
-
-		if err := util.Sleep(ctx.Context(), util.RetryInterval); err != nil {
-			return fmt.Errorf("drpc %q is not deleted in cluster %q: %w", name, hub.Name, err)
-		}
-	}
-}
-
 // nolint:unparam
 func waitDRPCProgression(
 	ctx types.TestContext,

@@ -26,7 +26,11 @@ func EnsureChannelDeleted(ctx types.Context) error {
 		return err
 	}
 
-	return DeleteNamespace(ctx, ctx.Env().Hub, ctx.Config().Channel.Namespace)
+	if err := DeleteNamespace(ctx, ctx.Env().Hub, ctx.Config().Channel.Namespace); err != nil {
+		return err
+	}
+
+	return WaitForNamespaceDelete(ctx, ctx.Env().Hub, ctx.Config().Channel.Namespace)
 }
 
 func createChannel(ctx types.Context) error {

@@ -4,9 +4,6 @@
 package util
 
 import (
-	"fmt"
-	"time"
-
 	corev1 "k8s.io/api/core/v1"
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -63,25 +60,7 @@ func DeleteNamespace(ctx types.Context, cluster types.Cluster, namespace string)
 		return nil
 	}
 
-	log.Debugf("Waiting until namespace %q is deleted in cluster %q", namespace, cluster.Name)
-
-	key := k8stypes.NamespacedName{Name: namespace}
-
-	for {
-		if err := cluster.Client.Get(ctx.Context(), key, ns); err != nil {
-			if !k8serrors.IsNotFound(err) {
-				return err
-			}
-
-			log.Debugf("Namespace %q deleted in cluster %q", namespace, cluster.Name)
-
-			return nil
-		}
-
-		if err := Sleep(ctx.Context(), time.Second); err != nil {
-			return fmt.Errorf("namespace %q not deleted in cluster %q: %w", namespace, cluster.Name, err)
-		}
-	}
+	return nil
 }
 
 // Problem: currently we must manually add an annotation to application’s namespace to make volsync work.

@@ -0,0 +1,135 @@
+// SPDX-FileCopyrightText: The RamenDR authors
+// SPDX-License-Identifier: Apache-2.0
+
+package util
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+
+	ramen "github.com/ramendr/ramen/api/v1alpha1"
+	argocdv1alpha1hack "github.com/ramendr/ramen/e2e/argocd"
+	corev1 "k8s.io/api/core/v1"
+	k8serrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	k8stypes "k8s.io/apimachinery/pkg/types"
+	ocmv1b1 "open-cluster-management.io/api/cluster/v1beta1"
+	ocmv1b2 "open-cluster-management.io/api/cluster/v1beta2"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/ramendr/ramen/e2e/types"
+)
+
+func WaitForApplicationSetDelete(ctx types.Context, cluster types.Cluster, name, namespace string) error {
+	obj := &argocdv1alpha1hack.ApplicationSet{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+	}
+
+	return waitForResourceDelete(ctx, cluster, obj)
+}
+
+func WaitForConfigMapDelete(ctx types.Context, cluster types.Cluster, name, namespace string) error {
+	obj := &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+	}
+
+	return waitForResourceDelete(ctx, cluster, obj)
+}
+
+func WaitForPlacementDelete(ctx types.Context, cluster types.Cluster, name, namespace string) error {
+	obj := &ocmv1b1.Placement{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+	}
+
+	return waitForResourceDelete(ctx, cluster, obj)
+}
+
+func WaitForManagedClusterSetBindingDelete(ctx types.Context, cluster types.Cluster, name, namespace string) error {
+    	obj := &ocmv1b2.ManagedClusterSetBinding{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+	}
+
+	return waitForResourceDelete(ctx, cluster, obj)
+}
+
+func WaitForNamespaceDelete(ctx types.Context, cluster types.Cluster, namespace string) error {
+	obj := &corev1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: namespace,
+		},
+	}
+
+	return waitForResourceDelete(ctx, cluster, obj)
+}
+
+func WaitForDRPCDelete(ctx types.Context, cluster types.Cluster, name, namespace string) error {
+	obj := &ramen.DRPlacementControl{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+	}
+
+	return waitForResourceDelete(ctx, cluster, obj)
+}
+
+// waitForResourceDelete waits until a resource is deleted or deadline is reached
+func waitForResourceDelete(ctx types.Context, cluster types.Cluster, obj client.Object) error {
+	log := ctx.Logger()
+	kind := getKind(obj)
+	key := k8stypes.NamespacedName{
+		Name:      obj.GetName(),
+		Namespace: obj.GetNamespace(),
+	}
+	resourceName := logName(obj)
+
+	log.Debugf("Waiting until %s %q is deleted in cluster %q", kind, resourceName, cluster.Name)
+
+	for {
+		if err := cluster.Client.Get(ctx.Context(), key, obj); err != nil {
+			if !k8serrors.IsNotFound(err) {
+				return err
+			}
+
+			log.Debugf("%s %q deleted in cluster %q", kind, resourceName, cluster.Name)
+
+			return nil
+		}
+
+		if err := Sleep(ctx.Context(), time.Second); err != nil {
+			return fmt.Errorf("%s %q not deleted in cluster %q: %w", kind, resourceName, cluster.Name, err)
+		}
+	}
+}
+
+// getKind extracts resource type name from the object
+func getKind(obj client.Object) string {
+	t := reflect.TypeOf(obj)
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+
+	return t.Name()
+}
+
+// logName returns the resource name for logging (namespace/name or just name)
+func logName(obj client.Object) string {
+	if obj.GetNamespace() != "" {
+		return obj.GetNamespace() + "/" + obj.GetName()
+	}
+
+	return obj.GetName()
+}