#19 - ENH: Generate META-INF/ebean-info.mf (such that we don't need ebean.mf)

Author: rbygrave

src/main/java/io/ebean/querybean/generator/Constants.java

@@ -27,4 +27,8 @@ interface Constants {
   String DB = "io.ebean.DB";
   String FETCHGROUP = "io.ebean.FetchGroup";
   String QUERY = "io.ebean.Query";
+
+  String MODULEINFO = "io.ebean.config.ModuleInfo";
+  String METAINF_MANIFEST = "META-INF/ebean-generated-info.mf";
+  String METAINF_SERVICES_MODULELOADER = "META-INF/services/io.ebean.config.ModuleInfoLoader";
 }

src/main/java/io/ebean/querybean/generator/ProcessingContext.java

@@ -1,5 +1,7 @@
 package io.ebean.querybean.generator;
 
+import javax.annotation.processing.Filer;
+import javax.annotation.processing.FilerException;
 import javax.annotation.processing.Messager;
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.SourceVersion;
@@ -17,34 +19,87 @@
 import javax.lang.model.util.Elements;
 import javax.lang.model.util.Types;
 import javax.tools.Diagnostic;
+import javax.tools.FileObject;
+import javax.tools.JavaFileObject;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.LineNumberReader;
+import java.io.Reader;
+import java.nio.file.NoSuchFileException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import static javax.tools.StandardLocation.CLASS_OUTPUT;
 
 /**
  * Context for the source generation.
  */
 class ProcessingContext implements Constants {
 
+  private final ProcessingEnvironment processingEnv;
   private final String generatedSources;
 
   private final Types typeUtils;
-
+  private final Filer filer;
   private final Messager messager;
-
   private final Elements elementUtils;
-
   private final String generatedAnnotation;
 
   private final PropertyTypeMap propertyTypeMap = new PropertyTypeMap();
 
+  private final ReadModuleInfo readModuleInfo;
+
+  /**
+   * All entity packages regardless of DB (for META-INF/ebean-generated-info.mf).
+   */
+  private final Set<String> allEntityPackages = new TreeSet<>();
+
+  /**
+   * The DB name prefixed entities.
+   */
+  private final Set<String> prefixEntities = new TreeSet<>();
+
+  /**
+   * Entity classes for the default database.
+   */
+  private final Set<String> dbEntities = new TreeSet<>();
+
+  /**
+   * Entity classes for non default databases.
+   */
+  private final Map<String, Set<String>> otherDbEntities = new TreeMap<>();
+
+  /**
+   * All loaded entities regardless of db (to detect ones we add back from loadedPrefixEntities).
+   */
+  private final Set<String> loaded = new HashSet<>();
+
+  /**
+   * For partial compile the previous list of prefixed entity classes.
+   */
+  private List<String> loadedPrefixEntities;
+
+  /**
+   * The package for the generated ModuleInfoLoader.
+   */
+  private String factoryPackage;
+
   ProcessingContext(ProcessingEnvironment processingEnv) {
+    this.processingEnv = processingEnv;
     this.typeUtils = processingEnv.getTypeUtils();
+    this.filer = processingEnv.getFiler();
     this.messager = processingEnv.getMessager();
     this.elementUtils = processingEnv.getElementUtils();
+
     boolean jdk8 = processingEnv.getSourceVersion().compareTo(SourceVersion.RELEASE_8) <= 0;
     this.generatedAnnotation = generatedAnnotation(jdk8);
     this.generatedSources = initGeneratedSources(processingEnv);
+    this.readModuleInfo = new ReadModuleInfo(this);
   }
 
   private String generatedAnnotation(boolean jdk8) {
@@ -274,8 +329,12 @@ private String packageAppend(String origPackage) {
   }
 
   /**
-   * Log an error message.
+   * Create a file writer for the given class name.
    */
+  JavaFileObject createWriter(String factoryClassName, Element originatingElement) throws IOException {
+    return filer.createSourceFile(factoryClassName, originatingElement);
+  }
+
   void logError(Element e, String msg, Object... args) {
     messager.printMessage(Diagnostic.Kind.ERROR, String.format(msg, args), e);
   }
@@ -294,4 +353,137 @@ boolean isGeneratedAvailable() {
   String getGeneratedAnnotation() {
     return generatedAnnotation;
   }
+
+  void readModuleInfo() {
+    String factory = loadMetaInfServices();
+    if (factory != null) {
+      TypeElement factoryType = elementUtils.getTypeElement(factory);
+      if (factoryType != null) {
+        // previous prefixed entities to add back for partial compile
+        loadedPrefixEntities = readModuleInfo.read(factoryType);
+      }
+    }
+  }
+
+  /**
+   * Register an entity with optional dbName.
+   */
+  void addEntity(String beanFullName, String dbName) {
+
+    loaded.add(beanFullName);
+    final String pkg = packageOf(beanFullName);
+    if (pkg != null) {
+      allEntityPackages.add(pkg);
+    }
+    if (dbName != null) {
+      prefixEntities.add(dbName + ":" + beanFullName);
+      otherDbEntities.computeIfAbsent(dbName, s -> new TreeSet<>()).add(beanFullName);
+    } else {
+      prefixEntities.add(beanFullName);
+      dbEntities.add(beanFullName);
+      updateFactoryPackage(pkg);
+    }
+  }
+
+  /**
+   * Add back entity classes for partial compile.
+   */
+  int complete() {
+
+    int added = 0;
+    if (loadedPrefixEntities != null) {
+      for (String oldPrefixEntity : loadedPrefixEntities) {
+        // maybe split as dbName:entityClass
+        final String[] prefixEntityClass = oldPrefixEntity.split(":");
+
+        String dbName = null;
+        String entityClass;
+        if (prefixEntityClass.length > 1) {
+          dbName = prefixEntityClass[0];
+          entityClass = prefixEntityClass[1];
+        } else {
+          entityClass = prefixEntityClass[0];
+        }
+        if (!loaded.contains(entityClass)) {
+          addEntity(entityClass, dbName);
+          added++;
+        }
+      }
+    }
+    return added;
+  }
+
+  private String packageOf(String beanFullName) {
+    final int pos = beanFullName.lastIndexOf('.');
+    if (pos > -1) {
+      return beanFullName.substring(0, pos);
+    }
+    return null;
+  }
+
+  private void updateFactoryPackage(String pkg) {
+    if (pkg != null && (factoryPackage == null || factoryPackage.length() > pkg.length())) {
+      factoryPackage = pkg;
+    }
+  }
+
+  FileObject createMetaInfServicesWriter() throws IOException {
+    return createMetaInfWriter(METAINF_SERVICES_MODULELOADER);
+  }
+
+  FileObject createManifestWriter() throws IOException {
+    return createMetaInfWriter(Constants.METAINF_MANIFEST);
+  }
+
+  FileObject createMetaInfWriter(String target) throws IOException {
+    return filer.createResource(CLASS_OUTPUT, "", target);
+  }
+
+  Set<String> getPrefixEntities() {
+    return prefixEntities;
+  }
+
+  Set<String> getDbEntities() {
+    return dbEntities;
+  }
+
+  Map<String, Set<String>> getOtherDbEntities() {
+    return otherDbEntities;
+  }
+
+
+  Set<String> getAllEntityPackages() {
+    return allEntityPackages;
+  }
+
+  String getFactoryPackage() {
+    return factoryPackage != null ? factoryPackage : "unknown";
+  }
+
+  /**
+   * Return the class name of the generated ModuleInfoLoader
+   * (such that we can read the current meta data for partial compile).
+   */
+  String loadMetaInfServices() {
+    try {
+      FileObject fileObject = processingEnv.getFiler().getResource(CLASS_OUTPUT, "", METAINF_SERVICES_MODULELOADER);
+      if (fileObject != null) {
+        Reader reader = fileObject.openReader(true);
+        LineNumberReader lineReader = new LineNumberReader(reader);
+        String line = lineReader.readLine();
+        if (line != null) {
+          return line.trim();
+        }
+      }
+
+    } catch (FileNotFoundException | NoSuchFileException e) {
+      // ignore - no services file yet
+    } catch (FilerException e) {
+      logNote(null, "FilerException reading services file: " + e.getMessage());
+    } catch (Exception e) {
+      e.printStackTrace();
+      logError(null, "Error reading services file: " + e.getMessage());
+    }
+    return null;
+  }
 }

src/main/java/io/ebean/querybean/generator/Processor.java

@@ -43,6 +43,7 @@ public Set<String> getSupportedAnnotationTypes() {
     Set<String> annotations = new LinkedHashSet<>();
     annotations.add(ENTITY);
     annotations.add(EMBEDDABLE);
+    annotations.add(MODULEINFO);
     return annotations;
   }
 
@@ -54,28 +55,42 @@ public SourceVersion getSupportedSourceVersion() {
   @Override
   public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
 
+    processingContext.readModuleInfo();
     int count = 0;
-
     for (TypeElement annotation : annotations) {
       for (Element element : roundEnv.getElementsAnnotatedWith(annotation)) {
         generateQueryBeans(element);
         count++;
       }
     }
+    final int loaded = processingContext.complete();
+    if (roundEnv.processingOver()) {
+      writeModuleInfoBean();
+    }
 
     if (count > 0) {
-      processingContext.logNote("Generated " + count + " query beans");
+      String msg = "Ebean APT generated %s query beans, loaded %s others - META-INF/ebean-generated-info.mf entity-packages: %s";
+      processingContext.logNote(msg, count, loaded, processingContext.getAllEntityPackages());
     }
 
     return true;
   }
 
+  private void writeModuleInfoBean() {
+    try {
+      SimpleModuleInfoWriter writer = new SimpleModuleInfoWriter(processingContext);
+      writer.write();
+    } catch (Throwable e) {
+      processingContext.logError(null, "Failed to write ModuleInfoLoader " + e.getMessage());
+    }
+  }
+
   private void generateQueryBeans(Element element) {
     try {
       SimpleQueryBeanWriter beanWriter = new SimpleQueryBeanWriter((TypeElement) element, processingContext);
       beanWriter.writeRootBean();
       beanWriter.writeAssocBean();
-    } catch (Exception e) {
+    } catch (Throwable e) {
       processingContext.logError(element, "Error generating query beans: " + e);
     }
   }