#16 - ENH: Support specifying database owner username, password and InitDatabase

Author: rbygrave

pom.xml

@@ -22,13 +22,13 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-datasource-api</artifactId>
-      <version>4.2</version>
+      <version>4.3</version>
     </dependency>
 
     <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
-      <version>1.7.12</version>
+      <version>1.7.25</version>
       <scope>provided</scope>
     </dependency>
 
@@ -40,6 +40,20 @@
       <scope>test</scope>
     </dependency>
 
+    <dependency>
+      <groupId>io.ebean.test</groupId>
+      <artifactId>ebean-test-docker</artifactId>
+      <version>2.2.2</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.postgresql</groupId>
+      <artifactId>postgresql</artifactId>
+      <version>42.2.5</version>
+      <scope>test</scope>
+    </dependency>
+
     <dependency>
       <groupId>ch.qos.logback</groupId>
       <artifactId>logback-classic</artifactId>
@@ -57,25 +71,4 @@
 
   </dependencies>
 
-  <build>
-    <plugins>
-
-      <plugin>
-        <groupId>io.repaint.maven</groupId>
-        <artifactId>tiles-maven-plugin</artifactId>
-        <version>2.12</version>
-        <extensions>true</extensions>
-        <configuration>
-          <tiles>
-            <tile>org.avaje.tile:java-compile:1.1</tile>
-            <tile>org.avaje.tile:dependency-tree:1.1</tile>
-            <tile>org.avaje.tile:pygments-doclet:1.1</tile>
-          </tiles>
-        </configuration>
-      </plugin>
-
-    </plugins>
-
-  </build>
-
 </project>

src/main/java/io/ebean/datasource/pool/ConnectionPool.java

@@ -6,6 +6,7 @@
 import io.ebean.datasource.DataSourceInitialiseException;
 import io.ebean.datasource.DataSourcePool;
 import io.ebean.datasource.DataSourcePoolListener;
+import io.ebean.datasource.InitDatabase;
 import io.ebean.datasource.PoolStatistics;
 import io.ebean.datasource.PoolStatus;
 import org.slf4j.Logger;
