[maven-release-plugin] prepare release ebean-externalmapping-xml-12.5.1

* Add failing test case for generic querybeans

Types with generics arguments have not been processed correctly, they
will lose their generics. This is not critical in Java, as the language
has to be backwards compatible with Java 1.4, but will still become
highlighted as a warning in all common IDEs.

In Kotlin however, it's not a warning but a compile error.

* Fix problem with generics in scalar type arg

This fixes the issue introduced with ScalarType aware querybeans.

.travis/print_surefire_reports

@@ -7,4 +7,11 @@ do
     echo ${file}
     cat ${file}
     echo
-done
+done
+
+for file in ebean-autotune/target/surefire-reports/*.txt
+do
+    echo ${file}
+    cat ${file}
+    echo
+done

ebean-api/pom.xml

@@ -0,0 +1,141 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <artifactId>ebean-parent</artifactId>
+    <groupId>io.ebean</groupId>
+    <version>12.5.2-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>ebean-api</artifactId>
+
+  <properties>
+    <jackson-core.version>2.11.3</jackson-core.version>
+    <jackson-databind.version>2.11.3</jackson-databind.version>
+  </properties>
+
+  <dependencies>
+
+    <!--
+    Projects are expected to explicit depend on version
+    of slf4j that they want to use
+    -->
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>1.7.25</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>io.avaje</groupId>
+      <artifactId>avaje-config</artifactId>
+      <version>1.1</version>
+    </dependency>
+
+    <!--
+    Class retention Nonnull and Nullable annotations
+    to assist with IDE auto-completion with Ebean API
+    -->
+    <dependency>
+      <groupId>io.avaje</groupId>
+      <artifactId>avaje-jsr305</artifactId>
+      <version>1.0</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>persistence-api</artifactId>
+      <version>2.2.4</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-annotation</artifactId>
+      <version>6.13</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-types</artifactId>
+      <version>2.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-datasource</artifactId>
+      <version>6.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-migration</artifactId>
+      <version>12.1.4</version>
+    </dependency>
+
+    <!-- Jackson core used internally by Ebean -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-core</artifactId>
+      <version>${jackson-core.version}</version>
+      <optional>true</optional>
+    </dependency>
+
+    <!-- provided scope for JsonNode support -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>${jackson-databind.version}</version>
+      <optional>true</optional>
+    </dependency>
+
+    <!-- Provided scope so that the H2HistoryTrigger can live in Ebean core
+     and not require a separate module for it -->
+    <dependency>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+      <version>1.4.199</version>
+      <optional>true</optional>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.transaction</groupId>
+      <artifactId>jta</artifactId>
+      <version>1.1</version>
+      <optional>true</optional>
+    </dependency>
+
+    <!-- provided scope to read validation annotations Size etc -->
+    <dependency>
+      <groupId>javax.validation</groupId>
+      <artifactId>validation-api</artifactId>
+      <version>1.1.0.Final</version>
+      <optional>true</optional>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.servlet</groupId>
+      <artifactId>javax.servlet-api</artifactId>
+      <version>3.1.0</version>
+      <optional>true</optional>
+    </dependency>
+
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.5</version>
+        <configuration>
+          <archive>
+            <manifestFile>src/main/resources/META-INF/MANIFEST.MF</manifestFile>
+          </archive>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+
+</project>

ebean-api/src/main/java/io/ebean/Database.java

@@ -93,6 +93,11 @@ import java.util.concurrent.Callable;
  */
 public interface Database {
 
+  /**
+   * Shutdown the Database instance.
+   */
+  void shutdown();
+
   /**
    * Shutdown the Database instance programmatically.
    * <p>

ebean-api/src/main/java/io/ebean/DatabaseFactory.java

@@ -9,6 +9,7 @@ import javax.persistence.PersistenceException;
 import java.util.Iterator;
 import java.util.Properties;
 import java.util.ServiceLoader;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Creates Database instances.
@@ -30,6 +31,7 @@ import java.util.ServiceLoader;
  */
 public class DatabaseFactory {
 
+  private static final ReentrantLock lock = new ReentrantLock(false);
   private static SpiContainer container;
 
   static {
@@ -42,44 +44,63 @@ public class DatabaseFactory {
    * Call this prior to creating any Database instances or alternatively set the
    * ContainerConfig on the DatabaseConfig when creating the first Database instance.
    */
-  public static synchronized void initialiseContainer(ContainerConfig containerConfig) {
-    getContainer(containerConfig);
+  public static void initialiseContainer(ContainerConfig containerConfig) {
+    lock.lock();
+    try {
+      getContainer(containerConfig);
+    } finally {
+      lock.unlock();
+    }
   }
 
   /**
    * Create using properties to configure the database.
    */
-  public static synchronized Database create(String name) {
-    // construct based on loading properties files
-    return getContainer(null).createServer(name);
+  public static Database create(String name) {
+    lock.lock();
+    try {
+      return getContainer(null).createServer(name);
+    } finally {
+      lock.unlock();
+    }
   }
 
   /**
    * Create using the DatabaseConfig object to configure the database.
    */
-  public static synchronized Database create(DatabaseConfig config) {
-    if (config.getName() == null) {
-      throw new PersistenceException("The name is null (it is required)");
+  public static Database create(DatabaseConfig config) {
+    lock.lock();
+    try {
+      if (config.getName() == null) {
+        throw new PersistenceException("The name is null (it is required)");
+      }
+      Database server = createInternal(config);
+      if (config.isRegister()) {
+        DbPrimary.setSkip(true);
+        DbContext.getInstance().register(server, config.isDefaultServer());
+      }
+      return server;
+    } finally {
+      lock.unlock();
     }
-    Database server = createInternal(config);
-    if (config.isRegister()) {
-      DbPrimary.setSkip(true);
-      DbContext.getInstance().register(server, config.isDefaultServer());
-    }
-    return server;
   }
 
   /**
    * Create using the DatabaseConfig additionally specifying a classLoader to use as the context class loader.
    */
-  public static synchronized Database createWithContextClassLoader(DatabaseConfig config, ClassLoader classLoader) {
-    ClassLoader currentContextLoader = Thread.currentThread().getContextClassLoader();
-    Thread.currentThread().setContextClassLoader(classLoader);
+  public static Database createWithContextClassLoader(DatabaseConfig config, ClassLoader classLoader) {
+    lock.lock();
     try {
-      return DatabaseFactory.create(config);
+      ClassLoader currentContextLoader = Thread.currentThread().getContextClassLoader();
+      Thread.currentThread().setContextClassLoader(classLoader);
+      try {
+        return DatabaseFactory.create(config);
+      } finally {
+        // set the currentContextLoader back
+        Thread.currentThread().setContextClassLoader(currentContextLoader);
+      }
     } finally {
-      // set the currentContextLoader back
-      Thread.currentThread().setContextClassLoader(currentContextLoader);
+      lock.unlock();
     }
   }
 
@@ -89,8 +110,13 @@ public class DatabaseFactory {
    * This is typically invoked via JVM shutdown hook and not explicitly called.
    * </p>
    */
-  public static synchronized void shutdown() {
-    container.shutdown();
+  public static void shutdown() {
+    lock.lock();
+    try {
+      container.shutdown();
+    } finally {
+      lock.unlock();
+    }
   }
 
   private static Database createInternal(DatabaseConfig config) {
@@ -103,8 +129,7 @@ public class DatabaseFactory {
    * @param containerConfig the configuration controlling clustering communication
    */
   private static SpiContainer getContainer(ContainerConfig containerConfig) {
-
-    // thread safe in that all calling methods are synchronized
+    // thread safe in that all calling methods hold lock
     if (container != null) {
       return container;
     }
@@ -123,7 +148,6 @@ public class DatabaseFactory {
    * Create the container instance using the configuration.
    */
   protected static SpiContainer createContainer(ContainerConfig containerConfig) {
-
     Iterator<SpiContainerFactory> factories = ServiceLoader.load(SpiContainerFactory.class).iterator();
     if (factories.hasNext()) {
       return factories.next().create(containerConfig);

ebean-api/src/main/java/io/ebean/DbContext.java

@@ -8,6 +8,7 @@ import org.slf4j.LoggerFactory;
 import javax.persistence.PersistenceException;
 import java.util.HashMap;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Holds Database instances.
@@ -22,17 +23,11 @@ final class DbContext {
 
   private static final DbContext INSTANCE = new DbContext();
 
-  /**
-   * Cache for fast concurrent read access.
-   */
   private final ConcurrentHashMap<String, Database> concMap = new ConcurrentHashMap<>();
 
-  /**
-   * Cache for synchronized read, creation and put. Protected by the monitor object.
-   */
   private final HashMap<String, Database> syncMap = new HashMap<>();
 
-  private final Object monitor = new Object();
+  private final ReentrantLock lock = new ReentrantLock(false);
 
   /**
    * The 'default' Database.
@@ -91,27 +86,28 @@ final class DbContext {
     if (name == null || name.isEmpty()) {
       return defaultDatabase;
     }
-    // non-synchronized read
     Database server = concMap.get(name);
     if (server != null) {
       return server;
     }
-    // synchronized read, create and put
     return getWithCreate(name);
   }
 
   /**
-   * Synchronized read, create and put of Databases.
+   * Read, create and put of Databases.
    */
   private Database getWithCreate(String name) {
-    synchronized (monitor) {
+    lock.lock();
+    try {
       Database server = syncMap.get(name);
       if (server == null) {
         // register when creating server this way
-        server = EbeanServerFactory.create(name);
+        server = DatabaseFactory.create(name);
         register(server, false);
       }
       return server;
+    } finally {
+      lock.unlock();
     }
   }
 
@@ -123,12 +119,15 @@ final class DbContext {
   }
 
   private void registerWithName(String name, Database server, boolean isDefault) {
-    synchronized (monitor) {
+    lock.lock();
+    try {
       concMap.put(name, server);
       syncMap.put(name, server);
       if (isDefault) {
         defaultDatabase = server;
       }
+    } finally {
+      lock.unlock();
     }
   }
 

ebean-api/src/main/java/io/ebean/DbPrimary.java

@@ -3,6 +3,7 @@ package io.ebean;
 import io.avaje.config.Config;
 
 import java.util.Properties;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Provides singleton state for the default database.
@@ -11,47 +12,66 @@ import java.util.Properties;
  */
 class DbPrimary {
 
+  private static final ReentrantLock lock = new ReentrantLock(false);
   private static String defaultServerName;
-
   private static boolean skip;
 
   /**
    * Set whether to skip automatically creating the primary database.
    */
-  static synchronized void setSkip(boolean skip) {
-    DbPrimary.skip = skip;
+  static void setSkip(boolean skip) {
+    lock.lock();
+    try {
+      DbPrimary.skip = skip;
+    } finally {
+      lock.unlock();
+    }
   }
 
   /**
    * Return true to skip automatically creating the primary database.
    */
-  static synchronized boolean isSkip() {
-    return skip;
+  static boolean isSkip() {
+    lock.lock();
+    try {
+      return skip;
+    } finally {
+      lock.unlock();
+    }
   }
 
   /**
    * Return the default database name.
    */
-  static synchronized String getDefaultServerName() {
-    getProperties();
-    return defaultServerName;
+  static String getDefaultServerName() {
+    lock.lock();
+    try {
+      getProperties();
+      return defaultServerName;
+    } finally {
+      lock.unlock();
+    }
   }
 
   /**
    * Return the default configuration Properties.
    */
-  static synchronized Properties getProperties() {
-    if (defaultServerName == null) {
-      defaultServerName = determineDefaultServerName();
+  static Properties getProperties() {
+    lock.lock();
+    try {
+      if (defaultServerName == null) {
+        defaultServerName = determineDefaultServerName();
+      }
+      return Config.asProperties();
+    } finally {
+      lock.unlock();
     }
-    return Config.asProperties();
   }
 
   /**
    * Determine and return the default server name checking system environment variables and then global properties.
    */
   private static String determineDefaultServerName() {
-
     String defaultServerName = System.getenv("EBEAN_DB");
     defaultServerName = System.getProperty("db", defaultServerName);
     defaultServerName = System.getProperty("ebean_db", defaultServerName);

ebean-api/src/main/java/io/ebean/DocumentStore.java

@@ -1,7 +1,7 @@
 package io.ebean;
 
-import io.ebeanservice.docstore.api.DocQueryRequest;
-import io.ebeanservice.docstore.api.RawDoc;
+import io.ebean.docstore.DocQueryContext;
+import io.ebean.docstore.RawDoc;
 import javax.annotation.Nullable;
 
 import java.io.IOException;
@@ -69,7 +69,7 @@ public interface DocumentStore {
    * }</pre>
    */
   @Nullable
-  <T> T find(DocQueryRequest<T> request);
+  <T> T find(DocQueryContext<T> request);
 
   /**
    * Execute the find list query. This request is prepared to execute secondary queries.
@@ -86,7 +86,7 @@ public interface DocumentStore {
    *
    * }</pre>
    */
-  <T> List<T> findList(DocQueryRequest<T> request);
+  <T> List<T> findList(DocQueryContext<T> request);
 
   /**
    * Execute the query against the document store returning the paged list.
@@ -107,7 +107,7 @@ public interface DocumentStore {
    *
    * }</pre>
    */
-  <T> PagedList<T> findPagedList(DocQueryRequest<T> request);
+  <T> PagedList<T> findPagedList(DocQueryContext<T> request);
 
   /**
    * Execute the query against the document store with the expectation of a large set of results
@@ -129,7 +129,7 @@ public interface DocumentStore {
    *
    * }</pre>
    */
-  <T> void findEach(DocQueryRequest<T> query, Consumer<T> consumer);
+  <T> void findEach(DocQueryContext<T> query, Consumer<T> consumer);
 
   /**
    * Execute the query against the document store with the expectation of a large set of results
@@ -161,7 +161,7 @@ public interface DocumentStore {
    *
    * }</pre>
    */
-  <T> void findEachWhile(DocQueryRequest<T> query, Predicate<T> consumer);
+  <T> void findEachWhile(DocQueryContext<T> query, Predicate<T> consumer);
 
   /**
    * Find each processing raw documents.

ebean-api/src/main/java/io/ebean/EbeanServerFactory.java

@@ -39,28 +39,28 @@ public class EbeanServerFactory {
    * Call this prior to creating any EbeanServer instances or alternatively set the
    * ContainerConfig on the ServerConfig when creating the first EbeanServer instance.
    */
-  public static synchronized void initialiseContainer(ContainerConfig containerConfig) {
+  public static void initialiseContainer(ContainerConfig containerConfig) {
     DatabaseFactory.initialiseContainer(containerConfig);
   }
 
   /**
    * Create using ebean.properties to configure the database.
    */
-  public static synchronized EbeanServer create(String name) {
+  public static EbeanServer create(String name) {
     return (EbeanServer)DatabaseFactory.create(name);
   }
 
   /**
    * Create using the ServerConfig object to configure the database.
    */
-  public static synchronized EbeanServer create(ServerConfig config) {
+  public static EbeanServer create(ServerConfig config) {
     return (EbeanServer)DatabaseFactory.create(config);
   }
 
   /**
    * Create using the ServerConfig additionally specifying a classLoader to use as the context class loader.
    */
-  public static synchronized EbeanServer createWithContextClassLoader(ServerConfig config, ClassLoader classLoader) {
+  public static EbeanServer createWithContextClassLoader(ServerConfig config, ClassLoader classLoader) {
     return (EbeanServer)DatabaseFactory.createWithContextClassLoader(config, classLoader);
   }
 
@@ -70,7 +70,7 @@ public class EbeanServerFactory {
    * This is typically invoked via JVM shutdown hook and not explicitly called.
    * </p>
    */
-  public static synchronized void shutdown() {
+  public static void shutdown() {
     DatabaseFactory.shutdown();
   }
 

ebean-api/src/main/java/io/ebean/bean/BeanLoader.java

@@ -1,5 +1,7 @@
 package io.ebean.bean;
 
+import java.util.concurrent.locks.Lock;
+
 /**
  * Loads a entity bean.
  * <p>
@@ -18,4 +20,9 @@ public interface BeanLoader {
    */
   void loadBean(EntityBeanIntercept ebi);
 
+  /**
+   * Obtain a lock on the loader.
+   */
+  Lock lock();
+
 }

ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java

@@ -14,6 +14,8 @@ import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * This is the object added to every entity bean using byte code enhancement.
@@ -30,6 +32,8 @@ public final class EntityBeanIntercept implements Serializable {
   private static final int STATE_REFERENCE = 1;
   private static final int STATE_LOADED = 2;
 
+  private transient final ReentrantLock lock = new ReentrantLock(false);
+
   private transient NodeUsageCollector nodeUsageCollector;
 
   private transient PersistenceContext persistenceContext;
@@ -803,7 +807,8 @@ public final class EntityBeanIntercept implements Serializable {
    * Load the bean when it is a reference.
    */
   protected void loadBean(int loadProperty) {
-    synchronized (this) {
+    lock.lock();
+    try {
       if (beanLoader == null) {
         final Database database = DB.byName(ebeanServerName);
         if (database == null) {
@@ -811,14 +816,19 @@ public final class EntityBeanIntercept implements Serializable {
         }
         // For stand alone reference bean or after deserialisation lazy load
         // using the ebeanServer. Synchronise only on the bean.
-        loadBeanInternal(loadProperty, database.getPluginApi());
+        loadBeanInternal(loadProperty, database.getPluginApi().beanLoader());
         return;
       }
+    } finally {
+      lock.unlock();
     }
-    synchronized (beanLoader) {
+    final Lock lock = beanLoader.lock();
+    try {
       // Lazy loading using LoadBeanContext which supports batch loading
       // Synchronise on the beanLoader (a 'node' of the LoadBeanContext 'tree')
       loadBeanInternal(loadProperty, beanLoader);
+    } finally {
+      lock.unlock();
     }
   }
 

ebean-api/src/main/java/io/ebean/bean/SingleBeanLoader.java

@@ -2,11 +2,16 @@ package io.ebean.bean;
 
 import io.ebean.Database;
 
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 /**
  * BeanLoader used when single beans are loaded (which is usually not ideal / N+1).
  */
 public abstract class SingleBeanLoader implements BeanLoader {
 
+  private final ReentrantLock lock = new ReentrantLock(false);
+
   protected final Database database;
 
   SingleBeanLoader(Database database) {
@@ -18,6 +23,12 @@ public abstract class SingleBeanLoader implements BeanLoader {
     return database.getName();
   }
 
+  @Override
+  public Lock lock() {
+    lock.lock();
+    return lock;
+  }
+
   /**
    * Single bean lazy loaded when bean from L2 cache.
    */
@@ -45,4 +56,18 @@ public abstract class SingleBeanLoader implements BeanLoader {
       database.getPluginApi().loadBeanRef(ebi);
     }
   }
+
+  /**
+   * Single bean lazy loaded when a reference bean.
+   */
+  public static class Dflt extends SingleBeanLoader {
+    public Dflt(Database database) {
+      super(database);
+    }
+
+    @Override
+    public void loadBean(EntityBeanIntercept ebi) {
+      database.getPluginApi().loadBean(ebi);
+    }
+  }
 }