fix: DefaultEventHandler should get its cache from the CR event source

Author: metacosm

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

@@ -34,7 +34,6 @@ public class DefaultEventHandler implements EventHandler {
 
   private static final Logger log = LoggerFactory.getLogger(DefaultEventHandler.class);
 
-  private final CustomResourceCache customResourceCache;
   private final EventBuffer eventBuffer;
   private final Set<String> underProcessing = new HashSet<>();
   private final ScheduledThreadPoolExecutor executor;
@@ -49,20 +48,17 @@ public class DefaultEventHandler implements EventHandler {
   public DefaultEventHandler(
       ResourceController controller, ControllerConfiguration configuration, MixedOperation client) {
     this(
-        new CustomResourceCache(configuration.getConfigurationService().getObjectMapper()),
         new EventDispatcher(controller, configuration.getFinalizer(), client),
         configuration.getName(),
         GenericRetry.fromConfiguration(configuration.getRetryConfiguration()),
         configuration.getConfigurationService().concurrentReconciliationThreads());
   }
 
   DefaultEventHandler(
-      CustomResourceCache customResourceCache,
       EventDispatcher eventDispatcher,
       String relatedControllerName,
       Retry retry,
       int concurrentReconciliationThreads) {
-    this.customResourceCache = customResourceCache;
     this.eventDispatcher = eventDispatcher;
     this.retry = retry;
     this.controllerName = relatedControllerName;
@@ -103,7 +99,7 @@ private void executeBufferedEvents(String customResourceUid) {
     boolean newEventForResourceId = eventBuffer.containsEvents(customResourceUid);
     boolean controllerUnderExecution = isControllerUnderExecution(customResourceUid);
     Optional<CustomResource> latestCustomResource =
-        customResourceCache.getLatestResource(customResourceUid);
+        eventSourceManager.getLatestResource(customResourceUid);
 
     if (!controllerUnderExecution && newEventForResourceId && latestCustomResource.isPresent()) {
       setUnderExecutionProcessing(customResourceUid);
@@ -235,7 +231,7 @@ private void cacheUpdatedResourceIfChanged(
           getUID(originalCustomResource),
           getVersion(customResourceAfterExecution),
           getVersion(originalCustomResource));
-      this.customResourceCache.cacheResource(
+      eventSourceManager.cacheResource(
           customResourceAfterExecution,
           customResource ->
               getVersion(customResource).equals(originalResourceVersion)
@@ -246,7 +242,6 @@ private void cacheUpdatedResourceIfChanged(
   private void cleanupAfterDeletedEvent(String customResourceUid) {
     eventSourceManager.cleanup(customResourceUid);
     eventBuffer.cleanup(customResourceUid);
-    customResourceCache.cleanup(customResourceUid);
   }
 
   private boolean isControllerUnderExecution(String customResourceUid) {

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

@@ -6,6 +6,7 @@
 import io.fabric8.kubernetes.client.dsl.Resource;
 import io.javaoperatorsdk.operator.api.ResourceController;
 import io.javaoperatorsdk.operator.api.config.ControllerConfiguration;
+import io.javaoperatorsdk.operator.processing.CustomResourceCache;
 import io.javaoperatorsdk.operator.processing.DefaultEventHandler;
 import io.javaoperatorsdk.operator.processing.event.internal.CustomResourceEventSource;
 import io.javaoperatorsdk.operator.processing.event.internal.TimerEventSource;
@@ -15,6 +16,7 @@
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Predicate;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -134,5 +136,24 @@ public void cleanup(String customResourceUid) {
         .keySet()
         .forEach(k -> deRegisterCustomResourceFromEventSource(k, customResourceUid));
     eventSources.remove(customResourceUid);
+    getCache().cleanup(customResourceUid);
+  }
+
+  // todo: remove
+  public CustomResourceCache getCache() {
+    final var source =
+        (CustomResourceEventSource)
+            getRegisteredEventSources().get(CUSTOM_RESOURCE_EVENT_SOURCE_NAME);
+    return source.getCache();
+  }
+
+  // todo: remove
+  public Optional<CustomResource> getLatestResource(String customResourceUid) {
+    return getCache().getLatestResource(customResourceUid);
+  }
+
+  // todo: remove
+  public void cacheResource(CustomResource resource, Predicate<CustomResource> predicate) {
+    getCache().cacheResource(resource, predicate);
   }
 }

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

@@ -193,4 +193,9 @@ public void onClose(WatcherException e) {
       System.exit(1);
     }
   }
+
+  // todo: remove
+  public CustomResourceCache getCache() {
+    return customResourceCache;
+  }
 }

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

@@ -4,6 +4,8 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.timeout;
@@ -40,19 +42,18 @@ class DefaultEventHandlerTest {
   private CustomResourceCache customResourceCache = new CustomResourceCache();
   private DefaultEventSourceManager defaultEventSourceManagerMock =
       mock(DefaultEventSourceManager.class);
+
   private TimerEventSource retryTimerEventSourceMock = mock(TimerEventSource.class);
 
   private DefaultEventHandler defaultEventHandler =
       new DefaultEventHandler(
-          customResourceCache,
           eventDispatcherMock,
           "Test",
           null,
           ConfigurationService.DEFAULT_RECONCILIATION_THREADS_NUMBER);
 
   private DefaultEventHandler defaultEventHandlerWithRetry =
       new DefaultEventHandler(
-          customResourceCache,
           eventDispatcherMock,
           "Test",
           GenericRetry.defaultLimitedExponentialRetry(),
@@ -64,6 +65,19 @@ public void setup() {
         .thenReturn(retryTimerEventSourceMock);
     defaultEventHandler.setEventSourceManager(defaultEventSourceManagerMock);
     defaultEventHandlerWithRetry.setEventSourceManager(defaultEventSourceManagerMock);
+
+    // todo: remove
+    when(defaultEventSourceManagerMock.getCache()).thenReturn(customResourceCache);
+    doCallRealMethod().when(defaultEventSourceManagerMock).getLatestResource(any());
+    doCallRealMethod().when(defaultEventSourceManagerMock).cacheResource(any(), any());
+    doAnswer(
+            invocation -> {
+              final var resourceId = (String) invocation.getArgument(0);
+              customResourceCache.cleanup(resourceId);
+              return null;
+            })
+        .when(defaultEventSourceManagerMock)
+        .cleanup(any());
   }
 
   @Test