feat: upgrade to k8s client 5.0 to simplify CR handling

.github/workflows/ci.yml

@@ -33,5 +33,5 @@ jobs:
           kubernetes version: ${{ matrix.kubernetes }}
           driver: 'docker'
       - name: Run integration tests
-        run: mvn -B package -P no-unit-tests --file pom.xml
+        run: mvn -e -B package -P no-unit-tests --file pom.xml
 

README.md

@@ -79,7 +79,7 @@ The Controller implements the business logic and describes all the classes neede
 
 ```java
 @Controller(customResourceClass = WebServer.class,
-        crdName = "webservers.sample.javaoperatorsdk")
+    crdName = "webservers.sample.javaoperatorsdk.io")
 public class WebServerController implements ResourceController<WebServer> {
 
     @Override

operator-framework/pom.xml

@@ -36,10 +36,6 @@
             <groupId>io.fabric8</groupId>
             <artifactId>openshift-client</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-lang3</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>

operator-framework/src/main/java/io/javaoperatorsdk/operator/ControllerUtils.java

@@ -1,89 +1,48 @@
 package io.javaoperatorsdk.operator;
 
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.fabric8.kubernetes.client.CustomResource;
 import io.javaoperatorsdk.operator.api.Controller;
 import io.javaoperatorsdk.operator.api.ResourceController;
-import io.fabric8.kubernetes.api.builder.Function;
-import io.fabric8.kubernetes.client.CustomResource;
-import io.fabric8.kubernetes.client.CustomResourceDoneable;
-import javassist.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.HashMap;
-import java.util.Map;
 
 
 public class ControllerUtils {
-
-    private final static double JAVA_VERSION = Double.parseDouble(System.getProperty("java.specification.version"));
     private static final String FINALIZER_NAME_SUFFIX = "/finalizer";
-
-    // this is just to support testing, this way we don't try to create class multiple times in memory with same name.
-    // note that other solution is to add a random string to doneable class name
-    private static Map<Class<? extends CustomResource>, Class<? extends CustomResourceDoneable<? extends CustomResource>>>
-            doneableClassCache = new HashMap<>();
-
+
     static String getFinalizer(ResourceController controller) {
         final String annotationFinalizerName = getAnnotation(controller).finalizerName();
         if (!Controller.NULL.equals(annotationFinalizerName)) {
             return annotationFinalizerName;
         }
-        final String crdName = getAnnotation(controller).crdName() + FINALIZER_NAME_SUFFIX;
-        return crdName;
+        return getDefaultFinalizerIdentifier(controller);
     }
-
+
+    static String getDefaultFinalizerIdentifier(ResourceController controller) {
+        return getAnnotation(controller).crdName() + FINALIZER_NAME_SUFFIX;
+    }
+
+    /**
+     * @param finalizer
+     * @return
+     * @deprecated this should be removed once k8s client provides that method on HasMetadata
+     */
+    static boolean isFinalizerValid(String finalizer) {
+        return HasMetadata.FINALIZER_NAME_MATCHER.reset(finalizer).matches();
+    }
+
     static boolean getGenerationEventProcessing(ResourceController controller) {
         return getAnnotation(controller).generationAwareEventProcessing();
     }
-
+    
     static <R extends CustomResource> Class<R> getCustomResourceClass(ResourceController<R> controller) {
         return (Class<R>) getAnnotation(controller).customResourceClass();
     }
-
+    
     static String getCrdName(ResourceController controller) {
         return getAnnotation(controller).crdName();
     }
-
-
-    public static <T extends CustomResource> Class<? extends CustomResourceDoneable<T>>
-    getCustomResourceDoneableClass(ResourceController<T> controller) {
-        try {
-            Class<? extends CustomResource> customResourceClass = getAnnotation(controller).customResourceClass();
-            String className = customResourceClass.getPackage().getName() + "." + customResourceClass.getSimpleName() + "CustomResourceDoneable";
-
-            if (doneableClassCache.containsKey(customResourceClass)) {
-                return (Class<? extends CustomResourceDoneable<T>>) doneableClassCache.get(customResourceClass);
-            }
-
-            ClassPool pool = ClassPool.getDefault();
-            pool.appendClassPath(new LoaderClassPath(Thread.currentThread().getContextClassLoader()));
-
-            CtClass superClass = pool.get(CustomResourceDoneable.class.getName());
-            CtClass function = pool.get(Function.class.getName());
-            CtClass customResource = pool.get(customResourceClass.getName());
-            CtClass[] argTypes = {customResource, function};
-            CtClass customDoneable = pool.makeClass(className, superClass);
-            CtConstructor ctConstructor = CtNewConstructor.make(argTypes, null, "super($1, $2);", customDoneable);
-            customDoneable.addConstructor(ctConstructor);
-
-            Class<? extends CustomResourceDoneable<T>> doneableClass;
-            if (JAVA_VERSION >= 9) {
-                doneableClass = (Class<? extends CustomResourceDoneable<T>>) customDoneable.toClass(customResourceClass);
-            } else {
-                doneableClass = (Class<? extends CustomResourceDoneable<T>>) customDoneable.toClass();
-            }
-            doneableClassCache.put(customResourceClass, doneableClass);
-            return doneableClass;
-        } catch (CannotCompileException | NotFoundException e) {
-            throw new IllegalStateException(e);
-        }
-    }
-
+
     private static Controller getAnnotation(ResourceController controller) {
         return controller.getClass().getAnnotation(Controller.class);
     }
-
-    public static boolean hasGivenFinalizer(CustomResource resource, String finalizer) {
-        return resource.getMetadata().getFinalizers() != null && resource.getMetadata().getFinalizers().contains(finalizer);
-    }
 }

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

@@ -1,33 +1,28 @@
 package io.javaoperatorsdk.operator;
 
-import io.javaoperatorsdk.operator.api.ResourceController;
-import io.javaoperatorsdk.operator.processing.EventDispatcher;
-import io.javaoperatorsdk.operator.processing.EventScheduler;
-import io.javaoperatorsdk.operator.processing.retry.GenericRetry;
-import io.javaoperatorsdk.operator.processing.retry.Retry;
+import java.util.Arrays;
+
 import io.fabric8.kubernetes.api.model.apiextensions.v1beta1.CustomResourceDefinition;
 import io.fabric8.kubernetes.client.CustomResource;
-import io.fabric8.kubernetes.client.CustomResourceDoneable;
 import io.fabric8.kubernetes.client.CustomResourceList;
 import io.fabric8.kubernetes.client.KubernetesClient;
 import io.fabric8.kubernetes.client.dsl.MixedOperation;
 import io.fabric8.kubernetes.client.dsl.base.CustomResourceDefinitionContext;
 import io.fabric8.kubernetes.client.dsl.internal.CustomResourceOperationsImpl;
-import io.fabric8.kubernetes.internal.KubernetesDeserializer;
+import io.javaoperatorsdk.operator.api.ResourceController;
+import io.javaoperatorsdk.operator.processing.EventDispatcher;
+import io.javaoperatorsdk.operator.processing.EventScheduler;
+import io.javaoperatorsdk.operator.processing.retry.GenericRetry;
+import io.javaoperatorsdk.operator.processing.retry.Retry;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-
 @SuppressWarnings("rawtypes")
 public class Operator {
 
     private final static Logger log = LoggerFactory.getLogger(Operator.class);
     private final KubernetesClient k8sClient;
-    private Map<Class<? extends CustomResource>, CustomResourceOperationsImpl> customResourceClients = new HashMap<>();
-
+
     public Operator(KubernetesClient k8sClient) {
         this.k8sClient = k8sClient;
     }
@@ -53,12 +48,10 @@ public <R extends CustomResource> void registerController(ResourceController<R>
     private <R extends CustomResource> void registerController(ResourceController<R> controller,
                                                                boolean watchAllNamespaces, Retry retry, String... targetNamespaces) throws OperatorException {
         Class<R> resClass = ControllerUtils.getCustomResourceClass(controller);
-        CustomResourceDefinitionContext crd = getCustomResourceDefinitionForController(controller);
-        KubernetesDeserializer.registerCustomKind(crd.getVersion(), crd.getKind(), resClass);
         String finalizer = ControllerUtils.getFinalizer(controller);
-        MixedOperation client = k8sClient.customResources(crd, resClass, CustomResourceList.class, ControllerUtils.getCustomResourceDoneableClass(controller));
+        MixedOperation client = k8sClient.customResources(resClass, CustomResourceList.class);
         EventDispatcher eventDispatcher = new EventDispatcher(controller,
-                finalizer, new EventDispatcher.CustomResourceFacade(client), ControllerUtils.getGenerationEventProcessing(controller));
+            finalizer, new EventDispatcher.CustomResourceFacade(client), ControllerUtils.getGenerationEventProcessing(controller));
         EventScheduler eventScheduler = new EventScheduler(eventDispatcher, retry);
         registerWatches(controller, client, resClass, watchAllNamespaces, targetNamespaces, eventScheduler);
     }
@@ -79,7 +72,6 @@ private <R extends CustomResource> void registerWatches(ResourceController<R> co
                 log.debug("Registered controller for namespace: {}", targetNamespace);
             }
         }
-        customResourceClients.put(resClass, (CustomResourceOperationsImpl) client);
         log.info("Registered Controller: '{}' for CRD: '{}' for namespaces: {}", controller.getClass().getSimpleName(),
                 resClass, targetNamespaces.length == 0 ? "[all/client namespace]" : Arrays.toString(targetNamespaces));
     }
@@ -93,21 +85,4 @@ private CustomResourceDefinitionContext getCustomResourceDefinitionForController
         CustomResourceDefinitionContext context = CustomResourceDefinitionContext.fromCrd(customResourceDefinition);
         return context;
     }
-
-    public Map<Class<? extends CustomResource>, CustomResourceOperationsImpl> getCustomResourceClients() {
-        return customResourceClients;
-    }
-
-    public <T extends CustomResource, L extends CustomResourceList<T>, D extends CustomResourceDoneable<T>> CustomResourceOperationsImpl<T, L, D>
-    getCustomResourceClients(Class<T> customResourceClass) {
-        return customResourceClients.get(customResourceClass);
-    }
-
-    private String getKind(CustomResourceDefinition crd) {
-        return crd.getSpec().getNames().getKind();
-    }
-
-    private String getApiVersion(CustomResourceDefinition crd) {
-        return crd.getSpec().getGroup() + "/" + crd.getSpec().getVersion();
-    }
 }

operator-framework/src/main/java/io/javaoperatorsdk/operator/api/Controller.java

@@ -1,12 +1,12 @@
 package io.javaoperatorsdk.operator.api;
 
-import io.fabric8.kubernetes.client.CustomResource;
-
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import io.fabric8.kubernetes.client.CustomResource;
+
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.TYPE})
 public @interface Controller {

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

@@ -1,18 +1,20 @@
 package io.javaoperatorsdk.operator.processing;
 
-import io.javaoperatorsdk.operator.ControllerUtils;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
 import io.fabric8.kubernetes.client.CustomResource;
 import io.fabric8.kubernetes.client.Watcher;
 import io.fabric8.kubernetes.client.dsl.MixedOperation;
 import io.fabric8.kubernetes.client.dsl.Resource;
-import io.javaoperatorsdk.operator.api.*;
+import io.javaoperatorsdk.operator.api.Context;
+import io.javaoperatorsdk.operator.api.DefaultContext;
+import io.javaoperatorsdk.operator.api.ResourceController;
+import io.javaoperatorsdk.operator.api.RetryInfo;
+import io.javaoperatorsdk.operator.api.UpdateControl;
 import org.slf4j.Logger;
 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.
  */
@@ -43,23 +45,24 @@ public void handleEvent(CustomResourceEvent event) {
             log.error("Received error for resource: {}", resource.getMetadata().getName());
             return;
         }
-        if (markedForDeletion(resource) && !ControllerUtils.hasGivenFinalizer(resource, resourceFinalizer)) {
-            log.debug("Skipping event dispatching since its marked for deletion but does not have finalizer: {}", event);
-            return;
-        }
+        final boolean markedForDeletion = resource.isMarkedForDeletion();
+        final boolean hasFinalizer = resource.hasFinalizer(resourceFinalizer);
         Context context = new DefaultContext(new RetryInfo(event.getRetryCount(), event.getRetryExecution().isLastExecution()));
-        if (markedForDeletion(resource)) {
+        if (markedForDeletion) {
+            if (!hasFinalizer) {
+                log.debug("Skipping event dispatching since its marked for deletion but has no default finalizer: {}", event);
+                return;
+            }
             boolean removeFinalizer = controller.deleteResource(resource, context);
-            boolean hasFinalizer = ControllerUtils.hasGivenFinalizer(resource, resourceFinalizer);
-            if (removeFinalizer && hasFinalizer) {
+            if (removeFinalizer) {
                 removeFinalizer(resource);
             } else {
                 log.debug("Skipping finalizer remove. removeFinalizer: {}, hasFinalizer: {} ",
-                        removeFinalizer, hasFinalizer);
+                    removeFinalizer, hasFinalizer);
             }
             cleanup(resource);
         } else {
-            if (!ControllerUtils.hasGivenFinalizer(resource, resourceFinalizer) && !markedForDeletion(resource)) {
+            if (!hasFinalizer) {
                 /*  We always add a finalizer if missing and not marked for deletion.
                     We execute the controller processing only for processing the event sent as a results
                     of the finalizer add. This will make sure that the resources are not created before
@@ -105,8 +108,10 @@ private void markLastGenerationProcessed(CustomResource resource) {
 
     private void updateCustomResourceWithFinalizer(CustomResource resource) {
         log.debug("Adding finalizer for resource: {} version: {}", resource.getMetadata().getName(),
-                resource.getMetadata().getResourceVersion());
-        addFinalizerIfNotPresent(resource);
+            resource.getMetadata().getResourceVersion());
+        if (resource.addFinalizer(resourceFinalizer)) {
+            log.info("Adding default finalizer to {}", resource.getMetadata());
+        }
         replace(resource);
     }
 
@@ -128,27 +133,13 @@ private void replace(CustomResource resource) {
         log.debug("Trying to replace resource {}, version: {}", resource.getMetadata().getName(), resource.getMetadata().getResourceVersion());
         customResourceFacade.replaceWithLock(resource);
     }
-
-    private void addFinalizerIfNotPresent(CustomResource resource) {
-        if (!ControllerUtils.hasGivenFinalizer(resource, resourceFinalizer) && !markedForDeletion(resource)) {
-            log.info("Adding finalizer {} to {}", resourceFinalizer, resource.getMetadata());
-            if (resource.getMetadata().getFinalizers() == null) {
-                resource.getMetadata().setFinalizers(new ArrayList<>(1));
-            }
-            resource.getMetadata().getFinalizers().add(resourceFinalizer);
-        }
-    }
-
-    private boolean markedForDeletion(CustomResource resource) {
-        return resource.getMetadata().getDeletionTimestamp() != null && !resource.getMetadata().getDeletionTimestamp().isEmpty();
-    }
-
+
     // created to support unit testing
     public static class CustomResourceFacade {
-
-        private final MixedOperation<?, ?, ?, Resource<CustomResource, ?>> resourceOperation;
-
-        public CustomResourceFacade(MixedOperation<?, ?, ?, Resource<CustomResource, ?>> resourceOperation) {
+        
+        private final MixedOperation<?, ?, Resource<CustomResource>> resourceOperation;
+        
+        public CustomResourceFacade(MixedOperation<?, ?, Resource<CustomResource>> resourceOperation) {
             this.resourceOperation = resourceOperation;
         }
 

operator-framework/src/main/java/io/javaoperatorsdk/operator/processing/EventScheduler.java

@@ -1,18 +1,18 @@
 package io.javaoperatorsdk.operator.processing;
 
 
-import io.javaoperatorsdk.operator.processing.retry.Retry;
-import io.fabric8.kubernetes.client.CustomResource;
-import io.fabric8.kubernetes.client.KubernetesClientException;
-import io.fabric8.kubernetes.client.Watcher;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.util.Optional;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
 
+import io.fabric8.kubernetes.client.CustomResource;
+import io.fabric8.kubernetes.client.Watcher;
+import io.fabric8.kubernetes.client.WatcherException;
+import io.javaoperatorsdk.operator.processing.retry.Retry;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Requirements:
  * <ul>
@@ -57,7 +57,7 @@ public void eventReceived(Watcher.Action action, CustomResource resource) {
         CustomResourceEvent event = new CustomResourceEvent(action, resource, retry);
         scheduleEventFromApi(event);
     }
-
+    
     void scheduleEventFromApi(CustomResourceEvent event) {
         try {
             lock.lock();
@@ -137,9 +137,9 @@ private void scheduleNotYetScheduledEventForExecution(String uuid) {
         CustomResourceEvent notScheduledEvent = eventStore.removeEventNotScheduled(uuid);
         scheduleEventForExecution(notScheduledEvent);
     }
-
+    
     @Override
-    public void onClose(KubernetesClientException e) {
+    public void onClose(WatcherException e) {
         log.error("Error: ", e);
         // we will exit the application if there was a watching exception, because of the bug in fabric8 client
         // see https://github.com/fabric8io/kubernetes-client/issues/1318