[CONTP-1335] organize finalizers

internal/controller/datadogagent/controller.go

@@ -64,7 +64,8 @@ import (
 )
 
 const (
-	defaultRequeuePeriod = 15 * time.Second
+	defaultRequeuePeriod    = 15 * time.Second
+	defaultErrRequeuePeriod = 5 * time.Second
 )
 
 // ReconcilerOptions provides options read from command line

internal/controller/datadogagent/controller_reconcile_v2.go

@@ -22,6 +22,7 @@ import (
 	"github.com/DataDog/datadog-operator/internal/controller/datadogagent/component"
 	"github.com/DataDog/datadog-operator/internal/controller/datadogagent/defaults"
 	"github.com/DataDog/datadog-operator/internal/controller/datadogagent/feature"
+	"github.com/DataDog/datadog-operator/internal/controller/finalizer"
 	"github.com/DataDog/datadog-operator/pkg/agentprofile"
 	"github.com/DataDog/datadog-operator/pkg/condition"
 	"github.com/DataDog/datadog-operator/pkg/controller/utils"
@@ -40,7 +41,8 @@ func (r *Reconciler) internalReconcileV2(ctx context.Context, instance *datadogh
 	}
 
 	// 2. Handle finalizer logic.
-	if result, err := r.handleFinalizer(reqLogger, instance, r.finalizeDadV2); utils.ShouldReturn(result, err) {
+	final := finalizer.NewFinalizer(reqLogger, r.client, r.deleteResource(reqLogger), 0, defaultErrRequeuePeriod)
+	if result, err := final.HandleFinalizer(ctx, instance, "", datadogAgentFinalizer); utils.ShouldReturn(result, err) {
 		return result, err
 	}
 

internal/controller/datadogagent/finalizer.go

@@ -12,11 +12,10 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
-	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	"github.com/DataDog/datadog-operator/internal/controller/datadogagent/object"
 	"github.com/DataDog/datadog-operator/internal/controller/datadogagent/store"
+	"github.com/DataDog/datadog-operator/internal/controller/finalizer"
 	"github.com/DataDog/datadog-operator/pkg/agentprofile"
 	"github.com/DataDog/datadog-operator/pkg/constants"
 	"github.com/DataDog/datadog-operator/pkg/kubernetes"
@@ -26,41 +25,10 @@ const (
 	datadogAgentFinalizer = "finalizer.agent.datadoghq.com"
 )
 
-type finalizerDadFunc func(reqLogger logr.Logger, dda client.Object) error
-
-func (r *Reconciler) handleFinalizer(reqLogger logr.Logger, dda client.Object, finalizerDad finalizerDadFunc) (reconcile.Result, error) {
-	// Check if the DatadogAgent instance is marked to be deleted, which is
-	// indicated by the deletion timestamp being set.
-	isDadMarkedToBeDeleted := dda.GetDeletionTimestamp() != nil
-	if isDadMarkedToBeDeleted {
-		if controllerutil.ContainsFinalizer(dda, datadogAgentFinalizer) {
-			// Run finalization logic for datadogAgentFinalizer. If the
-			// finalization logic fails, don't remove the finalizer so
-			// that we can retry during the next reconciliation.
-			if err := finalizerDad(reqLogger, dda); err != nil {
-				return reconcile.Result{}, err
-			}
-
-			// Remove datadogAgentFinalizer. Once all finalizers have been
-			// removed, the object will be deleted.
-			controllerutil.RemoveFinalizer(dda, datadogAgentFinalizer)
-			err := r.client.Update(context.TODO(), dda)
-			if err != nil {
-				return reconcile.Result{}, err
-			}
-		}
-		return reconcile.Result{Requeue: true}, nil
-	}
-
-	// Add finalizer for this CR
-	if !controllerutil.ContainsFinalizer(dda, datadogAgentFinalizer) {
-		if err := r.addFinalizer(reqLogger, dda); err != nil {
-			return reconcile.Result{}, err
-		}
-		return reconcile.Result{Requeue: true}, nil
+func (r *Reconciler) deleteResource(reqLogger logr.Logger) finalizer.ResourceDeleteFunc {
+	return func(ctx context.Context, k8sObj client.Object, datadogID string) error {
+		return r.finalizeDadV2(reqLogger, k8sObj)
 	}
-
-	return reconcile.Result{}, nil
 }
 
 func (r *Reconciler) finalizeDadV2(reqLogger logr.Logger, obj client.Object) error {
@@ -82,19 +50,6 @@ func (r *Reconciler) finalizeDadV2(reqLogger logr.Logger, obj client.Object) err
 	return nil
 }
 
-func (r *Reconciler) addFinalizer(reqLogger logr.Logger, dda client.Object) error {
-	reqLogger.Info("Adding Finalizer for the DatadogAgent")
-	controllerutil.AddFinalizer(dda, datadogAgentFinalizer)
-
-	// Update CR
-	err := r.client.Update(context.TODO(), dda)
-	if err != nil {
-		reqLogger.Error(err, "Failed to update DatadogAgent with finalizer")
-		return err
-	}
-	return nil
-}
-
 // profilesCleanup performs the cleanups required for the profiles feature. The
 // only thing that we need to do is to ensure that no nodes are left with the
 // profile label.

internal/controller/datadogagent/finalizer_test.go

@@ -139,7 +139,7 @@ func Test_handleFinalizer(t *testing.T) {
 
 	reconciler := reconcilerForFinalizerTest(initialKubeObjects)
 
-	_, err := reconciler.handleFinalizer(logf.Log.WithName("Handle Finalizer V2 test"), dda, reconciler.finalizeDadV2)
+	err := reconciler.finalizeDadV2(logf.Log.WithName("Handle Finalizer V2 test"), dda)
 	assert.NoError(t, err)
 
 	// Check that the cluster roles associated with the Datadog Agent have been deleted

internal/controller/datadogagentinternal/controller.go

@@ -58,7 +58,8 @@ import (
 )
 
 const (
-	defaultRequeuePeriod = 15 * time.Second
+	defaultRequeuePeriod    = 15 * time.Second
+	defaultErrRequeuePeriod = 5 * time.Second
 )
 
 // ReconcilerOptions provides options read from command line

internal/controller/datadogagentinternal/controller_reconcile_v2.go

@@ -18,7 +18,9 @@ import (
 	"github.com/DataDog/datadog-operator/internal/controller/datadogagent/common"
 	"github.com/DataDog/datadog-operator/internal/controller/datadogagent/defaults"
 	"github.com/DataDog/datadog-operator/internal/controller/datadogagent/feature"
+	"github.com/DataDog/datadog-operator/internal/controller/finalizer"
 	"github.com/DataDog/datadog-operator/pkg/condition"
+	"github.com/DataDog/datadog-operator/pkg/constants"
 	"github.com/DataDog/datadog-operator/pkg/controller/utils"
 )
 
@@ -34,7 +36,8 @@ func (r *Reconciler) internalReconcileV2(ctx context.Context, instance *v1alpha1
 	// }
 
 	// 2. Handle finalizer logic.
-	if result, err := r.handleFinalizer(ctx, instance, r.finalizeDDAI); utils.ShouldReturn(result, err) {
+	final := finalizer.NewFinalizer(logger, r.client, r.deleteResource(), 0, defaultErrRequeuePeriod)
+	if result, err := final.HandleFinalizer(ctx, instance, "", constants.DatadogAgentInternalFinalizer); utils.ShouldReturn(result, err) {
 		return result, err
 	}
 

internal/controller/datadogagentinternal/finalizer.go

@@ -12,51 +12,19 @@ import (
 	"k8s.io/apimachinery/pkg/api/errors"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
-	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	"github.com/DataDog/datadog-operator/internal/controller/datadogagent/object"
 	"github.com/DataDog/datadog-operator/internal/controller/datadogagent/store"
+	"github.com/DataDog/datadog-operator/internal/controller/finalizer"
 	"github.com/DataDog/datadog-operator/pkg/agentprofile"
 	"github.com/DataDog/datadog-operator/pkg/constants"
 	"github.com/DataDog/datadog-operator/pkg/kubernetes"
 )
 
-type finalizerDDAIFunc func(ctx context.Context, dda client.Object) error
-
-func (r *Reconciler) handleFinalizer(ctx context.Context, ddai client.Object, finalizerDDAI finalizerDDAIFunc) (reconcile.Result, error) {
-	// Check if the DatadogAgentInternal instance is marked to be deleted, which is
-	// indicated by the deletion timestamp being set.
-	isDDAIMarkedToBeDeleted := ddai.GetDeletionTimestamp() != nil
-	if isDDAIMarkedToBeDeleted {
-		if controllerutil.ContainsFinalizer(ddai, constants.DatadogAgentInternalFinalizer) {
-			// Run finalization logic for datadogAgentFinalizer. If the
-			// finalization logic fails, don't remove the finalizer so
-			// that we can retry during the next reconciliation.
-			if err := finalizerDDAI(ctx, ddai); err != nil {
-				return reconcile.Result{}, err
-			}
-
-			// Remove datadogAgentFinalizer. Once all finalizers have been
-			// removed, the object will be deleted.
-			controllerutil.RemoveFinalizer(ddai, constants.DatadogAgentInternalFinalizer)
-			err := r.client.Update(ctx, ddai)
-			if err != nil {
-				return reconcile.Result{}, err
-			}
-		}
-		return reconcile.Result{Requeue: true}, nil
+func (r *Reconciler) deleteResource() finalizer.ResourceDeleteFunc {
+	return func(ctx context.Context, k8sObj client.Object, datadogID string) error {
+		return r.finalizeDDAI(ctx, k8sObj)
 	}
-
-	// Add finalizer for this CR
-	if !controllerutil.ContainsFinalizer(ddai, constants.DatadogAgentInternalFinalizer) {
-		if err := r.addFinalizer(ctx, ddai); err != nil {
-			return reconcile.Result{}, err
-		}
-		return reconcile.Result{Requeue: true}, nil
-	}
-
-	return reconcile.Result{}, nil
 }
 
 func (r *Reconciler) finalizeDDAI(ctx context.Context, obj client.Object) error {
@@ -79,20 +47,6 @@ func (r *Reconciler) finalizeDDAI(ctx context.Context, obj client.Object) error
 	return nil
 }
 
-func (r *Reconciler) addFinalizer(ctx context.Context, ddai client.Object) error {
-	logger := ctrl.LoggerFrom(ctx)
-	logger.Info("Adding Finalizer for the DatadogAgentInternal")
-	controllerutil.AddFinalizer(ddai, constants.DatadogAgentInternalFinalizer)
-
-	// Update CR
-	err := r.client.Update(ctx, ddai)
-	if err != nil {
-		logger.Error(err, "Failed to update DatadogAgentInternal with finalizer")
-		return err
-	}
-	return nil
-}
-
 // profilesCleanup performs the cleanups required for the profiles feature. The
 // only thing that we need to do is to ensure that no nodes are left with the
 // profile label.

internal/controller/datadogagentinternal/finalizer_test.go

@@ -128,7 +128,7 @@ func Test_handleFinalizer(t *testing.T) {
 
 	reconciler := reconcilerForFinalizerTest(initialKubeObjects)
 
-	_, err := reconciler.handleFinalizer(context.Background(), ddai, reconciler.finalizeDDAI)
+	err := reconciler.finalizeDDAI(context.Background(), ddai)
 	assert.NoError(t, err)
 
 	// Check that the cluster roles associated with the Datadog Agent have been deleted

internal/controller/datadogdashboard/controller.go

@@ -22,6 +22,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	"github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
+	"github.com/DataDog/datadog-operator/internal/controller/finalizer"
 	"github.com/DataDog/datadog-operator/internal/controller/utils"
 	"github.com/DataDog/datadog-operator/pkg/config"
 	ctrutils "github.com/DataDog/datadog-operator/pkg/controller/utils"
@@ -111,7 +112,8 @@ func (r *Reconciler) internalReconcile(ctx context.Context, req reconcile.Reques
 		return ctrl.Result{}, err
 	}
 
-	if result, err = r.handleFinalizer(logger, instance); ctrutils.ShouldReturn(result, err) {
+	final := finalizer.NewFinalizer(logger, r.client, r.deleteResource(logger), 0, defaultErrRequeuePeriod)
+	if result, err = final.HandleFinalizer(ctx, instance, instance.Status.ID, datadogDashboardFinalizer); ctrutils.ShouldReturn(result, err) {
 		return result, err
 	}
 

internal/controller/datadogdashboard/finalizer.go

@@ -10,69 +10,28 @@ import (
 	"fmt"
 
 	"github.com/go-logr/logr"
-	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 
-	datadoghqv1alpha1 "github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
+	"github.com/DataDog/datadog-operator/internal/controller/finalizer"
 	"github.com/DataDog/datadog-operator/pkg/controller/utils/datadog"
 )
 
 const (
 	datadogDashboardFinalizer = "finalizer.datadoghq.com/dashboard"
 )
 
-func (r *Reconciler) handleFinalizer(logger logr.Logger, db *datadoghqv1alpha1.DatadogDashboard) (ctrl.Result, error) {
-	// Check if the DatadogDashboard instance is marked to be deleted, which is indicated by the deletion timestamp being set.
-	if db.GetDeletionTimestamp() != nil {
-		if controllerutil.ContainsFinalizer(db, datadogDashboardFinalizer) {
-			r.finalizeDatadogDashboard(logger, db)
-
-			controllerutil.RemoveFinalizer(db, datadogDashboardFinalizer)
-			err := r.client.Update(context.TODO(), db)
+func (r *Reconciler) deleteResource(logger logr.Logger) finalizer.ResourceDeleteFunc {
+	return func(ctx context.Context, k8sObj client.Object, datadogID string) error {
+		if datadogID != "" {
+			err := deleteDashboard(r.datadogAuth, r.datadogClient, datadogID)
 			if err != nil {
-				return ctrl.Result{RequeueAfter: defaultErrRequeuePeriod}, err
+				logger.Error(err, "failed to finalize dashboard", "dashboard ID", fmt.Sprint(datadogID))
+				return nil
 			}
+			logger.Info("Successfully finalized DatadogDashboard", "dashboard ID", fmt.Sprint(datadogID))
 		}
-
-		// Requeue until the object is properly deleted by Kubernetes
-		return ctrl.Result{RequeueAfter: defaultRequeuePeriod}, nil
+		event := buildEventInfo(k8sObj.GetName(), k8sObj.GetNamespace(), datadog.DeletionEvent)
+		r.recordEvent(k8sObj, event)
+		return nil
 	}
-
-	// Add finalizer for this resource if it doesn't already exist.
-	if !controllerutil.ContainsFinalizer(db, datadogDashboardFinalizer) {
-		if err := r.addFinalizer(logger, db); err != nil {
-			return ctrl.Result{RequeueAfter: defaultErrRequeuePeriod}, err
-		}
-
-		return ctrl.Result{Requeue: true}, nil
-	}
-
-	// Proceed in reconcile loop.
-	return ctrl.Result{}, nil
-}
-
-func (r *Reconciler) finalizeDatadogDashboard(logger logr.Logger, db *datadoghqv1alpha1.DatadogDashboard) {
-	err := deleteDashboard(r.datadogAuth, r.datadogClient, db.Status.ID)
-	if err != nil {
-		logger.Error(err, "failed to finalize dashboard", "dashboard ID", fmt.Sprint(db.Status.ID))
-
-		return
-	}
-	logger.Info("Successfully finalized DatadogDashboard", "dashboard ID", fmt.Sprint(db.Status.ID))
-	event := buildEventInfo(db.Name, db.Namespace, datadog.DeletionEvent)
-	r.recordEvent(db, event)
-}
-
-func (r *Reconciler) addFinalizer(logger logr.Logger, db *datadoghqv1alpha1.DatadogDashboard) error {
-	logger.Info("Adding Finalizer for the DatadogDashboard")
-
-	controllerutil.AddFinalizer(db, datadogDashboardFinalizer)
-
-	err := r.client.Update(context.TODO(), db)
-	if err != nil {
-		logger.Error(err, "failed to update DatadogDashboard with finalizer", "dashboard ID", fmt.Sprint(db.Status.ID))
-		return err
-	}
-
-	return nil
 }

internal/controller/datadogdashboard/finalizer_test.go

@@ -18,6 +18,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/log/zap"
 
 	datadoghqv1alpha1 "github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
+	"github.com/DataDog/datadog-operator/internal/controller/finalizer"
 )
 
 var (
@@ -58,7 +59,8 @@ func Test_handleFinalizer(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			reqLogger := testLogger.WithValues("test:", test.name)
 			_ = r.client.Create(context.TODO(), test.db)
-			_, err := r.handleFinalizer(reqLogger, test.db)
+			final := finalizer.NewFinalizer(reqLogger, r.client, r.deleteResource(reqLogger), defaultRequeuePeriod, defaultErrRequeuePeriod)
+			_, err := final.HandleFinalizer(context.TODO(), test.db, test.db.Status.ID, datadogDashboardFinalizer)
 			assert.NoError(t, err)
 			if test.finalizerShouldExist {
 				assert.True(t, controllerutil.ContainsFinalizer(test.db, datadogDashboardFinalizer))

internal/controller/datadoggenericresource/controller.go

@@ -21,6 +21,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	"github.com/DataDog/datadog-operator/api/datadoghq/v1alpha1"
+	"github.com/DataDog/datadog-operator/internal/controller/finalizer"
 	"github.com/DataDog/datadog-operator/internal/controller/utils"
 	"github.com/DataDog/datadog-operator/pkg/config"
 	ctrutils "github.com/DataDog/datadog-operator/pkg/controller/utils"
@@ -105,7 +106,8 @@ func (r *Reconciler) internalReconcile(ctx context.Context, req reconcile.Reques
 		return ctrl.Result{}, err
 	}
 
-	if result, err = r.handleFinalizer(logger, instance); ctrutils.ShouldReturn(result, err) {
+	final := finalizer.NewFinalizer(logger, r.client, r.deleteResource(logger), 0, defaultErrRequeuePeriod)
+	if result, err = final.HandleFinalizer(ctx, instance, instance.Status.Id, datadogGenericResourceFinalizer); ctrutils.ShouldReturn(result, err) {
 		return result, err
 	}