Native Image Friendly

README.md

@@ -78,8 +78,7 @@ public class Runner {
 The Controller implements the business logic and describes all the classes needed to handle the CRD.
 
 ```java
-@Controller(customResourceClass = WebServer.class,
-        crdName = "webservers.sample.javaoperatorsdk")
+@Controller(crdName = "webservers.sample.javaoperatorsdk")
 public class WebServerController implements ResourceController<WebServer> {
 
     @Override

operator-framework/pom.xml

@@ -31,6 +31,7 @@
         </plugins>
     </build>
 
+
     <dependencies>
         <dependency>
             <groupId>io.fabric8</groupId>
@@ -77,10 +78,26 @@
             <version>4.0.3</version>
             <scope>test</scope>
         </dependency>
+
+        <dependency>
+            <groupId>com.google.testing.compile</groupId>
+            <artifactId>compile-testing</artifactId>
+            <version>0.19</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.auto.service</groupId>
+            <artifactId>auto-service</artifactId>
+            <version>1.0-rc2</version>
+            <scope>compile</scope>
+        </dependency>
+
         <dependency>
-            <groupId>org.javassist</groupId>
-            <artifactId>javassist</artifactId>
-            <version>3.27.0-GA</version>
+            <groupId>com.squareup</groupId>
+            <artifactId>javapoet</artifactId>
+            <version>1.13.0</version>
+            <scope>compile</scope>
         </dependency>
     </dependencies>
 </project>

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

@@ -0,0 +1,56 @@
+package io.javaoperatorsdk.operator;
+
+import io.fabric8.kubernetes.client.CustomResource;
+import io.javaoperatorsdk.operator.api.ResourceController;
+import org.apache.commons.lang3.ClassUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+class ControllerToCustomResourceMappingsProvider {
+    private static final Logger log = LoggerFactory.getLogger(ControllerUtils.class);
+
+    static Map<Class<? extends ResourceController>, Class<? extends CustomResource>> provide(final String resourcePath) {
+        Map<Class<? extends ResourceController>, Class<? extends CustomResource>> controllerToCustomResourceMappings = new HashMap();
+        try {
+            final Enumeration<URL> customResourcesMetadataList = ControllerUtils.class.getClassLoader().getResources(resourcePath);
+            for (Iterator<URL> it = customResourcesMetadataList.asIterator(); it.hasNext(); ) {
+                URL url = it.next();
+
+                List<String> classNamePairs = retrieveClassNamePairs(url);
+                classNamePairs.forEach(clazzPair -> {
+                    try {
+                        final String[] classNames = clazzPair.split(",");
+                        if (classNames.length != 2) {
+                            throw new IllegalStateException(String.format("%s is not valid CustomResource metadata defined in %s", clazzPair, url.toString()));
+                        }
+
+                        controllerToCustomResourceMappings.put(
+                                (Class<? extends ResourceController>) ClassUtils.getClass(classNames[0]),
+                                (Class<? extends CustomResource>) ClassUtils.getClass(classNames[1])
+                        );
+                    } catch (ClassNotFoundException e) {
+                        throw new RuntimeException(e);
+                    }
+                });
+            }
+            log.debug("Loaded Controller to CustomResource mappings {}", controllerToCustomResourceMappings);
+            return controllerToCustomResourceMappings;
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static List<String> retrieveClassNamePairs(URL url) throws IOException {
+        return new BufferedReader(
+                new InputStreamReader(url.openStream())
+        ).lines().collect(Collectors.toList());
+    }
+}

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

@@ -1,43 +1,49 @@
 package io.javaoperatorsdk.operator;
 
-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 io.javaoperatorsdk.operator.api.Controller;
+import io.javaoperatorsdk.operator.api.ResourceController;
 
-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";
+    public static final String CONTROLLERS_RESOURCE_PATH = "javaoperatorsdk/controllers";
+    private static Map<Class<? extends ResourceController>, Class<? extends CustomResource>> controllerToCustomResourceMappings;
 
-    // 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 {
+        controllerToCustomResourceMappings =
+                ControllerToCustomResourceMappingsProvider
+                        .provide(CONTROLLERS_RESOURCE_PATH);
+    }
 
     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 getAnnotation(controller).crdName() + FINALIZER_NAME_SUFFIX;
     }
 
-    static boolean getGenerationEventProcessing(ResourceController controller) {
+    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();
+        final Class<? extends CustomResource> customResourceClass = controllerToCustomResourceMappings
+                .get(controller.getClass());
+        if (customResourceClass == null) {
+            throw new IllegalArgumentException(
+                    String.format(
+                            "No custom resource has been found for controller %s",
+                            controller.getClass().getCanonicalName()
+                    )
+            );
+        }
+        return (Class<R>) customResourceClass;
     }
 
     static String getCrdName(ResourceController controller) {
@@ -48,38 +54,15 @@ static String getCrdName(ResourceController controller) {
     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);
+            final Class<T> customResourceClass = getCustomResourceClass(controller);
+            return (Class<? extends CustomResourceDoneable<T>>) Class.forName(customResourceClass.getCanonicalName() + "Doneable");
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+            return null;
         }
     }
 
-    private static Controller getAnnotation(ResourceController controller) {
+    private static Controller getAnnotation(ResourceController<?> controller) {
         return controller.getClass().getAnnotation(Controller.class);
     }
 

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

@@ -1,6 +1,5 @@
 package io.javaoperatorsdk.operator.api;
 
-import io.fabric8.kubernetes.client.CustomResource;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
@@ -14,8 +13,6 @@
 
     String crdName();
 
-    Class<? extends CustomResource> customResourceClass();
-
     /**
      * Optional finalizer name, if it is not,
      * the crdName will be used as the name of the finalizer too.

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

@@ -0,0 +1,150 @@
+package io.javaoperatorsdk.operator.processing;
+
+import com.google.auto.service.AutoService;
+import com.squareup.javapoet.*;
+import io.fabric8.kubernetes.api.builder.Function;
+import io.fabric8.kubernetes.client.CustomResourceDoneable;
+import io.javaoperatorsdk.operator.api.ResourceController;
+import javax.annotation.processing.*;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.*;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.tools.Diagnostic;
+import javax.tools.FileObject;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardLocation;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static io.javaoperatorsdk.operator.ControllerUtils.CONTROLLERS_RESOURCE_PATH;
+
+@SupportedAnnotationTypes(
+        "io.javaoperatorsdk.operator.api.Controller")
+@SupportedSourceVersion(SourceVersion.RELEASE_8)
+@AutoService(Processor.class)
+public class ControllerAnnotationProcessor extends AbstractProcessor {
+    private FileObject resource;
+    PrintWriter printWriter = null;
+    private Set<String> generatedDoneableClassFiles = new HashSet<>();
+
+    @Override
+    public synchronized void init(ProcessingEnvironment processingEnv) {
+        super.init(processingEnv);
+        try {
+            resource = processingEnv.getFiler().createResource(StandardLocation.CLASS_OUTPUT, "", CONTROLLERS_RESOURCE_PATH);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        try {
+            printWriter = new PrintWriter(resource.openOutputStream());
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+        try {
+            for (TypeElement annotation : annotations) {
+                Set<? extends Element> annotatedElements
+                        = roundEnv.getElementsAnnotatedWith(annotation);
+                annotatedElements.stream().filter(element -> element.getKind().equals(ElementKind.CLASS))
+                        .map(e -> (TypeElement) e)
+                        .forEach(e -> this.generateDoneableClass(e, printWriter));
+            }
+        } finally {
+            printWriter.close();
+        }
+        return true;
+    }
+
+    private void generateDoneableClass(TypeElement controllerClassSymbol, PrintWriter printWriter) {
+        try {
+            final TypeMirror resourceType = findResourceType(controllerClassSymbol);
+
+            TypeElement customerResourceTypeElement = processingEnv
+                    .getElementUtils()
+                    .getTypeElement(resourceType.toString());
+
+            final String doneableClassName = customerResourceTypeElement.getSimpleName() + "Doneable";
+            final String destinationClassFileName = customerResourceTypeElement.getQualifiedName() + "Doneable";
+            final TypeName customResourceType = TypeName.get(resourceType);
+
+            if (!generatedDoneableClassFiles.add(destinationClassFileName)) {
+                processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE,
+                        String.format(
+                                "%s already exist! adding the mapping to the %s",
+                                destinationClassFileName,
+                                CONTROLLERS_RESOURCE_PATH)
+                );
+                printWriter.println(controllerClassSymbol.getQualifiedName() + "," + customResourceType.toString());
+                return;
+            }
+            JavaFileObject builderFile = processingEnv.getFiler()
+                    .createSourceFile(destinationClassFileName);
+
+            try (PrintWriter out = new PrintWriter(builderFile.openWriter())) {
+                printWriter.println(controllerClassSymbol.getQualifiedName() + "," + customResourceType.toString());
+                final MethodSpec constructor = MethodSpec.constructorBuilder()
+                        .addModifiers(Modifier.PUBLIC)
+                        .addParameter(customResourceType, "resource")
+                        .addParameter(Function.class, "function")
+                        .addStatement("super(resource,function)")
+                        .build();
+
+
+                final TypeSpec typeSpec = TypeSpec.classBuilder(doneableClassName)
+                        .superclass(ParameterizedTypeName.get(ClassName.get(CustomResourceDoneable.class), customResourceType))
+                        .addModifiers(Modifier.PUBLIC)
+                        .addMethod(constructor)
+                        .build();
+
+                final PackageElement packageElement = processingEnv.getElementUtils().getPackageOf(customerResourceTypeElement);
+                JavaFile file = JavaFile.builder(packageElement.getQualifiedName().toString(), typeSpec)
+                        .build();
+                file.writeTo(out);
+            }
+        } catch (Exception ioException) {
+            ioException.printStackTrace();
+        }
+    }
+
+    private TypeMirror findResourceType(TypeElement controllerClassSymbol) throws Exception {
+        try {
+            final DeclaredType controllerType = collectAllInterfaces(controllerClassSymbol)
+                    .stream()
+                    .filter(i -> i.toString()
+                            .startsWith(ResourceController.class.getCanonicalName())
+                    )
+                    .findFirst()
+                    .orElseThrow(() -> new Exception("ResourceController is not implemented by " + controllerClassSymbol.toString()));
+
+            return controllerType.getTypeArguments().get(0);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private List<DeclaredType> collectAllInterfaces(TypeElement element) {
+        try {
+            List<DeclaredType> interfaces = new ArrayList<>(element.getInterfaces()).stream().map(t -> (DeclaredType) t).collect(Collectors.toList());
+            TypeElement superclass = ((TypeElement) ((DeclaredType) element.getSuperclass()).asElement());
+            while (superclass.getSuperclass().getKind() != TypeKind.NONE) {
+                interfaces.addAll(superclass.getInterfaces().stream().map(t -> (DeclaredType) t).collect(Collectors.toList()));
+                superclass = ((TypeElement) ((DeclaredType) superclass.getSuperclass()).asElement());
+            }
+            return interfaces;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}

operator-framework/src/test/java/io/javaoperatorsdk/operator/ControllerUtilsTest.java

@@ -25,7 +25,7 @@ public void returnsValuesFromControllerAnnotationFinalizer() {
         assertTrue(CustomResourceDoneable.class.isAssignableFrom(ControllerUtils.getCustomResourceDoneableClass(new TestCustomResourceController(null))));
     }
 
-    @Controller(crdName = "test.crd", customResourceClass = TestCustomResource.class, finalizerName = CUSTOM_FINALIZER_NAME)
+    @Controller(crdName = "test.crd", finalizerName = CUSTOM_FINALIZER_NAME)
     static class TestCustomFinalizerController implements ResourceController<TestCustomResource> {
 
         @Override