Rollback/Commit in close if there may be an open transaction

Author: rPraml

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

@@ -749,6 +749,28 @@ default DataSourceBuilder initDatabaseForPlatform(String platform) {
    */
   DataSourceBuilder loadSettings(Properties properties, String poolName);
 
+
+  /**
+   * Sets the behaviour what to do, when a connection is closed (=returned to pool), while there is uncommitted work.
+   * <p>
+   * Possible values
+   * <ul>
+   *   <li><code>nothing</code> nothing happens</li>
+   *   <li><code>rollback</code> a rollback is performed (default)</li>
+   *   <li><code>commit</code> a commit is performed (dangerous!)</li>
+   *   <li><code>remove</code> the connection is removed from the pool (not recommended for production, connection might leak)</li>
+   *   <li><code>fail</code> an exception is thrown by close itself (for debugging, not recommended for production)</li>
+   * </ul>
+   */
+  DataSourceBuilder closeWithinTxn(String closeWithinTxn);
+
+  /**
+   * Returns the behaviour, what to do, when a connection is (=returned to pool), while there is uncommitted work.
+   * <p>
+   * See {@link #closeWithinTxn(String)}.
+   */
+  String closeWithinTxn();
+
   /**
    * The settings of the DataSourceBuilder. Provides getters/accessors
    * to read the configured properties of this DataSourceBuilder.

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

@@ -83,6 +83,7 @@ public class DataSourceConfig implements DataSourceBuilder.Settings {
   private String applicationName;
   private boolean shutdownOnJvmExit;
   private boolean validateOnHeartbeat = !System.getenv().containsKey("LAMBDA_TASK_ROOT");
+  private String closeWithinTxn = "rollback";
 
   @Override
   public Settings settings() {
@@ -144,6 +145,7 @@ public DataSourceConfig copy() {
     copy.initSql = initSql;
     copy.alert = alert;
     copy.listener = listener;
+    copy.closeWithinTxn = closeWithinTxn;
     return copy;
   }
 
@@ -798,6 +800,8 @@ private void loadSettings(ConfigPropertiesHelper properties) {
     offline = properties.getBoolean("offline", offline);
     shutdownOnJvmExit = properties.getBoolean("shutdownOnJvmExit", shutdownOnJvmExit);
     validateOnHeartbeat = properties.getBoolean("validateOnHeartbeat", validateOnHeartbeat);
+    closeWithinTxn = properties.get("closeWithinTxn", closeWithinTxn);
+
 
     String isoLevel = properties.get("isolationLevel", _isolationLevel(isolationLevel));
     this.isolationLevel = _isolationLevel(isoLevel);
@@ -846,6 +850,17 @@ Map<String, String> parseCustom(String customProperties) {
     return propertyMap;
   }
 
+  @Override
+  public DataSourceBuilder closeWithinTxn(String closeWithinTxn) {
+    this.closeWithinTxn = closeWithinTxn;
+    return this;
+  }
+
+  @Override
+  public String closeWithinTxn() {
+    return closeWithinTxn;
+  }
+
   /**
    * Return the isolation level description from the associated Connection int value.
    */

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

@@ -17,11 +17,12 @@ public interface DataSourcePoolListener {
   /**
    * Called after a connection has been retrieved from the connection pool
    */
-  void onAfterBorrowConnection(Connection connection);
+  default void onAfterBorrowConnection(Connection connection) {}
 
   /**
    * Called before a connection will be put back to the connection pool
    */
-  void onBeforeReturnConnection(Connection connection);
+  default void onBeforeReturnConnection(Connection connection) {}
+
 
 }

ebean-datasource/pom.xml

@@ -76,6 +76,13 @@
       <scope>test</scope>
     </dependency>
 
+    <dependency>
+      <groupId>com.ibm.db2</groupId>
+      <artifactId>jcc</artifactId>
+      <version>11.5.9.0</version>
+      <scope>test</scope>
+    </dependency>
+
   </dependencies>
 
 </project>

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

@@ -25,6 +25,10 @@
  */
 final class ConnectionPool implements DataSourcePool {
 
+  enum CloseWithinTxn {
+    NOTHING, ROLLBACK, COMMIT, FAIL, REMOVE;
+  }
+
   private static final String APPLICATION_NAME = "ApplicationName";
   private final ReentrantLock heartbeatLock = new ReentrantLock(false);
   private final ReentrantLock notifyLock = new ReentrantLock(false);
@@ -55,6 +59,7 @@ final class ConnectionPool implements DataSourcePool {
   private final boolean failOnStart;
   private final int maxInactiveMillis;
   private final long validateStaleMillis;
+  private final CloseWithinTxn closeWithinTxn;
   /**
    * Max age a connection is allowed in millis.
    * A value of 0 means no limit (no trimming based on max age).
@@ -94,6 +99,7 @@ final class ConnectionPool implements DataSourcePool {
   private final boolean shutdownOnJvmExit;
   private Thread shutdownHook;
 
+
   ConnectionPool(String name, DataSourceConfig params) {
     this.config = params;
     this.name = name;
@@ -128,10 +134,12 @@ final class ConnectionPool implements DataSourcePool {
     this.user = params.getUsername();
     this.shutdownOnJvmExit = params.isShutdownOnJvmExit();
     this.source = DriverDataSource.of(name, params);
+    this.closeWithinTxn = Enum.valueOf(CloseWithinTxn.class, params.closeWithinTxn().toUpperCase(Locale.ROOT));
     if (!params.isOffline()) {
       init();
     }
     this.nextTrimTime = System.currentTimeMillis() + trimPoolFreqMillis;
+
   }
 
   private void init() {
@@ -516,6 +524,37 @@ boolean invalidConnection(PooledConnection conn) {
     }
   }
 
+  /**
+   * Fail hard in close() when there is uncommitted work. This is for debugging to find wrong code.
+   */
+  boolean failIfWithinTransaction() {
+    return closeWithinTxn == CloseWithinTxn.FAIL;
+  }
+
+  /**
+   * will be called, before the connection is returned to the pool. This happens, when there may
+   * be uncommitted changes and before all settings like autocommit/schema/catalog are reset to default.
+   * <p>
+   * If this method fails, the connection is silently removed from pool
+   */
+  void closeWithinTxn(PooledConnection pooledConnection) throws SQLException {
+    switch (closeWithinTxn) {
+      case NOTHING:
+        Log.trace("Closing active connection.");
+        break;
+      case ROLLBACK:
+        pooledConnection.rollback();
+        Log.trace("Closing active connection. Rollback performed.");
+        break;
+      case COMMIT:
+        pooledConnection.commit();
+        Log.trace("Closing active connection. Commit performed.");
+        break;
+      case REMOVE:
+        throw new SQLException("Closing active connection. Removing from pool.");
+    }
+  }
+
   /**
    * Called by the PooledConnection themselves, returning themselves to the
    * pool when they have been finished with.

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

@@ -448,6 +448,11 @@ public void close() throws SQLException {
     if (status == STATUS_IDLE) {
       throw new SQLException(IDLE_CONNECTION_ACCESSED_ERROR + "close()");
     }
+    boolean mayHaveUncommittedChanges = !autoCommit && !readOnly && status == STATUS_ACTIVE;
+    if (mayHaveUncommittedChanges && pool.failIfWithinTransaction()) {
+      pool.returnConnectionForceClose(this);
+      throw new SQLException("Tried to close active connection within transaction");
+    }
     if (hadErrors) {
       if (failoverToReadOnly) {
         pool.returnConnectionReset(this);
@@ -458,12 +463,14 @@ public void close() throws SQLException {
         return;
       }
     }
-
     try {
       if (connection.isClosed()) {
         pool.removeClosedConnection(this);
         return;
       }
+      if (mayHaveUncommittedChanges) {
+        pool.closeWithinTxn(this);
+      }
       // reset the autoCommit back if client code changed it
       if (autoCommit != pool.isAutoCommit()) {
         connection.setAutoCommit(pool.isAutoCommit());