feat: make EventDispatcher & ExecutionScope parameterized

Author: metacosm

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/Operator.java

@@ -137,7 +137,7 @@ public <R extends CustomResource> void register(
       }
 
       final var client = k8sClient.customResources(resClass);
-      EventDispatcher dispatcher = new EventDispatcher(controller, finalizer, client);
+      EventDispatcher<R> dispatcher = new EventDispatcher<>(controller, finalizer, client);
 
       CustomResourceCache customResourceCache = new CustomResourceCache(objectMapper);
       DefaultEventHandler defaultEventHandler =

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

@@ -21,31 +21,36 @@
 /**
  * Dispatches events to the Controller and handles Finalizers for a single type of Custom Resource.
  */
-public class EventDispatcher {
+public class EventDispatcher<R extends CustomResource> {
 
   private static final Logger log = LoggerFactory.getLogger(EventDispatcher.class);
 
-  private final ResourceController controller;
+  private final ResourceController<R> controller;
   private final String resourceFinalizer;
-  private final CustomResourceFacade customResourceFacade;
+  private final CustomResourceFacade<R> customResourceFacade;
   private EventSourceManager eventSourceManager;
 
   EventDispatcher(
-      ResourceController controller, String finalizer, CustomResourceFacade customResourceFacade) {
+      ResourceController<R> controller,
+      String finalizer,
+      CustomResourceFacade<R> customResourceFacade) {
     this.controller = controller;
     this.customResourceFacade = customResourceFacade;
     this.resourceFinalizer = finalizer;
   }
 
-  public EventDispatcher(ResourceController controller, String finalizer, MixedOperation client) {
-    this(controller, finalizer, new CustomResourceFacade(client));
+  public EventDispatcher(
+      ResourceController<R> controller,
+      String finalizer,
+      MixedOperation<R, KubernetesResourceList<R>, Resource<R>> client) {
+    this(controller, finalizer, new CustomResourceFacade<>(client));
   }
 
   public void setEventSourceManager(EventSourceManager eventSourceManager) {
     this.eventSourceManager = eventSourceManager;
   }
 
-  public PostExecutionControl handleExecution(ExecutionScope executionScope) {
+  public PostExecutionControl handleExecution(ExecutionScope<R> executionScope) {
     try {
       return handleDispatch(executionScope);
     } catch (RuntimeException e) {
@@ -54,8 +59,8 @@ public PostExecutionControl handleExecution(ExecutionScope executionScope) {
     }
   }
 
-  private PostExecutionControl handleDispatch(ExecutionScope executionScope) {
-    CustomResource resource = executionScope.getCustomResource();
+  private PostExecutionControl handleDispatch(ExecutionScope<R> executionScope) {
+    R resource = executionScope.getCustomResource();
     log.debug(
         "Handling events: {} for resource {}", executionScope.getEvents(), resource.getMetadata());
 
@@ -72,8 +77,8 @@ private PostExecutionControl handleDispatch(ExecutionScope executionScope) {
           executionScope);
       return PostExecutionControl.defaultDispatch();
     }
-    Context context =
-        new DefaultContext(
+    Context<R> context =
+        new DefaultContext<>(
             eventSourceManager,
             new EventList(executionScope.getEvents()),
             executionScope.getRetryInfo());
@@ -85,7 +90,7 @@ private PostExecutionControl handleDispatch(ExecutionScope executionScope) {
   }
 
   private PostExecutionControl handleCreateOrUpdate(
-      ExecutionScope executionScope, CustomResource resource, Context context) {
+      ExecutionScope<R> executionScope, R resource, Context<R> context) {
     if (!resource.hasFinalizer(resourceFinalizer) && !resource.isMarkedForDeletion()) {
       /*  We always add the finalizer if missing and not marked for deletion.
          We execute the controller processing only for processing the event sent as a results
@@ -100,9 +105,8 @@ private PostExecutionControl handleCreateOrUpdate(
           getUID(resource),
           getVersion(resource),
           executionScope);
-      UpdateControl<? extends CustomResource> updateControl =
-          controller.createOrUpdateResource(resource, context);
-      CustomResource updatedCustomResource = null;
+      UpdateControl<R> updateControl = controller.createOrUpdateResource(resource, context);
+      R updatedCustomResource = null;
       if (updateControl.isUpdateCustomResourceAndStatusSubResource()) {
         updatedCustomResource = updateCustomResource(updateControl.getCustomResource());
         updateControl
@@ -126,15 +130,15 @@ private PostExecutionControl handleCreateOrUpdate(
     }
   }
 
-  private PostExecutionControl handleDelete(CustomResource resource, Context context) {
+  private PostExecutionControl handleDelete(R resource, Context<R> context) {
     log.debug(
         "Executing delete for resource: {} with version: {}",
         getUID(resource),
         getVersion(resource));
     DeleteControl deleteControl = controller.deleteResource(resource, context);
     boolean hasFinalizer = resource.hasFinalizer(resourceFinalizer);
     if (deleteControl == DeleteControl.DEFAULT_DELETE && hasFinalizer) {
-      CustomResource customResource = removeFinalizer(resource);
+      R customResource = removeFinalizer(resource);
       return PostExecutionControl.customResourceUpdated(customResource);
     } else {
       log.debug(
@@ -147,20 +151,20 @@ private PostExecutionControl handleDelete(CustomResource resource, Context conte
     }
   }
 
-  private void updateCustomResourceWithFinalizer(CustomResource resource) {
+  private void updateCustomResourceWithFinalizer(R resource) {
     log.debug(
         "Adding finalizer for resource: {} version: {}", getUID(resource), getVersion(resource));
     resource.addFinalizer(resourceFinalizer);
     replace(resource);
   }
 
-  private CustomResource updateCustomResource(CustomResource resource) {
+  private R updateCustomResource(R resource) {
     log.debug("Updating resource: {} with version: {}", getUID(resource), getVersion(resource));
     log.trace("Resource before update: {}", resource);
     return replace(resource);
   }
 
-  private CustomResource removeFinalizer(CustomResource resource) {
+  private R removeFinalizer(R resource) {
     log.debug(
         "Removing finalizer on resource: {} with version: {}",
         getUID(resource),
@@ -169,7 +173,7 @@ private CustomResource removeFinalizer(CustomResource resource) {
     return customResourceFacade.replaceWithLock(resource);
   }
 
-  private CustomResource replace(CustomResource resource) {
+  private R replace(R resource) {
     log.debug(
         "Trying to replace resource {}, version: {}",
         resource.getMetadata().getName(),

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

@@ -5,14 +5,14 @@
 import io.javaoperatorsdk.operator.processing.event.Event;
 import java.util.List;
 
-public class ExecutionScope {
+public class ExecutionScope<R extends CustomResource> {
 
-  private List<Event> events;
+  private final List<Event> events;
   // the latest custom resource from cache
-  private CustomResource customResource;
-  private RetryInfo retryInfo;
+  private final R customResource;
+  private final RetryInfo retryInfo;
 
-  public ExecutionScope(List<Event> list, CustomResource customResource, RetryInfo retryInfo) {
+  public ExecutionScope(List<Event> list, R customResource, RetryInfo retryInfo) {
     this.events = list;
     this.customResource = customResource;
     this.retryInfo = retryInfo;
@@ -22,7 +22,7 @@ public List<Event> getEvents() {
     return events;
   }
 
-  public CustomResource getCustomResource() {
+  public R getCustomResource() {
     return customResource;
   }