fix: recreate application in managed mode upon deletion from spoke

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

Author: Rizwana777

principal/event.go

@@ -255,6 +255,21 @@ 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,3 +1172,95 @@ 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

@@ -1018,6 +1018,60 @@ 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
+func (suite *ResyncTestSuite) Test_ManagedAppRecreationOnDirectDeletion() {
+	requires := suite.Require()
+	t := suite.T()
+
+	t.Log("Create a managed application")
+	app := suite.createManagedApp()
+	key := types.NamespacedName{Name: app.Name, Namespace: "argocd"}
+
+	t.Log("Verify application exists on both principal and managed agent")
+	// Verify on principal
+	principalApp := argoapp.Application{}
+	err := suite.PrincipalClient.Get(suite.Ctx, types.NamespacedName{Name: app.Name, Namespace: "agent-managed"}, &principalApp, metav1.GetOptions{})
+	requires.NoError(err, "Application should exist on principal")
+
+	// Verify on managed agent
+	managedApp := argoapp.Application{}
+	err = suite.ManagedAgentClient.Get(suite.Ctx, key, &managedApp, metav1.GetOptions{})
+	requires.NoError(err, "Application should exist on managed agent")
+
+	t.Log("Delete application directly from managed agent")
+	err = suite.ManagedAgentClient.Delete(suite.Ctx, &argoapp.Application{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      app.Name,
+			Namespace: "argocd",
+		},
+	}, metav1.DeleteOptions{})
+	requires.NoError(err)
+
+	t.Log("Verify application is deleted from managed agent")
+	requires.Eventually(func() bool {
+		app := argoapp.Application{}
+		err := suite.ManagedAgentClient.Get(suite.Ctx, key, &app, metav1.GetOptions{})
+		return err != nil
+	}, 10*time.Second, 1*time.Second, "Application should be deleted from managed agent")
+
+	t.Log("Verify application is automatically recreated on managed agent")
+	requires.Eventually(func() bool {
+		app := argoapp.Application{}
+		err := suite.ManagedAgentClient.Get(suite.Ctx, key, &app, metav1.GetOptions{})
+		return err == nil
+	}, 30*time.Second, 2*time.Second, "Application should be recreated on managed agent")
+
+	t.Log("Verify recreated application has correct spec")
+	recreatedApp := argoapp.Application{}
+	err = suite.ManagedAgentClient.Get(suite.Ctx, key, &recreatedApp, metav1.GetOptions{})
+	requires.NoError(err)
+	requires.Equal(principalApp.Spec.Source.RepoURL, recreatedApp.Spec.Source.RepoURL, "Recreated app should have same source")
+	requires.Equal(principalApp.Spec.Destination.Namespace, recreatedApp.Spec.Destination.Namespace, "Recreated app should have same namespace")
+}
+
 func TestResyncTestSuite(t *testing.T) {
 	suite.Run(t, new(ResyncTestSuite))
 }