Merge pull request operator-framework#134 from ContainerSolutions/retry_and_improved_status_support

Improved Retry and Sub Resource Support

Author: csviri

README.md

@@ -2,10 +2,10 @@
 ![Java CI with Maven](https://github.com/ContainerSolutions/java-operator-sdk/workflows/Java%20CI%20with%20Maven/badge.svg)
 
 SDK for building Kubernetes Operators in Java. Inspired by [operator-sdk](https://github.com/operator-framework/operator-sdk).
-In this first iteration we aim to provide a framework which handles the reconciliation loop by dispatching events to
-a Controller written by the user of the framework.
-
-The Controller only contains the logic to create, update and delete the actual resources related to the CRD.
+User (you) only writes the logic in a Controller that creates/updates or deletes resources related to a custom resource.
+All the issues around are handled by the framework for you.
+Check out this [blog post](https://blog.container-solutions.com/a-deep-dive-into-the-java-operator-sdk) 
+about the non-trivial yet common problems needs to be solved for every operator. 
 
 ## Join us on Discord!
 
@@ -61,16 +61,16 @@ The Controller implements the business logic and describes all the classes neede
 public class WebServerController implements ResourceController<WebServer> {
 
     @Override
-    public boolean deleteResource(CustomService resource) {
+    public boolean deleteResource(CustomService resource, Context<WebServer> context) {
         // ... your logic ...
         return true;
     }
 
     // Return the changed resource, so it gets updated. See javadoc for details.
     @Override
-    public Optional<CustomService> createOrUpdateResource(CustomService resource) {
+    public UpdateControl<CustomService> createOrUpdateResource(CustomService resource, Context<WebServer> context) {
         // ... your logic ...
-        return resource;
+        return UpdateControl.updateStatusSubResource(resource);
     }
 }
 ```
@@ -139,7 +139,7 @@ public class Application {
 }
 ```
 
-And add Spring's `@Service` annotation to your controller classes so they will be automatically registered as resource controllers.
+add Spring's `@Service` annotation to your controller classes so they will be automatically registered as resource controllers.
 
 The Operator's Spring Boot integration leverages [Spring's configuration mechanisms](https://docs.spring.io/spring-boot/docs/1.0.1.RELEASE/reference/html/boot-features-external-config.html) to configure
 - [The Kubernetes client](spring-boot-starter/src/main/java/com/github/containersolutions/operator/spingboot/starter/OperatorProperties.java)

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

@@ -13,7 +13,7 @@
 import java.util.Map;
 
 
-class ControllerUtils {
+public class ControllerUtils {
 
     private final static double JAVA_VERSION = Double.parseDouble(System.getProperty("java.specification.version"));
 
@@ -78,4 +78,11 @@ static String getCrdName(ResourceController controller) {
     private static Controller getAnnotation(ResourceController controller) {
         return controller.getClass().getAnnotation(Controller.class);
     }
+
+    public static boolean hasDefaultFinalizer(CustomResource resource, String finalizer) {
+        if (resource.getMetadata().getFinalizers() != null) {
+            return resource.getMetadata().getFinalizers().contains(finalizer);
+        }
+        return false;
+    }
 }

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

@@ -56,14 +56,15 @@ private <R extends CustomResource> void registerController(ResourceController<R>
         Class<R> resClass = getCustomResourceClass(controller);
         CustomResourceDefinition crd = getCustomResourceDefinitionForController(controller);
         KubernetesDeserializer.registerCustomKind(getApiVersion(crd), getKind(crd), resClass);
-
+        String finalizer = getDefaultFinalizer(controller);
         MixedOperation client = k8sClient.customResources(crd, resClass, CustomResourceList.class, getCustomResourceDoneableClass(controller));
         EventDispatcher eventDispatcher = new EventDispatcher(controller,
-                getDefaultFinalizer(controller), new EventDispatcher.CustomResourceReplaceFacade(client));
-        EventScheduler eventScheduler = new EventScheduler(eventDispatcher, retry, ControllerUtils.getGenerationEventProcessing(controller));
+                finalizer, new EventDispatcher.CustomResourceFacade(client), ControllerUtils.getGenerationEventProcessing(controller));
+        EventScheduler eventScheduler = new EventScheduler(eventDispatcher, retry);
         registerWatches(controller, client, resClass, watchAllNamespaces, targetNamespaces, eventScheduler);
     }
 
+
     private <R extends CustomResource> void registerWatches(ResourceController<R> controller, MixedOperation client,
                                                             Class<R> resClass,
                                                             boolean watchAllNamespaces, String[] targetNamespaces, EventScheduler eventScheduler) {

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

@@ -0,0 +1,9 @@
+package com.github.containersolutions.operator.api;
+
+import io.fabric8.kubernetes.client.CustomResource;
+
+public interface Context<T extends CustomResource> {
+
+    RetryInfo retryInfo();
+
+}

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

@@ -20,7 +20,7 @@
     String finalizerName() default DEFAULT_FINALIZER;
 
     /**
-     * If true, will process new event only if generation increased since the last processing, otherwise will
+     * If true, will dispatch new event to the controller 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>

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

@@ -0,0 +1,17 @@
+package com.github.containersolutions.operator.api;
+
+import io.fabric8.kubernetes.client.CustomResource;
+
+public class DefaultContext<T extends CustomResource> implements Context<T> {
+
+    private final RetryInfo retryInfo;
+
+    public DefaultContext(RetryInfo retryInfo) {
+        this.retryInfo = retryInfo;
+    }
+
+    @Override
+    public RetryInfo retryInfo() {
+        return retryInfo;
+    }
+}

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

@@ -2,8 +2,6 @@
 
 import io.fabric8.kubernetes.client.CustomResource;
 
-import java.util.Optional;
-
 public interface ResourceController<R extends CustomResource> {
 
     /**
@@ -17,7 +15,7 @@ public interface ResourceController<R extends CustomResource> {
      * @return true - so the finalizer is automatically removed after the call.
      * false if you don't want to remove the finalizer. Note that this is ALMOST NEVER the case.
      */
-    boolean deleteResource(R resource);
+    boolean deleteResource(R resource, Context<R> context);
 
     /**
      * The implementation of this operation is required to be idempotent.
@@ -28,6 +26,6 @@ public interface ResourceController<R extends CustomResource> {
      * this update can be skipped.
      * <b>However we will always call an update if there is no finalizer on object and its not marked for deletion.</b>
      */
-    Optional<R> createOrUpdateResource(R resource);
+    UpdateControl createOrUpdateResource(R resource, Context<R> context);
 
 }

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

@@ -0,0 +1,20 @@
+package com.github.containersolutions.operator.api;
+
+public class RetryInfo {
+
+    private int retryNumber;
+    private boolean lastAttempt;
+
+    public RetryInfo(int retryNumber, boolean lastAttempt) {
+        this.retryNumber = retryNumber;
+        this.lastAttempt = lastAttempt;
+    }
+
+    public int getRetryNumber() {
+        return retryNumber;
+    }
+
+    public boolean isLastAttempt() {
+        return lastAttempt;
+    }
+}

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

@@ -0,0 +1,44 @@
+package com.github.containersolutions.operator.api;
+
+import io.fabric8.kubernetes.client.CustomResource;
+
+public class UpdateControl<T extends CustomResource> {
+
+    private final T customResource;
+    private final boolean updateStatusSubResource;
+    private final boolean updateCustomResource;
+
+    private UpdateControl(T customResource, boolean updateStatusSubResource, boolean updateCustomResource) {
+        if ((updateCustomResource || updateStatusSubResource) && customResource == null) {
+            throw new IllegalArgumentException("CustomResource cannot be null in case of update");
+        }
+        this.customResource = customResource;
+        this.updateStatusSubResource = updateStatusSubResource;
+        this.updateCustomResource = updateCustomResource;
+    }
+
+    public static <T extends CustomResource> UpdateControl<T> updateCustomResource(T customResource) {
+        return new UpdateControl<>(customResource, false, true);
+    }
+
+    public static <T extends CustomResource> UpdateControl<T> updateStatusSubResource(T customResource) {
+        return new UpdateControl<>(customResource, true, false);
+    }
+
+    public static <T extends CustomResource> UpdateControl<T> noUpdate() {
+        return new UpdateControl<>(null, false, false);
+    }
+
+    public T getCustomResource() {
+        return customResource;
+    }
+
+    public boolean isUpdateStatusSubResource() {
+        return updateStatusSubResource;
+    }
+
+    public boolean isUpdateCustomResource() {
+        return updateCustomResource;
+    }
+
+}

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

@@ -14,13 +14,13 @@ public class CustomResourceEvent {
     private final CustomResource resource;
     private int retryCount = -1;
 
-    CustomResourceEvent(Watcher.Action action, CustomResource resource, Retry retry) {
+    public CustomResourceEvent(Watcher.Action action, CustomResource resource, Retry retry) {
         this.action = action;
         this.resource = resource;
         this.retryExecution = retry.initExecution();
     }
 
-    Watcher.Action getAction() {
+    public Watcher.Action getAction() {
         return action;
     }
 
@@ -32,8 +32,6 @@ public String resourceUid() {
         return resource.getMetadata().getUid();
     }
 
-
-
     public Optional<Long> nextBackOff() {
         retryCount++;
         return retryExecution.nextDelay();
@@ -50,4 +48,12 @@ public String toString() {
                 " ], retriesIndex=" + retryCount +
                 '}';
     }
+
+    public RetryExecution getRetryExecution() {
+        return retryExecution;
+    }
+
+    public int getRetryCount() {
+        return retryCount;
+    }
 }

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

@@ -1,7 +1,5 @@
 package com.github.containersolutions.operator.processing;
 
-import io.fabric8.kubernetes.client.CustomResource;
-import io.fabric8.kubernetes.client.Watcher;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -34,10 +32,8 @@ public void run() {
 
     @SuppressWarnings("unchecked")
     private boolean processEvent() {
-        Watcher.Action action = event.getAction();
-        CustomResource resource = event.getResource();
         try {
-            eventDispatcher.handleEvent(action, resource);
+            eventDispatcher.handleEvent(event);
         } catch (RuntimeException e) {
             log.error("Processing event {} failed.", event, e);
             return false;