@@ -48,6 +49,8 @@ public class ConnectionPool implements DataSourcePool {
    */
   private final String name;
 
+  private final DataSourceConfig config;
+
   /**
    * Used to notify of changes to the DataSource status.
    */
@@ -189,7 +192,7 @@ public class ConnectionPool implements DataSourcePool {
   private long leakTimeMinutes;
 
   public ConnectionPool(String name, DataSourceConfig params) {
-
+    this.config = params;
     this.name = name;
     this.notify = params.getAlert();
     this.poolListener = params.getListener();
@@ -290,6 +293,10 @@ private void initialise() throws SQLException {
 
     logger.info(sb.toString());
 
+    if (config.useInitDatabase()) {
+      initialiseDatabase();
+    }
+
     try {
       queue.ensureMinimumConnections();
     } catch (SQLException e) {
@@ -300,6 +307,27 @@ private void initialise() throws SQLException {
     }
   }
 
+  /**
+   * Initialise the database using the owner credentials if we can't connect using the normal credentials.
+   * <p>
+   * That is, if we think the username doesn't exist in the DB, initialise the DB using the owner credentials.
+   * </p>
+   */
+  private void initialiseDatabase() throws SQLException {
+    try (Connection connection = createUnpooledConnection(connectionProps, false)) {
+      // successfully obtained a connection so skip initDatabase
+      connection.clearWarnings();
+    } catch (SQLException e) {
+      // expected when user does not exists, obtain a connection using owner credentials
+      try (Connection connection = createUnpooledConnection(config.getOwnerUsername(), config.getOwnerPassword())) {
+        // initialise the DB (typically create the user/role using the owner credentials etc)
+        InitDatabase initDatabase = config.getInitDatabase();
+        initDatabase.run(connection, config);
+        connection.commit();
+      }
+    }
+  }
+
   /**
    * Returns false.
    */
@@ -476,26 +504,33 @@ private void initConnection(Connection conn) throws SQLException {
   }
 
   /**
-   * Create a Connection that will not be part of the connection pool.
-   * <p>
-   * <p>
-   * When this connection is closed it will not go back into the pool.
-   * </p>
-   * <p>
-   * <p>
-   * If withDefaults is true then the Connection will have the autoCommit and
-   * transaction isolation set to the defaults for the pool.
-   * </p>
+   * Create an un-pooled connection with the given username and password.
+   */
+  public Connection createUnpooledConnection(String username, String password) throws SQLException {
+
+    Properties properties = new Properties(connectionProps);
+    properties.setProperty("user", username);
+    properties.setProperty("password", password);
+    return createUnpooledConnection(properties, true);
+  }
+
+  /**
+   * Create an un-pooled connection.
    */
   public Connection createUnpooledConnection() throws SQLException {
+    return createUnpooledConnection(connectionProps, true);
+  }
 
+  private Connection createUnpooledConnection(Properties properties, boolean notifyIsDown) throws SQLException {
     try {
-      Connection conn = DriverManager.getConnection(databaseUrl, connectionProps);
+      Connection conn = DriverManager.getConnection(databaseUrl, properties);
       initConnection(conn);
       return conn;
 
     } catch (SQLException ex) {
-      notifyDataSourceIsDown(null);
+      if (notifyIsDown) {
+        notifyDataSourceIsDown(null);
+      }
       throw ex;
     }
   }

src/test/java/io/ebean/datasource/FactoryTest.java

@@ -21,10 +21,33 @@ public void createPool() throws Exception {
 
     DataSourcePool pool = factory.createPool("test", config);
 
-    Connection connection = pool.getConnection();
+    try (Connection connection = pool.getConnection()) {
+      try (PreparedStatement stmt = connection.prepareStatement("create table junk (acol varchar(10))")) {
+        stmt.execute();
+        connection.commit();
+      }
+    }
+  }
+
+  @Test
+  public void dataSourceFactory_get_createPool() throws Exception {
+
+    DataSourceFactory factory = DataSourceFactory.get();
+
+    DataSourceConfig config = new DataSourceConfig();
+    config.setDriver("org.h2.Driver");
+    config.setUrl("jdbc:h2:mem:tests2");
+    config.setUsername("sa");
+    config.setPassword("");
+
+    DataSourcePool pool = factory.createPool("test", config);
 
-    PreparedStatement stmt = connection.prepareStatement("create table junk (acol varchar(10))");
-    stmt.execute();
+    try (Connection connection = pool.getConnection()) {
+      try (PreparedStatement stmt = connection.prepareStatement("create table junk (acol varchar(10))")) {
+        stmt.execute();
+        connection.commit();
+      }
+    }
 
   }
 }

src/test/java/io/ebean/datasource/PostgresInitTest.java

@@ -0,0 +1,52 @@
+package io.ebean.datasource;
+
+import io.ebean.docker.commands.PostgresConfig;
+import io.ebean.docker.commands.PostgresContainer;
+import org.testng.annotations.Test;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+public class PostgresInitTest {
+
+  @Test
+  public void test() throws SQLException {
+
+    PostgresConfig dockerConfig = new PostgresConfig("10");
+    dockerConfig.setPort("9999");
+    dockerConfig.setContainerName("pool_test");
+    dockerConfig.setDbName("app");
+    // create database with owner as "db_owner"
+    dockerConfig.setUser("db_owner");
+
+    PostgresContainer container = new PostgresContainer(dockerConfig);
+    try {
+      container.startWithDropCreate();
+
+      DataSourceConfig ds = new DataSourceConfig();
+      ds.setDriver("org.postgresql.Driver");
+      ds.setUrl("jdbc:postgresql://127.0.0.1:9999/app");
+
+      // our application credentials (typically same as db and schema name with Postgres)
+      ds.setUsername("app");
+      ds.setPassword("app_pass");
+
+      // database owner credentials used to create the "app" role as needed
+      ds.setOwnerUsername("db_owner");
+      ds.setOwnerPassword("test");
+
+      DataSourcePool pool = DataSourceFactory.get().createPool("app", ds);
+
+      try (Connection connection = pool.getConnection()) {
+        try (PreparedStatement statement = connection.prepareStatement("create table my_table (acol integer);")) {
+          statement.execute();
+        }
+        connection.commit();
+      }
+
+    } finally {
+      container.stopRemove();
+    }
+  }
+}