Remove need for doneable and list classes

Replace with default dummy classes, adapt tests

Author: charlottemach

README.md

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

operator-framework/pom.xml

@@ -73,5 +73,10 @@
             <version>4.0.1</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>jboss</groupId>
+            <artifactId>javassist</artifactId>
+            <version>3.8.0.GA</version>
+        </dependency>
     </dependencies>
 </project>

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

@@ -5,9 +5,18 @@
 import io.fabric8.kubernetes.client.CustomResource;
 import io.fabric8.kubernetes.client.CustomResourceDoneable;
 import io.fabric8.kubernetes.client.CustomResourceList;
+import javassist.*;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 
 class ControllerUtils {
 
+    private final static Logger log = LoggerFactory.getLogger(Operator.class);
+    private static ClassPool pool;
+    private static Class generatedCustomResourceDoneable;
+
     static String getDefaultFinalizer(ResourceController controller) {
         return getAnnotation(controller).finalizerName();
     }
@@ -20,16 +29,94 @@ static String getCrdName(ResourceController controller) {
         return getAnnotation(controller).crdName();
     }
 
-    static <R extends CustomResource> Class<? extends CustomResourceList<R>> getCustomResourceListClass(ResourceController controller) {
-        return (Class<? extends CustomResourceList<R>>) getAnnotation(controller).customResourceListClass();
+    public static Class<? extends CustomResourceList> getCustomResourceListClass() {
+        return CustomResourceList.class;
+    }
+
+    public static <R extends CustomResource> Class<? extends CustomResourceDoneable<R>> getCustomResourceDoneableClass(ResourceController<R> controller) {
+        return createCustomResourceDoneableClass(controller);
+    }
+
+    private static <R extends CustomResource> Class<? extends CustomResourceDoneable<R>> createCustomResourceDoneableClass(ResourceController<R> controller) {
+        pool = ClassPool.getDefault();
+        pool.appendClassPath(new ClassClassPath(ControllerUtils.class));
+
+        String controllerName = StringUtils.substringAfterLast(controller.getClass().toString(), ".");
+        Class<R> customResourceClass = (Class<R>) getAnnotation(controller).customResourceClass();
+
+        String className = getPackageName(customResourceClass.getName(), controllerName + "CustomResourceDoneable");
+        if (isClassInPool(className)) {
+            return generatedCustomResourceDoneable;
+        }
+        String superClassName = "io.fabric8.kubernetes.client.CustomResourceDoneable";
+        CtClass customDoneable = getOrCreateClass(className, superClassName);
+
+        try {
+            CtClass customResource = pool.get(customResourceClass.getName());
+            CtClass function = pool.get("io.fabric8.kubernetes.api.builder.Function");
+            CtClass[] argTypes = {customResource, function};
+            CtConstructor ctConstructor = CtNewConstructor.make(argTypes, null, "super($1, $2);", customDoneable);
+            customDoneable.addConstructor(ctConstructor);
+
+        } catch (CannotCompileException | NotFoundException e) {
+            log.error("Error compiling constructor for CustomResourceDoneable class: {}", e);
+        }
+
+        Class<? extends CustomResourceDoneable<R>> doneableClass = getClassFromCtClass(customDoneable);
+        generatedCustomResourceDoneable = doneableClass;
+        return doneableClass;
+    }
+
+    private static boolean isClassInPool(String className) {
+        try {
+            pool.get(className);
+            return true;
+        } catch (NotFoundException e) {
+            log.debug("Class {} not in pool", className);
+            return false;
+        }
     }
 
-    static <R extends CustomResource> Class<? extends CustomResourceDoneable<R>> getCustomResourceDonebaleClass(ResourceController controller) {
-        return (Class<? extends CustomResourceDoneable<R>>) getAnnotation(controller).customResourceDoneableClass();
+    private static CtClass getOrCreateClass(String className, String superClassName){
+        CtClass customClass;
+        try {
+            customClass = pool.get(className);
+            customClass.defrost();
+        } catch (NotFoundException ce) {
+            log.info("Class not found, creating new: {}", className);
+            CtClass superClass = null;
+            try {
+                superClass = pool.get(superClassName);
+            } catch (NotFoundException sce) {
+                log.error("Error getting superClass: {}", sce);
+            }
+            customClass = pool.makeClass(className, superClass);
+        }
+        return customClass;
     }
 
     private static Controller getAnnotation(ResourceController controller) {
         return controller.getClass().getAnnotation(Controller.class);
     }
 
-}
+    private static String getPackageName(String customResourceName, String newClassName) {
+        CtClass customResource = null;
+        try {
+            customResource = pool.get(customResourceName);
+        } catch (NotFoundException e) {
+            log.error("Error getting class: {}", e);
+        }
+        String packageName = customResource != null ? customResource.getPackageName() : "";
+        return packageName + "." + newClassName;
+    }
+
+    private static Class getClassFromCtClass(CtClass customCtClass) {
+        Class customClass = null;
+        try {
+            customClass = customCtClass.toClass();
+        } catch (CannotCompileException e) {
+            log.error("Error transforming CtClass to Class: {}", e);
+        }
+        return customClass;
+    }
+}

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

@@ -59,8 +59,9 @@ private <R extends CustomResource> void registerController(ResourceController<R>
         CustomResourceDefinition crd = getCustomResourceDefinitionForController(controller);
         KubernetesDeserializer.registerCustomKind(getApiVersion(crd), getKind(crd), resClass);
 
-        Class<? extends CustomResourceList<R>> list = getCustomResourceListClass(controller);
-        Class<? extends CustomResourceDoneable<R>> doneable = getCustomResourceDonebaleClass(controller);
+        Class<? extends CustomResourceList<R>> list = (Class<? extends CustomResourceList<R>>) getCustomResourceListClass();
+
+        Class<? extends CustomResourceDoneable<R>> doneable = getCustomResourceDoneableClass(controller);
         MixedOperation client = k8sClient.customResources(crd, resClass, list, doneable);
         EventDispatcher eventDispatcher = new EventDispatcher(controller,
                 getDefaultFinalizer(controller), new EventDispatcher.CustomResourceReplaceFacade(client));

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

@@ -19,10 +19,9 @@
 
     Class<? extends CustomResource> customResourceClass();
 
-    Class<? extends CustomResourceList<? extends CustomResource>> customResourceListClass();
+    Class<? extends CustomResourceDoneable> customResourceDoneableClass() default CustomResourceDoneable.class;
 
-    Class<? extends CustomResourceDoneable<? extends CustomResource>> customResourceDoneableClass();
+    Class<? extends CustomResourceList> customResourceListClass() default CustomResourceList.class;
 
     String finalizerName() default DEFAULT_FINALIZER;
-
 }

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

@@ -1,6 +1,7 @@
 package com.github.containersolutions.operator;
 
 import com.github.containersolutions.operator.sample.TestCustomResource;
+import com.github.containersolutions.operator.sample.TestCustomResourceController;
 import io.fabric8.kubernetes.api.model.ConfigMap;
 import org.awaitility.Awaitility;
 import org.junit.jupiter.api.*;
@@ -50,6 +51,7 @@ public void manyResourcesGetCreatedUpdatedAndDeleted() throws InterruptedExcepti
                 .untilAsserted(() -> {
                     List<ConfigMap> items = integrationTest.getK8sClient().configMaps()
                             .inNamespace(TEST_NAMESPACE)
+                            .withLabel("managedBy", TestCustomResourceController.class.getSimpleName())
                             .list().getItems();
                     assertThat(items).hasSize(NUMBER_OF_RESOURCES_CREATED);
                 });
@@ -75,6 +77,7 @@ public void manyResourcesGetCreatedUpdatedAndDeleted() throws InterruptedExcepti
                 .untilAsserted(() -> {
                     List<ConfigMap> items = integrationTest.getK8sClient().configMaps()
                             .inNamespace(TEST_NAMESPACE)
+                            .withLabel("managedBy", TestCustomResourceController.class.getSimpleName())
                             .list().getItems();
                     assertThat(items).hasSize(NUMBER_OF_RESOURCES_CREATED - NUMBER_OF_RESOURCES_DELETED);
 

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

@@ -2,23 +2,23 @@
 
 import com.github.containersolutions.operator.sample.TestCustomResource;
 import com.github.containersolutions.operator.sample.TestCustomResourceController;
-import com.github.containersolutions.operator.sample.TestCustomResourceDoneable;
-import com.github.containersolutions.operator.sample.TestCustomResourceList;
+import io.fabric8.kubernetes.client.CustomResourceDoneable;
+import io.fabric8.kubernetes.client.CustomResourceList;
 import org.junit.jupiter.api.Test;
 
 import static com.github.containersolutions.operator.api.Controller.DEFAULT_FINALIZER;
 import static com.github.containersolutions.operator.sample.TestCustomResourceController.CRD_NAME;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class ControllerUtilsTest {
 
     @Test
     public void returnsValuesFromControllerAnnotationFinalizer() {
         assertEquals(DEFAULT_FINALIZER, ControllerUtils.getDefaultFinalizer(new TestCustomResourceController(null)));
         assertEquals(TestCustomResource.class, ControllerUtils.getCustomResourceClass(new TestCustomResourceController(null)));
-        assertEquals(TestCustomResourceDoneable.class, ControllerUtils.getCustomResourceDonebaleClass(new TestCustomResourceController(null)));
-        assertEquals(TestCustomResourceList.class, ControllerUtils.getCustomResourceListClass(new TestCustomResourceController(null)));
         assertEquals(CRD_NAME, ControllerUtils.getCrdName(new TestCustomResourceController(null)));
+        assertTrue(CustomResourceDoneable.class.isAssignableFrom(ControllerUtils.getCustomResourceDoneableClass(new TestCustomResourceController(null))));
+        assertEquals(CustomResourceList.class, ControllerUtils.getCustomResourceListClass());
     }
-
 }

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

@@ -1,11 +1,13 @@
 package com.github.containersolutions.operator;
 
+import com.github.containersolutions.operator.api.ResourceController;
 import com.github.containersolutions.operator.sample.*;
 import io.fabric8.kubernetes.api.model.NamespaceBuilder;
 import io.fabric8.kubernetes.api.model.ObjectMetaBuilder;
 import io.fabric8.kubernetes.api.model.apiextensions.CustomResourceDefinition;
-import io.fabric8.kubernetes.client.DefaultKubernetesClient;
-import io.fabric8.kubernetes.client.KubernetesClient;
+import io.fabric8.kubernetes.client.*;
+import io.fabric8.kubernetes.client.dsl.CreateOrReplaceable;
+import io.fabric8.kubernetes.client.dsl.Deletable;
 import io.fabric8.kubernetes.client.dsl.MixedOperation;
 import io.fabric8.kubernetes.client.dsl.Resource;
 import io.fabric8.kubernetes.client.utils.Serialization;
@@ -17,6 +19,8 @@
 import java.io.InputStream;
 import java.util.concurrent.TimeUnit;
 
+import static com.github.containersolutions.operator.ControllerUtils.getCustomResourceDoneableClass;
+import static com.github.containersolutions.operator.ControllerUtils.getCustomResourceListClass;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.awaitility.Awaitility.await;
 
@@ -26,8 +30,10 @@ public class IntegrationTestSupport {
     public static final String TEST_CUSTOM_RESOURCE_PREFIX = "test-custom-resource-";
     private final static Logger log = LoggerFactory.getLogger(IntegrationTestSupport.class);
     private KubernetesClient k8sClient;
-    private MixedOperation<TestCustomResource, TestCustomResourceList, TestCustomResourceDoneable,
-            Resource<TestCustomResource, TestCustomResourceDoneable>> crOperations;
+    private MixedOperation<TestCustomResource, CustomResourceList, CustomResourceDoneable,
+            Resource<TestCustomResource, CustomResourceDoneable>> crOperations;
+    private CreateOrReplaceable<TestCustomResource, TestCustomResource, CustomResourceDoneable> createOrReplaceable;
+    private Deletable<TestCustomResource> deleteable;
     private Operator operator;
 
 
@@ -52,7 +58,10 @@ public void cleanup() {
         k8sClient.customResourceDefinitions().createOrReplace(crd);
         KubernetesDeserializer.registerCustomKind(crd.getApiVersion(), crd.getKind(), TestCustomResource.class);
 
-        crOperations = k8sClient.customResources(crd, TestCustomResource.class, TestCustomResourceList.class, TestCustomResourceDoneable.class);
+        ResourceController<TestCustomResource> controller = new TestCustomResourceController(k8sClient);
+        Class listClass = getCustomResourceListClass();
+        Class doneableClass = getCustomResourceDoneableClass(controller);
+        crOperations = k8sClient.customResources(crd, TestCustomResource.class, listClass, doneableClass);
         crOperations.inNamespace(TEST_NAMESPACE).delete(crOperations.list().getItems());
         //we depend on the actual operator from the startup to handle the finalizers and clean up
         //resources from previous test runs
@@ -69,7 +78,9 @@ public void cleanup() {
 
         await("all config maps cleaned up").atMost(60, TimeUnit.SECONDS)
                 .untilAsserted(() -> {
-                    assertThat(k8sClient.configMaps().inNamespace(TEST_NAMESPACE).list().getItems()).isEmpty();
+                    assertThat(k8sClient.configMaps().inNamespace(TEST_NAMESPACE)
+                            .withLabel("managedBy", TestCustomResourceController.class.getSimpleName())
+                            .list().getItems().isEmpty());
                 });
 
         log.info("Cleaned up namespace " + TEST_NAMESPACE);
@@ -105,7 +116,7 @@ public KubernetesClient getK8sClient() {
         return k8sClient;
     }
 
-    public MixedOperation<TestCustomResource, TestCustomResourceList, TestCustomResourceDoneable, Resource<TestCustomResource, TestCustomResourceDoneable>> getCrOperations() {
+    public MixedOperation<TestCustomResource, CustomResourceList, CustomResourceDoneable, Resource<TestCustomResource, CustomResourceDoneable>> getCrOperations() {
         return crOperations;
     }
 

operator-framework/src/test/java/com/github/containersolutions/operator/sample/TestCustomResourceController.java

@@ -15,9 +15,7 @@
 
 @Controller(
         crdName = TestCustomResourceController.CRD_NAME,
-        customResourceClass = TestCustomResource.class,
-        customResourceListClass = TestCustomResourceList.class,
-        customResourceDoneableClass = TestCustomResourceDoneable.class)
+        customResourceClass = TestCustomResource.class)
 public class TestCustomResourceController implements ResourceController<TestCustomResource> {
 
     private static final Logger log = LoggerFactory.getLogger(TestCustomResourceController.class);