wip

Signed-off-by: Attila Mészáros <[email protected]>

Author: csviri

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/BaseConfigurationService.java

@@ -296,12 +296,14 @@ private <P extends HasMetadata> ResolvedControllerConfiguration<P> controllerCon
     final var dependentFieldManager =
         fieldManager.equals(CONTROLLER_NAME_AS_FIELD_MANAGER) ? name : fieldManager;
 
+    var controllerMode = annotation == null ? ControllerMode.DEFAULT : annotation.controllerMode();
+
     InformerConfiguration<P> informerConfig =
         InformerConfiguration.builder(resourceClass)
             .initFromAnnotation(annotation != null ? annotation.informer() : null, context)
             .buildForController();
 
-    return new ResolvedControllerConfiguration<P>(
+    return new ResolvedControllerConfiguration<>(
         name,
         generationAware,
         associatedReconcilerClass,
@@ -315,7 +317,8 @@ private <P extends HasMetadata> ResolvedControllerConfiguration<P> controllerCon
         null,
         dependentFieldManager,
         this,
-        informerConfig);
+        informerConfig,
+        controllerMode);
   }
 
   protected boolean createIfNeeded() {

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/ControllerConfiguration.java

@@ -93,7 +93,11 @@ default String fieldManager() {
 
   <C> C getConfigurationFor(DependentResourceSpec<?, P, C> spec);
 
-  default ControllerMode getMode() {
+  default ControllerMode getControllerMode() {
     return ControllerMode.DEFAULT;
   }
+
+  default boolean isAllEventReconcileMode() {
+    return getControllerMode() == ControllerMode.ALL_EVENT_RECONCILE;
+  }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/ControllerConfigurationOverrider.java

@@ -30,6 +30,7 @@ public class ControllerConfigurationOverrider<R extends HasMetadata> {
   private Duration reconciliationMaxInterval;
   private Map<DependentResourceSpec, Object> configurations;
   private final InformerConfiguration<R>.Builder config;
+  private ControllerMode controllerMode;
 
   private ControllerConfigurationOverrider(ControllerConfiguration<R> original) {
     this.finalizer = original.getFinalizerName();
@@ -42,6 +43,7 @@ private ControllerConfigurationOverrider(ControllerConfiguration<R> original) {
     this.rateLimiter = original.getRateLimiter();
     this.name = original.getName();
     this.fieldManager = original.fieldManager();
+    this.controllerMode = original.getControllerMode();
   }
 
   public ControllerConfigurationOverrider<R> withFinalizer(String finalizer) {
@@ -154,6 +156,11 @@ public ControllerConfigurationOverrider<R> withFieldManager(String dependentFiel
     return this;
   }
 
+  public ControllerConfigurationOverrider<R> withControllerMode(ControllerMode controllerMode) {
+    this.controllerMode = controllerMode;
+    return this;
+  }
+
   /**
    * Sets a max page size limit when starting the informer. This will result in pagination while
    * populating the cache. This means that longer lists will take multiple requests to fetch. See
@@ -198,6 +205,7 @@ public ControllerConfiguration<R> build() {
         fieldManager,
         original.getConfigurationService(),
         config.buildForController(),
+        controllerMode,
         original.getWorkflowSpec().orElse(null));
   }
 

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/ControllerMode.java

@@ -2,5 +2,5 @@
 
 public enum ControllerMode {
   DEFAULT,
-  RECONCILE_ALL_EVENT
+  ALL_EVENT_RECONCILE
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/ResolvedControllerConfiguration.java

@@ -30,6 +30,7 @@ public class ResolvedControllerConfiguration<P extends HasMetadata>
   private final ConfigurationService configurationService;
   private final String fieldManager;
   private WorkflowSpec workflowSpec;
+  private ControllerMode controllerMode;
 
   public ResolvedControllerConfiguration(ControllerConfiguration<P> other) {
     this(
@@ -44,6 +45,7 @@ public ResolvedControllerConfiguration(ControllerConfiguration<P> other) {
         other.fieldManager(),
         other.getConfigurationService(),
         other.getInformerConfig(),
+        other.getControllerMode(),
         other.getWorkflowSpec().orElse(null));
   }
 
@@ -59,6 +61,7 @@ public ResolvedControllerConfiguration(
       String fieldManager,
       ConfigurationService configurationService,
       InformerConfiguration<P> informerConfig,
+      ControllerMode controllerMode,
       WorkflowSpec workflowSpec) {
     this(
         name,
@@ -71,7 +74,8 @@ public ResolvedControllerConfiguration(
         configurations,
         fieldManager,
         configurationService,
-        informerConfig);
+        informerConfig,
+        controllerMode);
     setWorkflowSpec(workflowSpec);
   }
 
@@ -86,7 +90,8 @@ protected ResolvedControllerConfiguration(
       Map<DependentResourceSpec, Object> configurations,
       String fieldManager,
       ConfigurationService configurationService,
-      InformerConfiguration<P> informerConfig) {
+      InformerConfiguration<P> informerConfig,
+      ControllerMode controllerMode) {
     this.informerConfig = informerConfig;
     this.configurationService = configurationService;
     this.name = ControllerConfiguration.ensureValidName(name, associatedReconcilerClassName);
@@ -99,6 +104,7 @@ protected ResolvedControllerConfiguration(
     this.finalizer =
         ControllerConfiguration.ensureValidFinalizerName(finalizer, getResourceTypeName());
     this.fieldManager = fieldManager;
+    this.controllerMode = controllerMode;
   }
 
   protected ResolvedControllerConfiguration(
@@ -117,7 +123,8 @@ protected ResolvedControllerConfiguration(
         null,
         null,
         configurationService,
-        InformerConfiguration.builder(resourceClass).buildForController());
+        InformerConfiguration.builder(resourceClass).buildForController(),
+        null);
   }
 
   @Override
@@ -207,4 +214,9 @@ public <C> C getConfigurationFor(DependentResourceSpec<?, P, C> spec) {
   public String fieldManager() {
     return fieldManager;
   }
+
+  @Override
+  public ControllerMode getControllerMode() {
+    return controllerMode;
+  }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/Context.java

@@ -72,4 +72,8 @@ default <R> Stream<R> getSecondaryResourcesAsStream(Class<R> expectedType) {
    * @return {@code true} is another reconciliation is already scheduled, {@code false} otherwise
    */
   boolean isNextReconciliationImminent();
+
+  boolean isDeleteEventPresent();
+
+  boolean isDeleteFinalStateUnknown();
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/ControllerConfiguration.java

@@ -79,5 +79,5 @@ MaxReconciliationInterval maxReconciliationInterval() default
    */
   String fieldManager() default CONTROLLER_NAME_AS_FIELD_MANAGER;
 
-  ControllerMode allEventMode() default ControllerMode.DEFAULT;
+  ControllerMode controllerMode() default ControllerMode.DEFAULT;
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/DefaultContext.java

@@ -24,12 +24,21 @@ public class DefaultContext<P extends HasMetadata> implements Context<P> {
   private final ControllerConfiguration<P> controllerConfiguration;
   private final DefaultManagedWorkflowAndDependentResourceContext<P>
       defaultManagedDependentResourceContext;
-
-  public DefaultContext(RetryInfo retryInfo, Controller<P> controller, P primaryResource) {
+  private final boolean isDeleteEventPresent;
+  private final boolean isDeleteFinalStateUnknown;
+
+  public DefaultContext(
+      RetryInfo retryInfo,
+      Controller<P> controller,
+      P primaryResource,
+      boolean isDeleteEventPresent,
+      boolean isDeleteFinalStateUnknown) {
     this.retryInfo = retryInfo;
     this.controller = controller;
     this.primaryResource = primaryResource;
     this.controllerConfiguration = controller.getConfiguration();
+    this.isDeleteEventPresent = isDeleteEventPresent;
+    this.isDeleteFinalStateUnknown = isDeleteFinalStateUnknown;
     this.defaultManagedDependentResourceContext =
         new DefaultManagedWorkflowAndDependentResourceContext<>(controller, primaryResource, this);
   }
@@ -119,6 +128,16 @@ public boolean isNextReconciliationImminent() {
         .isNextReconciliationImminent(ResourceID.fromResource(primaryResource));
   }
 
+  @Override
+  public boolean isDeleteEventPresent() {
+    return isDeleteEventPresent;
+  }
+
+  @Override
+  public boolean isDeleteFinalStateUnknown() {
+    return isDeleteFinalStateUnknown;
+  }
+
   public DefaultContext<P> setRetryInfo(RetryInfo retryInfo) {
     this.retryInfo = retryInfo;
     return this;

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/EventProcessor.java

@@ -15,7 +15,6 @@
 import io.javaoperatorsdk.operator.OperatorException;
 import io.javaoperatorsdk.operator.api.config.ConfigurationService;
 import io.javaoperatorsdk.operator.api.config.ControllerConfiguration;
-import io.javaoperatorsdk.operator.api.config.ControllerMode;
 import io.javaoperatorsdk.operator.api.monitoring.Metrics;
 import io.javaoperatorsdk.operator.api.reconciler.Constants;
 import io.javaoperatorsdk.operator.processing.LifecycleAware;
@@ -24,6 +23,7 @@
 import io.javaoperatorsdk.operator.processing.event.rate.RateLimiter.RateLimitState;
 import io.javaoperatorsdk.operator.processing.event.source.Cache;
 import io.javaoperatorsdk.operator.processing.event.source.controller.ResourceAction;
+import io.javaoperatorsdk.operator.processing.event.source.controller.ResourceDeleteEvent;
 import io.javaoperatorsdk.operator.processing.event.source.controller.ResourceEvent;
 import io.javaoperatorsdk.operator.processing.event.source.timer.TimerEventSource;
 import io.javaoperatorsdk.operator.processing.retry.Retry;
@@ -123,7 +123,7 @@ public synchronized void handleEvent(Event event) {
   }
 
   private void handleMarkedEventForResource(ResourceState state) {
-    if (state.deleteEventPresent() && !isAllEventMode()) {
+    if (state.deleteEventPresent() && !controllerConfiguration.isAllEventReconcileMode()) {
       cleanupForDeletedEvent(state.getId());
     } else if (!state.processedMarkForDeletionPresent()) {
       submitReconciliationExecution(state);
@@ -180,7 +180,9 @@ private void handleEventMarking(Event event, ResourceState state) {
     if (event instanceof ResourceEvent resourceEvent) {
       if (resourceEvent.getAction() == ResourceAction.DELETED) {
         log.debug("Marking delete event received for: {}", relatedCustomResourceID);
-        state.markDeleteEventReceived(resourceEvent.getResource().orElseThrow());
+        state.markDeleteEventReceived(
+            resourceEvent.getResource().orElseThrow(),
+            ((ResourceDeleteEvent) resourceEvent).isDeletedFinalStateUnknown());
       } else {
         if (state.processedMarkForDeletionPresent() && isResourceMarkedForDeletion(resourceEvent)) {
           log.debug(
@@ -252,7 +254,8 @@ synchronized void eventProcessingFinished(
     }
     cleanupOnSuccessfulExecution(executionScope);
     metrics.finishedReconciliation(executionScope.getResource(), metricsMetadata);
-    if (state.deleteEventPresent()) {
+    if ((controllerConfiguration.isAllEventReconcileMode() && executionScope.isDeleteEvent())
+        || (!controllerConfiguration.isAllEventReconcileMode() && state.deleteEventPresent())) {
       cleanupForDeletedEvent(executionScope.getResourceID());
     } else if (postExecutionControl.isFinalizerRemoved()) {
       state.markProcessedMarkForDeletion();
@@ -451,6 +454,7 @@ private ReconcilerExecutor(ResourceID resourceID, ExecutionScope<P> executionSco
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public void run() {
       if (!running) {
         // this is needed for the case when controller stopped, but there is a graceful shutdown
@@ -465,15 +469,26 @@ public void run() {
       try {
         var actualResource = cache.get(resourceID);
         if (actualResource.isEmpty()) {
-          if (isAllEventMode()) {
+          if (controllerConfiguration.isAllEventReconcileMode()) {
+            log.debug(
+                "Resource not found in the cache, checking for delete event resource: {}",
+                resourceID);
             var state = resourceStateManager.get(resourceID);
             actualResource =
                 (Optional<P>)
-                    state.filter(s -> s.deleteEventPresent()).map(s -> s.getLastKnownResource());
+                    state
+                        .filter(ResourceState::deleteEventPresent)
+                        .map(ResourceState::getLastKnownResource);
+            if (actualResource.isEmpty()) {
+              log.debug(
+                  "Skipping execution; delete event resource not found in state: {}", resourceID);
+              return;
+            }
+            executionScope.setDeleteEvent(true);
+          } else {
+            log.debug("Skipping execution; primary resource missing from cache: {}", resourceID);
+            return;
           }
-
-          log.debug("Skipping execution; primary resource missing from cache: {}", resourceID);
-          return;
         }
         actualResource.ifPresent(executionScope::setResource);
         MDCUtils.addResourceInfo(executionScope.getResource());
@@ -509,8 +524,4 @@ public synchronized boolean isUnderProcessing(ResourceID resourceID) {
   public synchronized boolean isRunning() {
     return running;
   }
-
-  private boolean isAllEventMode() {
-    return controllerConfiguration.getMode() == ControllerMode.RECONCILE_ALL_EVENT;
-  }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/ExecutionScope.java

@@ -8,6 +8,8 @@ class ExecutionScope<R extends HasMetadata> {
   // the latest custom resource from cache
   private R resource;
   private final RetryInfo retryInfo;
+  private boolean deleteEvent = false;
+  private boolean isDeleteFinalStateUnknown = false;
 
   ExecutionScope(RetryInfo retryInfo) {
     this.retryInfo = retryInfo;
@@ -26,6 +28,22 @@ public ResourceID getResourceID() {
     return ResourceID.fromResource(resource);
   }
 
+  public boolean isDeleteEvent() {
+    return deleteEvent;
+  }
+
+  public void setDeleteEvent(boolean deleteEvent) {
+    this.deleteEvent = deleteEvent;
+  }
+
+  public boolean isDeleteFinalStateUnknown() {
+    return isDeleteFinalStateUnknown;
+  }
+
+  public void setDeleteFinalStateUnknown(boolean deleteFinalStateUnknown) {
+    isDeleteFinalStateUnknown = deleteFinalStateUnknown;
+  }
+
   @Override
   public String toString() {
     if (resource == null) {