wip

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

Author: csviri

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

@@ -486,4 +486,8 @@ public boolean workflowContainsDependentForType(Class<?> clazz) {
     return managedWorkflow.getDependentResourcesByName().values().stream()
         .anyMatch(d -> d.resourceType().equals(clazz));
   }
+
+  public boolean isCleaner() {
+    return isCleaner;
+  }
 }

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

@@ -150,7 +150,7 @@ private void submitReconciliationExecution(ResourceState state) {
         state.setUnderProcessing(true);
         final var latest = maybeLatest.get();
         ExecutionScope<P> executionScope = new ExecutionScope<>(state.getRetry());
-        state.unMarkEventReceived();
+        state.unMarkEventReceived(controllerConfiguration.isAllEventReconcileMode());
         metrics.reconcileCustomResource(latest, state.getRetry(), metricsMetadata);
         log.debug("Executing events for custom resource. Scope: {}", executionScope);
         executor.execute(new ReconcilerExecutor(resourceID, executionScope));
@@ -197,10 +197,12 @@ private void handleEventMarking(Event event, ResourceState state) {
         // removed, but also the informers websocket is disconnected and later reconnected. So
         // meanwhile the resource could be deleted and recreated. In this case we just mark a new
         // event as below.
-        markEventReceived(state);
+        state.markEventReceived();
       }
     } else if (!state.deleteEventPresent() && !state.processedMarkForDeletionPresent()) {
-      markEventReceived(state);
+      state.markEventReceived();
+    } else if (controllerConfiguration.isAllEventReconcileMode() && state.deleteEventPresent()) {
+      state.markAdditionalEventAfterDeleteEvent();
     } else if (log.isDebugEnabled()) {
       log.debug(
           "Skipped marking event as received. Delete event present: {}, processed mark for"
@@ -210,11 +212,6 @@ private void handleEventMarking(Event event, ResourceState state) {
     }
   }
 
-  private void markEventReceived(ResourceState state) {
-    log.debug("Marking event received for: {}", state.getId());
-    state.markEventReceived();
-  }
-
   private boolean isResourceMarkedForDeletion(ResourceEvent resourceEvent) {
     return resourceEvent.getResource().map(HasMetadata::isMarkedForDeletion).orElse(false);
   }

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

@@ -98,7 +98,9 @@ && shouldNotDispatchToCleanupWhenMarkedForDeletion(originalResource)) {
             resourceForExecution,
             executionScope.isDeleteEvent(),
             executionScope.isDeleteFinalStateUnknown());
-    if (markedForDeletion && !configuration().isAllEventReconcileMode()) {
+
+    // checking the cleaner for all-event-mode
+    if (markedForDeletion && controller.isCleaner()) {
       return handleCleanup(resourceForExecution, originalResource, context);
     } else {
       return handleReconcile(executionScope, resourceForExecution, originalResource, context);

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

@@ -1,11 +1,16 @@
 package io.javaoperatorsdk.operator.processing.event;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.javaoperatorsdk.operator.processing.event.rate.RateLimiter.RateLimitState;
 import io.javaoperatorsdk.operator.processing.retry.RetryExecution;
 
 class ResourceState {
 
+  private static final Logger log = LoggerFactory.getLogger(ResourceState.class);
+
   /**
    * Manages the state of received events. Basically there can be only three distinct states
    * relevant for event processing. Either an event is received, so we eventually process or no
@@ -76,7 +81,8 @@ public void markDeleteEventReceived(
   }
 
   public boolean deleteEventPresent() {
-    return eventing == EventingState.DELETE_EVENT_PRESENT;
+    return eventing == EventingState.DELETE_EVENT_PRESENT
+        || eventing == EventingState.ADDITIONAL_EVENT_PRESENT_AFTER_DELETE_EVENT;
   }
 
   public boolean processedMarkForDeletionPresent() {
@@ -87,10 +93,22 @@ public void markEventReceived() {
     if (deleteEventPresent()) {
       throw new IllegalStateException("Cannot receive event after a delete event received");
     }
+    log.debug("Marking event received for: {}", getId());
     eventing = EventingState.EVENT_PRESENT;
   }
 
+  public void markAdditionalEventAfterDeleteEvent() {
+    if (!deleteEventPresent()) {
+      throw new IllegalStateException(
+          "Cannot mark additional event after delete event, if in current state not delete event"
+              + " present");
+    }
+    log.debug("Marking additional event after delete event: {}", getId());
+    eventing = EventingState.ADDITIONAL_EVENT_PRESENT_AFTER_DELETE_EVENT;
+  }
+
   public void markProcessedMarkForDeletion() {
+    log.debug("Marking processed mark for deletion: {}", getId());
     eventing = EventingState.PROCESSED_MARK_FOR_DELETION;
   }
 
@@ -110,15 +128,25 @@ public HasMetadata getLastKnownResource() {
     return lastKnownResource;
   }
 
-  public void unMarkEventReceived() {
+  public void unMarkEventReceived(boolean isAllEventReconcileMode) {
     switch (eventing) {
       case EVENT_PRESENT:
         eventing = EventingState.NO_EVENT_PRESENT;
         break;
       case PROCESSED_MARK_FOR_DELETION:
         throw new IllegalStateException("Cannot unmark processed marked for deletion.");
       case DELETE_EVENT_PRESENT:
-        throw new IllegalStateException("Cannot unmark delete event.");
+        if (!isAllEventReconcileMode) {
+          throw new IllegalStateException("Cannot unmark delete event.");
+        }
+        break;
+      case ADDITIONAL_EVENT_PRESENT_AFTER_DELETE_EVENT:
+        if (!isAllEventReconcileMode) {
+          throw new IllegalStateException(
+              "This state should not happen in non all-event-reconciliation mode");
+        }
+        eventing = EventingState.DELETE_EVENT_PRESENT;
+        break;
       case NO_EVENT_PRESENT:
         // do nothing
         break;

operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/ResourceStateManagerTest.java

@@ -82,7 +82,7 @@ public void cannotMarkEventAfterDeleteEventReceived() {
   public void listsResourceIDSWithEventsPresent() {
     state.markEventReceived();
     state2.markEventReceived();
-    state.unMarkEventReceived();
+    state.unMarkEventReceived(false);
 
     var res = manager.resourcesWithEventPresent();