[WIP] Refactor jdbc migration and use service loader

ebean-migration/pom.xml

@@ -19,6 +19,7 @@
 
   <properties>
     <nexus.staging.autoReleaseAfterClose>true</nexus.staging.autoReleaseAfterClose>
+    <surefire.useModulePath>false</surefire.useModulePath>
   </properties>
 
   <dependencies>

ebean-migration/src/main/java/io/ebean/migration/JdbcMigration.java

@@ -5,24 +5,56 @@
 /**
  * Interface to be implemented by Jdbc Java Migrations. By default the migration
  * version and description will be extracted from the class name. The checksum of this migration
- * (for validation) will also be null, unless the migration also implements the
- * MigrationChecksumProvider, in which case it can be returned programmatically.
+ * will be 0 by default
  * <p>
- * When the JdbcMigration implements ConfigurationAware, the master
- * {@link MigrationConfig} is automatically injected upon creation, which is
- * useful for getting placeholder and schema information.
+ * Note: Instances of JdbcMigration should be stateless, as the <code>migrate</code> method may
+ * run multiple times in multi-tenant setups.
+ * <p>
+ * There are several ways, how the JdbcMigrations are found.
+ * <ul>
+ *   <li><b>ServiceLoader</b> this is the default behaviour<br>
+ *   in this case add all your migration class names in META-INF/services/io.ebean.migration.JdbcMigration and/or in your
+ *   module info.</li>
+ *   <li>Using <b>jdbcMigrations</b> property<br>
+ *   you can specify all migrations in the jdbcMigrations property</li>
+ *   <li>Using own <b>jdbcMigrationFactory</b<br>
+ *   you can write your own jdbcMigrationFactory that provides JdbcMigrations</li>
+ * </ul>
  *
  * @author Roland Praml, FOCONIS AG
  */
 public interface JdbcMigration extends MigrationChecksumProvider {
 
   /**
    * Execute the migration using the connection.
+   * <p>
+   * Note: This API has changed with ebean-migration 13.12, as the initialization has changed.
+   * See https://github.com/ebean-orm/ebean-migration/issues/90 for migration advice.
    */
-  void migrate(Connection connection);
+  void migrate(Connection connection, MigrationConfig config);
 
   @Override
   default int getChecksum() {
     return 0;
   }
+
+  /**
+   * Returns the name of the JdbcMigration. Note, the value must follow the naming conventions, for MigrationVersions.
+   * (example: <code>V1_2_1__comment</code>)
+   * <p>
+   * By default, the simple classname will be returned.
+   */
+  default String getName() {
+    return getClass().getSimpleName();
+  }
+
+  /**
+   * Determines, if this migration can be used for that migrationConfig.
+   * Here, platform checks or other things can be implemented.
+   * <p>
+   * By default, <code>true</code> is returned.
+   */
+  default boolean matches(MigrationConfig config) {
+    return true;
+  }
 }

ebean-migration/src/main/java/io/ebean/migration/MigrationConfig.java

@@ -1,11 +1,16 @@
 package io.ebean.migration;
 
+import java.lang.reflect.Constructor;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.SQLException;
+import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.Properties;
+import java.util.ServiceLoader;
 import java.util.Set;
 
 /**
@@ -32,7 +37,7 @@ public class MigrationConfig {
   private boolean setCurrentSchema = true;
   private boolean allowErrorInRepeatable;
 
-  private JdbcMigrationFactory jdbcMigrationFactory = new DefaultMigrationFactory();
+  private Iterable<JdbcMigration> jdbcMigrationFactory = new DefaultMigrationFactory();
 
   /**
    * Versions that we want to insert into migration history without actually running.
@@ -418,17 +423,34 @@ public void setClassLoader(ClassLoader classLoader) {
   /**
    * Return the jdbcMigrationFactory.
    */
