Add support for password2 and transparent password rotation

That is, we can configure the pool with a second password,
and when there is an error creating a new connection with
the first password the pool attempts to switch over to the
second password transparently to the application.

Author: rbygrave

ebean-datasource-api/pom.xml

@@ -22,7 +22,7 @@
     <dependency>
       <groupId>io.avaje</groupId>
       <artifactId>junit</artifactId>
-      <version>1.1</version>
+      <version>1.3</version>
       <scope>test</scope>
     </dependency>
 

ebean-datasource-api/src/main/java/io/ebean/datasource/DataSourceConfig.java

@@ -29,6 +29,7 @@ public class DataSourceConfig {
   private String url;
   private String username;
   private String password;
+  private String password2;
   private String schema;
   private String driver;
   private InitDatabase initDatabase;
@@ -81,6 +82,7 @@ public DataSourceConfig copy() {
     copy.readOnlyUrl = readOnlyUrl;
     copy.username = username;
     copy.password = password;
+    copy.password2 = password2;
     copy.schema = schema;
     copy.platform = platform;
     copy.ownerUsername = ownerUsername;
@@ -136,6 +138,9 @@ public DataSourceConfig setDefaults(DataSourceConfig other) {
     if (password == null) {
       password = other.password;
     }
+    if (password2 == null) {
+      password2 = other.password2;
+    }
     if (schema == null) {
       schema = other.schema;
     }
@@ -254,6 +259,21 @@ public DataSourceConfig setPassword(String password) {
     return this;
   }
 
+  /**
+   * Return the database alternate password2.
+   */
+  public String getPassword2() {
+    return password2;
+  }
+
+  /**
+   * Set the database alternate password2.
+   */
+  public DataSourceConfig setPassword2(String password2) {
+    this.password2 = password2;
+    return this;
+  }
+
   /**
    * Return the database username.
    */
@@ -834,6 +854,7 @@ public DataSourceConfig loadSettings(Properties properties, String poolName) {
   private void loadSettings(ConfigPropertiesHelper properties) {
     username = properties.get("username", username);
     password = properties.get("password", password);
+    password2 = properties.get("password2", password2);
     schema = properties.get("schema", schema);
     platform = properties.get("platform", platform);
     ownerUsername = properties.get("ownerUsername", ownerUsername);

ebean-datasource/pom.xml

@@ -22,35 +22,42 @@
     <dependency>
       <groupId>io.avaje</groupId>
       <artifactId>junit</artifactId>
-      <version>1.1</version>
+      <version>1.3</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-test-containers</artifactId>
-      <version>6.2</version>
+      <version>7.1</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>org.postgresql</groupId>
       <artifactId>postgresql</artifactId>
-      <version>42.5.1</version>
+      <version>42.6.0</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>ch.qos.logback</groupId>
       <artifactId>logback-classic</artifactId>
-      <version>1.2.11</version>
+      <version>1.4.7</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-jdk-platform-logging</artifactId>
+      <version>2.0.9</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>io.avaje</groupId>
       <artifactId>avaje-slf4j-jpl</artifactId>
-      <version>1.1</version>
+      <version>1.2</version>
       <scope>test</scope>
     </dependency>
 

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

@@ -33,6 +33,7 @@ final class ConnectionPool implements DataSourcePool {
   private final String name;
   private final AtomicInteger size = new AtomicInteger(0);
   private final DataSourceConfig config;
+  private final String password2;
   /**
    * Used to notify of changes to the DataSource status.
    */
@@ -75,6 +76,7 @@ final class ConnectionPool implements DataSourcePool {
   private final int waitTimeoutMillis;
   private final int pstmtCacheSize;
   private final PooledConnectionQueue queue;
+  private boolean fixedCredentials;
   private Timer heartBeatTimer;
   /**
    * Used to find and close() leaked connections. Leaked connections are
@@ -124,6 +126,8 @@ final class ConnectionPool implements DataSourcePool {
     if (pw == null) {
       throw new DataSourceConfigurationException("DataSource password is null? url is [" + url + "]");
     }
+    this.password2 = params.getPassword2();
+    this.fixedCredentials = password2 == null;
     this.connectionProps = new Properties();
     this.connectionProps.setProperty("user", user);
     this.connectionProps.setProperty("password", pw);
@@ -241,7 +245,7 @@ private void initialiseDatabase() throws SQLException {
     } catch (SQLException e) {
       Log.info("Obtaining connection using ownerUsername:{0} to initialise database", config.getOwnerUsername());
       // expected when user does not exist, obtain a connection using owner credentials
-      try (Connection ownerConnection = createConnection(config.getOwnerUsername(), config.getOwnerPassword())) {
+      try (Connection ownerConnection = ownerConnection(config.getOwnerUsername(), config.getOwnerPassword())) {
         // initialise the DB (typically create the user/role using the owner credentials etc)
         InitDatabase initDatabase = config.getInitDatabase();
         initDatabase.run(ownerConnection, config);
@@ -454,7 +458,7 @@ private void initConnection(Connection conn) throws SQLException {
   /**
    * Create an un-pooled connection with the given username and password.
    */
-  private Connection createConnection(String username, String password) throws SQLException {
+  private Connection ownerConnection(String username, String password) throws SQLException {
     Properties properties = new Properties(connectionProps);
     properties.setProperty("user", username);
     properties.setProperty("password", password);
@@ -467,7 +471,7 @@ private Connection createConnection() throws SQLException {
 
   private Connection createConnection(Properties properties, boolean notifyIsDown) throws SQLException {
     try {
-      Connection conn = DriverManager.getConnection(url, properties);
+      final var conn = newConnection(properties);
       initConnection(conn);
       return conn;
     } catch (SQLException ex) {
@@ -478,6 +482,34 @@ private Connection createConnection(Properties properties, boolean notifyIsDown)
     }
   }
 
+  private Connection newConnection(Properties properties) throws SQLException {
+    try {
+      return DriverManager.getConnection(url, properties);
+    } catch (SQLException e) {
+      notifyLock.lock();
+      try {
+        if (fixedCredentials) {
+          throw e;
+        }
+        Log.debug("DataSource [{0}] trying alternate credentials due to {1}", name, e.getMessage());
+        return switchCredentials(properties);
+      } finally {
+        notifyLock.unlock();
+      }
+    }
+  }
+
+  private Connection switchCredentials(Properties properties) throws SQLException {
+    var copy = new Properties(properties);
+    copy.setProperty("password", password2);
+    var connection = DriverManager.getConnection(url, copy);
+    // success, permanently switch to use password2 from now on
+    Log.info("DataSource [{0}] now using alternate credentials", name);
+    fixedCredentials = true;
+    properties.setProperty("password", password2);
+    return connection;
+  }
+
   @Override
   public void setMaxSize(int max) {
     queue.setMaxSize(max);

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

@@ -88,26 +88,8 @@ void test_with_applicationNameAndSchema() throws SQLException {
     DataSourcePool pool = DataSourceFactory.create("app", ds);
     try {
       try (Connection connection = pool.getConnection()) {
-        try (PreparedStatement statement = connection.prepareStatement("create schema if not exists fred;")) {
-          statement.execute();
-        }
-        connection.commit();
-        try (PreparedStatement statement = connection.prepareStatement("create table if not exists fred_table (acol integer);")) {
-          statement.execute();
-        }
-        try (PreparedStatement statement = connection.prepareStatement("insert into fred_table (acol) values (?);")) {
-          statement.setInt(1, 42);
-          int rows = statement.executeUpdate();
-          assertThat(rows).isEqualTo(1);
-        }
-        try (PreparedStatement statement = connection.prepareStatement("select acol from fred.fred_table")) {
-          try (ResultSet resultSet = statement.executeQuery()) {
-            while(resultSet.next()) {
-              int res = resultSet.getInt(1);
-              assertThat(res).isEqualTo(42);
-            }
-          }
-        }
+        setupTable(connection, "my_table");
+        testConnectionWithSelect(connection, "select acol from app.my_table");
         connection.commit();
 
         try (PreparedStatement statement = connection.prepareStatement("select application_name from pg_stat_activity where usename = ?")) {
@@ -124,4 +106,88 @@ void test_with_applicationNameAndSchema() throws SQLException {
       pool.shutdown();
     }
   }
+
+  @Test
+  void test_password2() throws SQLException {
+    DataSourceConfig ds = new DataSourceConfig();
+    ds.setUrl("jdbc:postgresql://127.0.0.1:9999/app");
+    ds.setSchema("fred");
+    ds.setUsername("db_owner");
+    ds.setPassword("test");
+    ds.setPassword2("newRolledPassword");
+
+    DataSourcePool pool = DataSourceFactory.create("app", ds);
+    try {
+      try (Connection connection0 = pool.getConnection()) {
+        setupTable(connection0, "my_table2");
+        testConnectionWithSelect(connection0, "select acol from app.my_table2");
+        connection0.commit();
+        try (Connection connection1 = pool.getConnection()) {
+          testConnectionWithSelect(connection1, "select acol from app.my_table2");
+          // change password
+          try (PreparedStatement statement = connection0.prepareStatement("alter role db_owner with password 'newRolledPassword'")) {
+            statement.execute();
+            connection0.commit();
+          }
+          // existing connections still work
+          testConnectionWithSelect(connection0, "select acol from app.my_table2");
+          testConnectionWithSelect(connection1, "select acol from app.my_table2");
+
+          // new connection triggers password switch
+          try (Connection newConnection0 = pool.getConnection()) {
+            testConnectionWithSelect(newConnection0, "select acol from app.my_table2");
+            try (Connection newConnection1 = pool.getConnection()) {
+              testConnectionWithSelect(newConnection1, "select acol from app.my_table2");
+            }
+          }
+        }
+
+        // a new pool switches immediately
+        DataSourcePool pool2 = DataSourceFactory.create("app2", ds);
+        try (var connP2_0 = pool2.getConnection()) {
+          testConnectionWithSelect(connP2_0, "select acol from app.my_table2");
+          try (var connP2_1 = pool2.getConnection()) {
+            testConnectionWithSelect(connP2_1, "select acol from app.my_table2");
+            try (var connP2_2 = pool2.getConnection()) {
+              testConnectionWithSelect(connP2_2, "select acol from app.my_table2");
+            }
+          }
+        }
+
+        // reset the password back for other tests
+        try (PreparedStatement statement = connection0.prepareStatement("alter role db_owner with password 'test'")) {
+          statement.execute();
+          connection0.commit();
+        }
+      }
+    } finally {
+      pool.shutdown();
+    }
+  }
+
+
+  private static void setupTable(Connection connection, String tableName) throws SQLException {
+    try (PreparedStatement statement = connection.prepareStatement("create schema if not exists app;")) {
+      statement.execute();
+    }
+    try (PreparedStatement statement = connection.prepareStatement("create table if not exists app." + tableName + " (acol integer);")) {
+      statement.execute();
+    }
+    try (PreparedStatement statement = connection.prepareStatement("insert into app." + tableName + " (acol) values (?);")) {
+      statement.setInt(1, 42);
+      int rows = statement.executeUpdate();
+      assertThat(rows).isEqualTo(1);
+    }
+  }
+
+  private static void testConnectionWithSelect(Connection connection, String sql) throws SQLException {
+    try (PreparedStatement statement = connection.prepareStatement(sql)) {
+      try (ResultSet resultSet = statement.executeQuery()) {
+        while (resultSet.next()) {
+          int res = resultSet.getInt(1);
+          assertThat(res).isEqualTo(42);
+        }
+      }
+    }
+  }
 }

ebean-datasource/src/test/resources/logback-test.xml

@@ -0,0 +1,21 @@
+<configuration scan="true" scanPeriod="10 seconds">
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>TRACE</level>
+    </filter>
+    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <root level="INF0">
+    <appender-ref ref="STDOUT"/>
+  </root>
+
+  <logger name="java.lang" level="WARN"/>
+  <logger name="io.ebean" level="INFO"/>
+  <logger name="io.avaje.config" level="TRACE"/>
+  <logger name="io.ebean.docker" level="DEBUG"/>
+  <logger name="io.ebean.test" level="TRACE"/>
+
+</configuration>