- generation aware impl different approach

Author: attila.meszaros

operator-framework/src/main/java/com/github/containersolutions/operator/ControllerUtils.java

@@ -28,6 +28,10 @@ static String getDefaultFinalizer(ResourceController controller) {
         return getAnnotation(controller).finalizerName();
     }
 
+    static boolean getGenerationEventProcessing(ResourceController controller) {
+        return getAnnotation(controller).generationAwareEventProcessing();
+    }
+
     static <R extends CustomResource> Class<R> getCustomResourceClass(ResourceController controller) {
         return (Class<R>) getAnnotation(controller).customResourceClass();
     }

operator-framework/src/main/java/com/github/containersolutions/operator/Operator.java

@@ -1,5 +1,6 @@
 package com.github.containersolutions.operator;
 
+import com.github.containersolutions.operator.api.Controller;
 import com.github.containersolutions.operator.api.ResourceController;
 import com.github.containersolutions.operator.processing.EventDispatcher;
 import com.github.containersolutions.operator.processing.EventScheduler;
@@ -59,7 +60,7 @@ private <R extends CustomResource> void registerController(ResourceController<R>
         String finalizer = getDefaultFinalizer(controller);
         MixedOperation client = k8sClient.customResources(crd, resClass, CustomResourceList.class, getCustomResourceDoneableClass(controller));
         EventDispatcher eventDispatcher = new EventDispatcher(controller,
-                finalizer, new EventDispatcher.CustomResourceFacade(client));
+                finalizer, new EventDispatcher.CustomResourceFacade(client), ControllerUtils.getGenerationEventProcessing(controller));
         EventScheduler eventScheduler = new EventScheduler(eventDispatcher, retry, finalizer);
         registerWatches(controller, client, resClass, watchAllNamespaces, targetNamespaces, eventScheduler);
     }

operator-framework/src/main/java/com/github/containersolutions/operator/api/Controller.java

@@ -19,4 +19,11 @@
 
     String finalizerName() default DEFAULT_FINALIZER;
 
+    /**
+     * If true, will process new event only if generation increased since the last processing, otherwise will
+     * process all events.
+     * See generation meta attribute
+     * <a href="https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/#status-subresource">here</a>
+     */
+    boolean generationAwareEventProcessing() default false;
 }

operator-framework/src/main/java/com/github/containersolutions/operator/processing/EventDispatcher.java

@@ -10,6 +10,8 @@
 import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Dispatches events to the Controller and handles Finalizers for a single type of Custom Resource.
@@ -21,13 +23,16 @@ public class EventDispatcher {
     private final ResourceController controller;
     private final String resourceDefaultFinalizer;
     private final CustomResourceFacade customResourceFacade;
+    private final boolean generationAware;
+    private final Map<String, Long> lastGenerationProcessedSuccessfully = new ConcurrentHashMap<>();
 
     public EventDispatcher(ResourceController controller,
                            String defaultFinalizer,
-                           CustomResourceFacade customResourceFacade) {
+                           CustomResourceFacade customResourceFacade, boolean generationAware) {
         this.controller = controller;
         this.customResourceFacade = customResourceFacade;
         this.resourceDefaultFinalizer = defaultFinalizer;
+        this.generationAware = generationAware;
     }
 
     public void handleEvent(CustomResourceEvent event) {
@@ -47,6 +52,7 @@ public void handleEvent(CustomResourceEvent event) {
             if (removeFinalizer && ControllerUtils.hasDefaultFinalizer(resource, resourceDefaultFinalizer)) {
                 removeDefaultFinalizer(resource);
             }
+            cleanup(resource);
         } else {
             if (!ControllerUtils.hasDefaultFinalizer(resource, resourceDefaultFinalizer) && !markedForDeletion(resource)) {
                 /*  We always add the default finalizer if missing and not marked for deletion.
@@ -56,16 +62,42 @@ public void handleEvent(CustomResourceEvent event) {
                  */
                 updateCustomResourceWithFinalizer(resource);
             } else {
-                UpdateControl<? extends CustomResource> updateControl = controller.createOrUpdateResource(resource, context);
-                if (updateControl.isUpdateStatusSubResource()) {
-                    customResourceFacade.updateStatus(updateControl.getCustomResource());
-                } else if (updateControl.isUpdateCustomResource()) {
-                    updateCustomResource(updateControl.getCustomResource());
+                if (!generationAware || largerGenerationThenProcessedBefore(resource)) {
+                    UpdateControl<? extends CustomResource> updateControl = controller.createOrUpdateResource(resource, context);
+                    if (updateControl.isUpdateStatusSubResource()) {
+                        customResourceFacade.updateStatus(updateControl.getCustomResource());
+                    } else if (updateControl.isUpdateCustomResource()) {
+                        updateCustomResource(updateControl.getCustomResource());
+                    }
+                    markLastGenerationProcessed(resource);
+                } else {
+                    log.debug("Skipping processing since generation not increased. Event: {}", event);
                 }
             }
         }
     }
 
+    public boolean largerGenerationThenProcessedBefore(CustomResource resource) {
+        Long lastGeneration = lastGenerationProcessedSuccessfully.get(resource.getMetadata().getUid());
+        if (lastGeneration == null) {
+            return true;
+        } else {
+            return resource.getMetadata().getGeneration() > lastGeneration;
+        }
+    }
+
+    private void cleanup(CustomResource resource) {
+        if (generationAware) {
+            lastGenerationProcessedSuccessfully.remove(resource.getMetadata().getUid());
+        }
+    }
+
+    private void markLastGenerationProcessed(CustomResource resource) {
+        if (generationAware) {
+            lastGenerationProcessedSuccessfully.put(resource.getMetadata().getUid(), resource.getMetadata().getGeneration());
+        }
+    }
+
     private void updateCustomResourceWithFinalizer(CustomResource resource) {
         log.debug("Adding finalizer for resource: {} version: {}", resource.getMetadata().getName(),
                 resource.getMetadata().getResourceVersion());

operator-framework/src/test/java/com/github/containersolutions/operator/ControllerUtilsTest.java

@@ -17,6 +17,7 @@ public void returnsValuesFromControllerAnnotationFinalizer() {
         assertEquals(DEFAULT_FINALIZER, ControllerUtils.getDefaultFinalizer(new TestCustomResourceController(null)));
         assertEquals(TestCustomResource.class, ControllerUtils.getCustomResourceClass(new TestCustomResourceController(null)));
         assertEquals(CRD_NAME, ControllerUtils.getCrdName(new TestCustomResourceController(null)));
+        assertEquals(false, ControllerUtils.getGenerationEventProcessing(new TestCustomResourceController(null)));
         assertTrue(CustomResourceDoneable.class.isAssignableFrom(ControllerUtils.getCustomResourceDoneableClass(new TestCustomResourceController(null))));
     }
 }

operator-framework/src/test/java/com/github/containersolutions/operator/EventDispatcherTest.java

@@ -27,7 +27,7 @@ class EventDispatcherTest {
     @BeforeEach
     void setup() {
         eventDispatcher = new EventDispatcher(resourceController,
-                DEFAULT_FINALIZER, customResourceFacade);
+                DEFAULT_FINALIZER, customResourceFacade, false);
 
         testCustomResource = getResource();