Add configurability to reapply support

Author: josvazg

internal/controller/atlasthirdpartyintegrations/setup.go

@@ -55,6 +55,7 @@ func NewAtlasThirdPartyIntegrationsReconciler(
 	deletionProtection bool,
 	logger *zap.Logger,
 	globalSecretRef client.ObjectKey,
+	reapplySupport bool,
 ) *ctrlstate.Reconciler[akov2next.AtlasThirdPartyIntegration] {
 	return ctrlstate.NewStateReconciler(&AtlasThirdPartyIntegrationHandler{
 		AtlasReconciler: reconciler.AtlasReconciler{
@@ -63,7 +64,7 @@ func NewAtlasThirdPartyIntegrationsReconciler(
 			GlobalSecretRef: globalSecretRef,
 		},
 		deletionProtection: deletionProtection,
-	})
+	}, ctrlstate.WithReapplySupport[akov2next.AtlasThirdPartyIntegration](reapplySupport))
 }
 
 func (h *AtlasThirdPartyIntegrationHandler) SetupWithManager(mgr ctrl.Manager, rec reconcile.Reconciler, opts ...ctrlstate.SetupManagerOption) error {

internal/controller/registry.go

@@ -49,6 +49,8 @@ import (
 	ctrlstate "github.com/mongodb/mongodb-atlas-kubernetes/v2/pkg/controller/state"
 )
 
+const DefaultReapplySupport = true
+
 type Reconciler interface {
 	reconcile.Reconciler
 	For() (client.Object, builder.Predicates)
@@ -65,6 +67,8 @@ type Registry struct {
 	reconcilers             []Reconciler
 	globalSecretRef         client.ObjectKey
 	experimentalReconcilers bool
+
+	reapplySupport bool
 }
 
 func NewRegistry(predicates []predicate.Predicate, deletionProtection bool, logger *zap.Logger, independentSyncPeriod time.Duration, featureFlags *featureflags.FeatureFlags, globalSecretRef client.ObjectKey, experimentalReconcilers bool) *Registry {
@@ -76,6 +80,7 @@ func NewRegistry(predicates []predicate.Predicate, deletionProtection bool, logg
 		featureFlags:            featureFlags,
 		globalSecretRef:         globalSecretRef,
 		experimentalReconcilers: experimentalReconcilers,
+		reapplySupport:          DefaultReapplySupport,
 	}
 }
 
@@ -128,7 +133,13 @@ func (r *Registry) registerControllers(c cluster.Cluster, ap atlas.Provider) {
 
 func (r *Registry) appendExperimentalReconcilers(reconcilers []Reconciler, _ cluster.Cluster, ap atlas.Provider) []Reconciler {
 	// TODO cluster.Cluster needed in initialization
-	integrationsReconciler := integrations.NewAtlasThirdPartyIntegrationsReconciler(ap, r.deletionProtection, r.logger, r.globalSecretRef)
+	integrationsReconciler := integrations.NewAtlasThirdPartyIntegrationsReconciler(
+		ap,
+		r.deletionProtection,
+		r.logger,
+		r.globalSecretRef,
+		r.reapplySupport,
+	)
 	compatibleIntegrationsReconciler := newCtrlStateReconciler(*integrationsReconciler)
 	reconcilers = append(reconcilers, compatibleIntegrationsReconciler)
 	return reconcilers

pkg/controller/state/reconciler.go

@@ -66,6 +66,15 @@ type Reconciler[T any] struct {
 	cluster         cluster.Cluster
 	reconciler      StateHandler[T]
 	unstructuredGVK schema.GroupVersionKind
+	supportReapply  bool
+}
+
+type ReconcilerOptionFn[T any] func(*Reconciler[T])
+
+func WithReapplySupport[T any](supportReapply bool) ReconcilerOptionFn[T] {
+	return func(r *Reconciler[T]) {
+		r.supportReapply = supportReapply
+	}
 }
 
 type UnstructuredStateReconciler = StateHandler[unstructured.Unstructured]
@@ -74,10 +83,14 @@ type ControllerSetupBuilder = ctrlrtbuilder.TypedBuilder[reconcile.Request]
 
 type SetupManagerOption func(builder *ControllerSetupBuilder) *ControllerSetupBuilder
 
-func NewStateReconciler[T any](target StateHandler[T]) *Reconciler[T] {
-	return &Reconciler[T]{
+func NewStateReconciler[T any](target StateHandler[T], options ...ReconcilerOptionFn[T]) *Reconciler[T] {
+	r := &Reconciler[T]{
 		reconciler: target,
 	}
+	for _, opt := range options {
+		opt(r)
+	}
+	return r
 }
 
 func NewUnstructuredStateReconciler(target UnstructuredStateReconciler, gvk schema.GroupVersionKind) *Reconciler[unstructured.Unstructured] {
@@ -287,20 +300,30 @@ func (r *Reconciler[T]) ReconcileState(ctx context.Context, t *T) (Result, error
 		result.NextState = state.StateInitial
 	}
 
+	if r.supportReapply {
+		err := r.reconcileReapply(ctx, obj, result, err)
+		if err != nil {
+			return Result{}, fmt.Errorf("failed to reconcile reapply: %w", err)
+		}
+	}
+
+	return result, err
+}
+
+func (r *Reconciler[T]) reconcileReapply(ctx context.Context, obj client.Object, result Result, err error) error {
 	isReapplyState := result.NextState == state.StateImported ||
 		result.NextState == state.StateCreated ||
 		result.NextState == state.StateUpdated
 
 	if isReapplyState && result.RequeueAfter == 0 && err == nil {
 		requeueAfter, err := PatchReapplyTimestamp(ctx, r.cluster.GetClient(), obj)
 		if err != nil {
-			return Result{}, err
+			return fmt.Errorf("failed to patch reapply timestamp: %w", err)
 		}
 
 		result.RequeueAfter = requeueAfter
 	}
-
-	return result, err
+	return nil
 }
 
 func getObservedGeneration(obj client.Object, prevStatusConditions []metav1.Condition, nextState state.ResourceState) int64 {