fix: use RevertUserInitiatedDeletion for application recreation

Assisted-by: Cursor
Signed-off-by: Rizwana777 <[email protected]>

Author: Rizwana777

agent/outbound.go

@@ -118,6 +118,18 @@ func (a *Agent) addAppDeletionToQueue(app *v1alpha1.Application) {
 	logCtx := log().WithField(logfields.Event, "DeleteApp").WithField(logfields.Application, app.QualifiedName())
 	logCtx.Debugf("Delete app event")
 
+	if isResourceFromPrincipal(app) {
+		reverted, err := manager.RevertUserInitiatedDeletion(a.context, app, a.deletions, a.appManager, logCtx)
+		if err != nil {
+			logCtx.WithError(err).Error("failed to revert invalid deletion of application")
+			return
+		}
+		if reverted {
+			logCtx.Trace("Deleted application is recreated")
+			return
+		}
+	}
+
 	a.resources.Remove(resources.NewResourceKeyFromApp(app))
 
 	if !a.appManager.IsManaged(app.QualifiedName()) {

agent/outbound_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/alicebob/miniredis/v2"
 	"github.com/argoproj-labs/argocd-agent/internal/argocd/cluster"
 	"github.com/argoproj-labs/argocd-agent/internal/event"
+	"github.com/argoproj-labs/argocd-agent/internal/manager"
 	"github.com/argoproj-labs/argocd-agent/internal/resources"
 	"github.com/argoproj-labs/argocd-agent/pkg/client"
 	"github.com/argoproj-labs/argocd-agent/pkg/types"
@@ -17,6 +18,7 @@ import (
 	"github.com/stretchr/testify/require"
 	corev1 "k8s.io/api/core/v1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	k8stypes "k8s.io/apimachinery/pkg/types"
 )
 
 func Test_addAppCreationToQueue(t *testing.T) {
@@ -164,6 +166,69 @@ func Test_addAppDeletionToQueue(t *testing.T) {
 		assert.Equal(t, 0, items.Len())
 		require.False(t, a.appManager.IsManaged("agent/guestbook"))
 	})
+	t.Run("Recreation of application from principal when deleted", func(t *testing.T) {
+		// Create a fresh agent for this test
+		testAgent, _ := newAgent(t)
+		testAgent.remote.SetClientID("agent")
+		testAgent.emitter = event.NewEventSource("principal")
+		testAgent.mode = types.AgentModeManaged
+
+		// Create an app with source UID annotation (from principal)
+		app := &v1alpha1.Application{
+			ObjectMeta: v1.ObjectMeta{
+				Name:      "guestbook",
+				Namespace: "agent",
+				Annotations: map[string]string{
+					manager.SourceUIDAnnotation: "uid-123",
+				},
+			},
+		}
+
+		// App must be already managed for event to be generated
+		_ = testAgent.appManager.Manage("agent/guestbook")
+		defer testAgent.appManager.ClearManaged()
+
+		// Don't mark the deletion as expected, so it should be recreated
+		testAgent.addAppDeletionToQueue(app)
+
+		// Should have recreated the app (no event in queue because recreation happened)
+		assert.Equal(t, 0, testAgent.queues.SendQ(defaultQueueName).Len())
+
+		// Verify the app is still managed (recreated)
+		assert.True(t, testAgent.appManager.IsManaged("agent/guestbook"))
+	})
+	t.Run("No recreation when deletion is expected from principal", func(t *testing.T) {
+		// Create a fresh agent for this test
+		testAgent, _ := newAgent(t)
+		testAgent.remote.SetClientID("agent")
+		testAgent.emitter = event.NewEventSource("principal")
+		testAgent.mode = types.AgentModeManaged
+
+		// Create an app with source UID annotation (from principal)
+		app := &v1alpha1.Application{
+			ObjectMeta: v1.ObjectMeta{
+				Name:      "guestbook",
+				Namespace: "agent",
+				Annotations: map[string]string{
+					manager.SourceUIDAnnotation: "uid-123",
+				},
+			},
+		}
+
+		// App must be already managed for event to be generated
+		_ = testAgent.appManager.Manage("agent/guestbook")
+		defer testAgent.appManager.ClearManaged()
+
+		// Mark the deletion as expected
+		testAgent.deletions.MarkExpected(k8stypes.UID("uid-123"))
+
+		testAgent.addAppDeletionToQueue(app)
+
+		// Should have sent delete event (not recreated)
+		assert.Equal(t, 1, testAgent.queues.SendQ(defaultQueueName).Len())
+		ev, _ := testAgent.queues.SendQ(defaultQueueName).Get()
+		assert.Equal(t, event.Delete.String(), ev.Type())
+	})
 }
 
 func Test_deleteNamespaceCallback(t *testing.T) {

principal/event.go

@@ -255,21 +255,6 @@ func (s *Server) processApplicationEvent(ctx context.Context, agentName string,
 			// When we receive an 'application deleted' event from a managed agent, it should only cause the principal application to be deleted IF the principal Application is ALSO in the deletion state (deletionTimestamp is non-nil)
 			if app.DeletionTimestamp == nil {
 				logCtx.Warn("application was detected as deleted from managed agent, even though principal application is not in deletion state")
-				// In managed mode, if the application was deleted from the agent but the principal
-				// application is not in deletion state, we should recreate it by sending the
-				// application spec back to the managed agent
-				logCtx.Info("Recreating application in managed agent to maintain desired state")
-
-				// Send the application spec to the managed agent to recreate it
-				ev := s.events.ApplicationEvent(event.SpecUpdate, app)
-				q := s.queues.SendQ(agentName)
-				if q == nil {
-					logCtx.Error("Send queue not found for agent, cannot recreate application")
-					return fmt.Errorf("send queue not found for agent %s", agentName)
-				}
-				q.Add(ev)
-				logCtx.Infof("Sent application spec to managed agent %s to recreate application %s", agentName, app.Name)
-
 				return nil
 			}
 

principal/event_test.go

@@ -1172,95 +1172,3 @@ func Test_processClusterCacheInfoUpdateEvent(t *testing.T) {
 		assert.ErrorContains(t, err, "not mapped to any cluster")
 	})
 }
-
-func Test_ManagedAppRecreationLogic(t *testing.T) {
-
-	type test struct {
-		name                            string
-		deletionTimestampSetOnPrincipal bool
-		expectRecreation                bool
-	}
-
-	tests := []test{
-		{
-			name:                            "Delete event from managed agent should recreate app when principal is not in deletion state",
-			deletionTimestampSetOnPrincipal: false,
-			expectRecreation:                true,
-		},
-		{
-			name:                            "Delete event from managed agent should not recreate app when principal is in deletion state",
-			deletionTimestampSetOnPrincipal: true,
-			expectRecreation:                false,
-		},
-	}
-
-	for _, test := range tests {
-
-		t.Run(test.name, func(t *testing.T) {
-			delApp := &v1alpha1.Application{
-				ObjectMeta: v1.ObjectMeta{
-					Name:       "test-app",
-					Namespace:  "agent-managed",
-					Finalizers: []string{"test-finalizer"},
-				},
-				Spec: v1alpha1.ApplicationSpec{
-					Project: "default",
-					Source: &v1alpha1.ApplicationSource{
-						RepoURL:        "https://github.com/argoproj/argocd-example-apps",
-						TargetRevision: "HEAD",
-						Path:           "kustomize-guestbook",
-					},
-					Destination: v1alpha1.ApplicationDestination{
-						Server:    "https://kubernetes.default.svc",
-						Namespace: "guestbook",
-					},
-				},
-				Status: v1alpha1.ApplicationStatus{
-					Sync: v1alpha1.SyncStatus{Status: v1alpha1.SyncStatusCodeSynced},
-				},
-			}
-
-			if test.deletionTimestampSetOnPrincipal {
-				delApp.DeletionTimestamp = ptr.To(v1.Time{Time: time.Now()})
-			}
-
-			fac := kube.NewKubernetesFakeClientWithApps("argocd")
-			ev := cloudevents.NewEvent()
-			ev.SetDataSchema("application")
-			ev.SetType(event.Delete.String())
-			ev.SetData(cloudevents.ApplicationJSON, delApp)
-			wq := wqmock.NewTypedRateLimitingInterface[*cloudevents.Event](t)
-			wq.On("Get").Return(&ev, false)
-			wq.On("Done", &ev)
-			s, err := NewServer(context.Background(), fac, "argocd", WithGeneratedTokenSigningKey())
-			require.NoError(t, err)
-			s.setAgentMode("agent-managed", types.AgentModeManaged)
-			s.events = event.NewEventSource("test")
-
-			// Set up the send queue for normal operation
-			err = s.queues.Create("agent-managed")
-			require.NoError(t, err)
-
-			// Create the application in the principal
-			_, err = fac.ApplicationsClientset.ArgoprojV1alpha1().Applications(delApp.Namespace).Create(context.Background(), delApp, v1.CreateOptions{})
-			require.NoError(t, err)
-
-			got, err := s.processRecvQueue(context.Background(), "agent-managed", wq)
-			require.NoError(t, err)
-			require.Equal(t, ev, *got)
-
-			if test.expectRecreation {
-				// When recreation is expected, the application should still exist in the principal
-				// because the deletion was prevented and a recreation event was sent
-				_, err = fac.ApplicationsClientset.ArgoprojV1alpha1().Applications(delApp.Namespace).Get(context.Background(), delApp.Name, v1.GetOptions{})
-				require.NoError(t, err, "Application should still exist in principal when recreation is expected")
-			} else {
-				// When recreation is not expected, the app should be deleted
-				// This happens when the principal app is already in deletion state
-				_, err = fac.ApplicationsClientset.ArgoprojV1alpha1().Applications(delApp.Namespace).Get(context.Background(), delApp.Name, v1.GetOptions{})
-				require.True(t, apierrors.IsNotFound(err), "Application should be deleted when recreation is not expected")
-			}
-		})
-	}
-
-}

test/e2e/resync_test.go

@@ -1019,9 +1019,9 @@ func sampleRepository() *corev1.Secret {
 }
 
 // Test_ManagedAppRecreationOnDirectDeletion tests the scenario where:
-// 1. A managed application exists on both principal and managed agent
-// 2. The application is directly deleted from the managed agent (while agent is running)
-// 3. The principal should detect this and recreate the application automatically
+//  1. A managed application exists on both principal and managed agent
+//  2. The application is directly deleted from the managed agent (while agent is running)
+//  3. The agent should detect this unauthorized deletion and recreate the application automatically
 func (suite *ResyncTestSuite) Test_ManagedAppRecreationOnDirectDeletion() {
 	requires := suite.Require()
 	t := suite.T()