This is an automated email from the ASF dual-hosted git repository.

ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-dbcp.git


The following commit(s) were added to refs/heads/master by this push:
     new cbf77a0  Use abort rather than close to destroy abandoned connections. 
Fixes DBCP-567. (#68)
cbf77a0 is described below

commit cbf77a08b7c64c1df3e2b2d2ee5e1415c9a885a1
Author: Phil Steitz <[email protected]>
AuthorDate: Mon Dec 28 10:17:43 2020 -0700

    Use abort rather than close to destroy abandoned connections. Fixes 
DBCP-567. (#68)
---
 .../org/apache/commons/dbcp2/BasicDataSource.java  |  1 +
 .../apache/commons/dbcp2/DelegatingConnection.java |  1 -
 .../apache/commons/dbcp2/PoolableConnection.java   | 11 ++++++
 .../commons/dbcp2/PoolableConnectionFactory.java   | 42 +++++++++++++++++++++-
 .../apache/commons/dbcp2/PoolingDataSource.java    |  3 ++
 .../dbcp2/TestAbandonedBasicDataSource.java        |  3 ++
 .../org/apache/commons/dbcp2/TesterConnection.java | 10 +++++-
 7 files changed, 68 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/apache/commons/dbcp2/BasicDataSource.java 
b/src/main/java/org/apache/commons/dbcp2/BasicDataSource.java
index 5fdbb2c..68235e7 100644
--- a/src/main/java/org/apache/commons/dbcp2/BasicDataSource.java
+++ b/src/main/java/org/apache/commons/dbcp2/BasicDataSource.java
@@ -428,6 +428,7 @@ public class BasicDataSource implements DataSource, 
BasicDataSourceMXBean, MBean
      */
     private void closeConnectionPool() {
         final GenericObjectPool<?> oldPool = connectionPool;
+        ((PoolableConnectionFactory) connectionPool.getFactory()).close();
         connectionPool = null;
         try {
             if (oldPool != null) {
diff --git a/src/main/java/org/apache/commons/dbcp2/DelegatingConnection.java 
b/src/main/java/org/apache/commons/dbcp2/DelegatingConnection.java
index 3f6d46b..11438f3 100644
--- a/src/main/java/org/apache/commons/dbcp2/DelegatingConnection.java
+++ b/src/main/java/org/apache/commons/dbcp2/DelegatingConnection.java
@@ -964,7 +964,6 @@ public class DelegatingConnection<C extends Connection> 
extends AbandonedTrace i
 
     @Override
     public void abort(final Executor executor) throws SQLException {
-        checkOpen();
         try {
             Jdbc41Bridge.abort(connection, executor);
         } catch (final SQLException e) {
diff --git a/src/main/java/org/apache/commons/dbcp2/PoolableConnection.java 
b/src/main/java/org/apache/commons/dbcp2/PoolableConnection.java
index 0cd0ee0..3f109cc 100644
--- a/src/main/java/org/apache/commons/dbcp2/PoolableConnection.java
+++ b/src/main/java/org/apache/commons/dbcp2/PoolableConnection.java
@@ -22,6 +22,7 @@ import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Collection;
+import java.util.concurrent.Executor;
 
 import javax.management.InstanceAlreadyExistsException;
 import javax.management.MBeanRegistrationException;
@@ -234,6 +235,16 @@ public class PoolableConnection extends 
DelegatingConnection<Connection> impleme
     }
 
     /**
+     * Abort my underlying {@link Connection}.
+     */
+    public void abort(Executor executor) throws SQLException {
+        if (jmxObjectName != null) {
+            jmxObjectName.unregisterMBean();
+        }
+        super.abort(executor);
+    }
+
+    /**
      * Expose the {@link #toString()} method via a bean getter so it can be 
read as a property via JMX.
      */
     @Override
diff --git 
a/src/main/java/org/apache/commons/dbcp2/PoolableConnectionFactory.java 
b/src/main/java/org/apache/commons/dbcp2/PoolableConnectionFactory.java
index 8d47df1..e1c3d06 100644
--- a/src/main/java/org/apache/commons/dbcp2/PoolableConnectionFactory.java
+++ b/src/main/java/org/apache/commons/dbcp2/PoolableConnectionFactory.java
@@ -17,17 +17,23 @@
 
 package org.apache.commons.dbcp2;
 
+import java.security.AccessController;
+import java.security.PrivilegedAction;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.Collection;
 import java.util.Objects;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicLong;
 
 import javax.management.ObjectName;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.apache.commons.pool2.DestroyMode;
 import org.apache.commons.pool2.KeyedObjectPool;
 import org.apache.commons.pool2.ObjectPool;
 import org.apache.commons.pool2.PooledObject;
@@ -41,7 +47,7 @@ import 
org.apache.commons.pool2.impl.GenericKeyedObjectPoolConfig;
  *
  * @since 2.0
  */
-public class PoolableConnectionFactory implements 
PooledObjectFactory<PoolableConnection> {
+public class PoolableConnectionFactory implements 
PooledObjectFactory<PoolableConnection>, AutoCloseable {
 
     private static final Log log = 
LogFactory.getLog(PoolableConnectionFactory.class);
 
@@ -94,6 +100,8 @@ public class PoolableConnectionFactory implements 
PooledObjectFactory<PoolableCo
 
     private Integer defaultQueryTimeoutSeconds;
 
+    private final ExecutorService executor = Executors.newFixedThreadPool(3, 
new AbortThreadFactory());
+
     /**
      * Creates a new {@code PoolableConnectionFactory}.
      *
@@ -139,6 +147,15 @@ public class PoolableConnectionFactory implements 
PooledObjectFactory<PoolableCo
         p.getObject().reallyClose();
     }
 
+    @Override
+    public void destroyObject(final PooledObject<PoolableConnection> p, final 
DestroyMode mode) throws Exception {
+        if (mode != null && mode.equals(DestroyMode.ABANDONED)) {
+            p.getObject().getInnermostDelegate().abort(executor);
+        } else {
+            p.getObject().reallyClose();
+        }
+    }
+
     /**
      * @return The cache state.
      * @since Made public in 2.6.0.
@@ -668,4 +685,27 @@ public class PoolableConnectionFactory implements 
PooledObjectFactory<PoolableCo
             return false;
         }
     }
+
+    @Override
+    public void close() {
+        executor.shutdown();
+    }
+
+    /**
+     * Thread factory that creates daemon threads, with the context class 
loader from this class.
+     */
+    private static class AbortThreadFactory implements ThreadFactory {
+
+        @Override
+        public Thread newThread(final Runnable runnable) {
+            final Thread thread = new Thread(null, runnable, 
"commons-dbcp-abort-thread");
+            thread.setDaemon(true); // POOL-363 - Required for applications 
using Runtime.addShutdownHook().
+            AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
+                
thread.setContextClassLoader(AbortThreadFactory.class.getClassLoader());
+                return null;
+            });
+
+            return thread;
+        }
+    }
 }
diff --git a/src/main/java/org/apache/commons/dbcp2/PoolingDataSource.java 
b/src/main/java/org/apache/commons/dbcp2/PoolingDataSource.java
index 0169d9b..8fd75b3 100644
--- a/src/main/java/org/apache/commons/dbcp2/PoolingDataSource.java
+++ b/src/main/java/org/apache/commons/dbcp2/PoolingDataSource.java
@@ -77,6 +77,9 @@ public class PoolingDataSource<C extends Connection> 
implements DataSource, Auto
     @Override
     public void close() throws RuntimeException, SQLException {
         try {
+            if (pool instanceof GenericObjectPool) {
+                ((PoolableConnectionFactory) ((GenericObjectPool<?>) 
pool).getFactory()).close();
+            }
             pool.close();
         } catch (final RuntimeException rte) {
             throw new RuntimeException(Utils.getMessage("pool.close.fail"), 
rte);
diff --git 
a/src/test/java/org/apache/commons/dbcp2/TestAbandonedBasicDataSource.java 
b/src/test/java/org/apache/commons/dbcp2/TestAbandonedBasicDataSource.java
index da83df6..5b4cc77 100644
--- a/src/test/java/org/apache/commons/dbcp2/TestAbandonedBasicDataSource.java
+++ b/src/test/java/org/apache/commons/dbcp2/TestAbandonedBasicDataSource.java
@@ -87,6 +87,9 @@ public class TestAbandonedBasicDataSource extends 
TestBasicDataSource {
         assertEquals(1, ds.getNumActive());
         // Verify that conn1 is closed
         assertTrue(((DelegatingConnection<?>) 
conn1).getInnermostDelegate().isClosed());
+        // Verify that conn1 is aborted
+        final TesterConnection tCon = (TesterConnection) 
((DelegatingConnection<?>) conn1).getInnermostDelegate();
+        assertTrue(tCon.isAborted());
 
         conn2.close();
         assertEquals(0, ds.getNumActive());
diff --git a/src/test/java/org/apache/commons/dbcp2/TesterConnection.java 
b/src/test/java/org/apache/commons/dbcp2/TesterConnection.java
index f136377..8dc0120 100644
--- a/src/test/java/org/apache/commons/dbcp2/TesterConnection.java
+++ b/src/test/java/org/apache/commons/dbcp2/TesterConnection.java
@@ -41,6 +41,7 @@ import java.util.concurrent.Executor;
 public class TesterConnection extends AbandonedTrace implements Connection {
 
     protected boolean _open = true;
+    protected boolean _aborted = false;
     protected boolean _autoCommit = true;
     protected int _transactionIsolation = 1;
     protected DatabaseMetaData _metaData = new TesterDatabaseMetaData();
@@ -60,7 +61,9 @@ public class TesterConnection extends AbandonedTrace 
implements Connection {
 
     @Override
     public void abort(final Executor executor) throws SQLException {
-        throw new SQLException("Not implemented.");
+        checkFailure();
+        _aborted = true;
+        _open = false;
     }
 
     protected void checkFailure() throws SQLException {
@@ -221,6 +224,11 @@ public class TesterConnection extends AbandonedTrace 
implements Connection {
         return !_open;
     }
 
+    public boolean isAborted() throws SQLException {
+        checkFailure();
+        return _aborted;
+    }
+
     @Override
     public boolean isReadOnly() throws SQLException {
         checkOpen();

Reply via email to