-  public JdbcMigrationFactory getJdbcMigrationFactory() {
+  public Iterable<JdbcMigration> getJdbcMigrationFactory() {
     return jdbcMigrationFactory;
   }
 
   /**
-   * Set the jdbcMigrationFactory.
+   * Set the jdbcMigrationFactory. If not set, the ServiceLoader is used.
+   * JdbcMigrationFactory can be either defined with the property <code>jdbcMigrationFactory</code>
+   * to a fully qualified class name implementing <code>Iterable&lt;JdbcMigration&gt;</code> or by
+   * specifying a comma separated list of JdbcMigrations in the <code>jdbcMigrations</code> property.
+   * <p>
+   * Note: If you plan to run migrations in multi-tenant env in multiple threads, the provided factory
+   * must be thread safe!
    */
-  public void setJdbcMigrationFactory(JdbcMigrationFactory jdbcMigrationFactory) {
+  public void setJdbcMigrationFactory(Iterable<JdbcMigration> jdbcMigrationFactory) {
     this.jdbcMigrationFactory = jdbcMigrationFactory;
   }
 
+  /**
+   * Helper method to set migrations with the <code>jdbcMigrations</code> property.
+   */
+  public void setJdbcMigrations(String... classNames) {
+    List<JdbcMigration> migrations = new ArrayList<>(classNames.length);
+    for (String className : classNames) {
+      migrations.add(newInstance(className.trim()));
+    }
+    setJdbcMigrationFactory(migrations);
+  }
+
   /**
    * Return the minVersion.
    */
@@ -484,6 +506,16 @@ public void load(Properties props) {
     minVersion = property("minVersion", minVersion);
     minVersionFailMessage = property("minVersionFailMessage", minVersionFailMessage);
 
+    String jdbcMigrationFactory = property("jdbcMigrationFactory");
+    if (jdbcMigrationFactory != null) {
+      setJdbcMigrationFactory(newInstance(jdbcMigrationFactory));
+    }
+
+    String jdbcMigrations = property("jdbcMigrations");
+    if (jdbcMigrations != null) {
+      setJdbcMigrations(jdbcMigrations.split(","));
+    }
+
     String patchInsertOn = property("patchInsertOn");
     if (patchInsertOn != null) {
       setPatchInsertOn(patchInsertOn);
@@ -498,6 +530,15 @@ public void load(Properties props) {
     }
   }
 
+  public <T> T newInstance(String className) {
+    try {
+      Class<?> cls = Class.forName(className, true, getClassLoader());
+      return (T) cls.getDeclaredConstructor().newInstance();
+    } catch (Exception e) {
+      throw new IllegalArgumentException("Error constructing " + className, e);
+    }
+  }
+
   private boolean property(String key, boolean value) {
     String val = property(key);
     return val != null ? Boolean.parseBoolean(val) : value;
@@ -611,25 +652,14 @@ public void setFastMode(boolean fastMode) {
   }
 
   /**
-   * Default factory. Uses the migration's class loader and injects the config if necessary.
-   *
-   * @author Roland Praml, FOCONIS AG
+   * Default implementation for service-loader. Note: ServiceLoader is not thread safe,
+   * so it is better to retrun a new iterator each time.
    */
-  public class DefaultMigrationFactory implements JdbcMigrationFactory {
+  private class DefaultMigrationFactory implements Iterable<JdbcMigration> {
 
     @Override
-    public JdbcMigration createInstance(String className) {
-      try {
-        Class<?> clazz = Class.forName(className, true, MigrationConfig.this.getClassLoader());
-        JdbcMigration migration = (JdbcMigration) clazz.getDeclaredConstructor().newInstance();
-        if (migration instanceof ConfigurationAware) {
-          ((ConfigurationAware) migration).setMigrationConfig(MigrationConfig.this);
-        }
-        return migration;
-      } catch (Exception e) {
-        throw new IllegalArgumentException(className + " is not a valid JdbcMigration", e);
-      }
+    public Iterator<JdbcMigration> iterator() {
+      return ServiceLoader.load(JdbcMigration.class, getClassLoader()).iterator();
     }
   }
-
 }

ebean-migration/src/main/java/io/ebean/migration/runner/LocalJdbcMigrationResource.java

@@ -15,8 +15,8 @@ final class LocalJdbcMigrationResource extends LocalMigrationResource {
   /**
    * Construct with version and resource.
    */
-  LocalJdbcMigrationResource(MigrationVersion version, String location, JdbcMigration migration) {
-    super(version, location);
+  LocalJdbcMigrationResource(MigrationVersion version, JdbcMigration migration) {
+    super(version, migration.getClass().getName());
     this.migration = migration;
   }