Use a shared connection provider for most tests to reduce test time significantly

Author: beikov

hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/ConnectionValidator.java

@@ -0,0 +1,28 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.engine.jdbc.connections.internal;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+/**
+ * Contract for validating JDBC Connections
+ *
+ * @author Christian Beikov
+ */
+public interface ConnectionValidator {
+
+	ConnectionValidator ALWAYS_VALID = connection -> true;
+
+	/**
+	 * Checks if the connection is still valid
+	 *
+	 * @return <code>true</code> if the connection is valid, <code>false</code> otherwise
+	 * @throws SQLException when an error happens due to the connection usage leading to a connection close
+	 */
+	boolean isValid(Connection connection) throws SQLException;
+}

hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/DriverManagerConnectionProviderImpl.java

@@ -47,7 +47,7 @@
  * @author Steve Ebersole
  */
 public class DriverManagerConnectionProviderImpl
-		implements ConnectionProvider, Configurable, Stoppable, ServiceRegistryAwareService {
+		implements ConnectionProvider, Configurable, Stoppable, ServiceRegistryAwareService, ConnectionValidator {
 
 	private static final ConnectionPoolingLogger log = ConnectionPoolingLogger.CONNECTIONS_LOGGER;
 
@@ -94,7 +94,7 @@ private PooledConnections buildPool(Map configurationValues, ServiceRegistryImpl
 		pooledConnectionBuilder.initialSize( initialSize );
 		pooledConnectionBuilder.minSize( minSize );
 		pooledConnectionBuilder.maxSize( maxSize );
-
+		pooledConnectionBuilder.validator( this );
 		return pooledConnectionBuilder.build();
 	}
 
@@ -205,13 +205,20 @@ public <T> T unwrap(Class<T> unwrapType) {
 		}
 	}
 
+	protected void validateConnectionsReturned() {
+		int allocationCount = state.pool.allConnections.size() - state.pool.availableConnections.size();
+		if ( allocationCount != 0 ) {
+			log.error( "Connection leak detected: there are " + allocationCount + " unclosed connections!");
+		}
+	}
 
 	// destroy the pool ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 	@Override
 	public void stop() {
 		if ( state != null ) {
 			state.stop();
+			validateConnectionsReturned();
 		}
 	}
 
@@ -234,6 +241,10 @@ public Properties getConnectionProperties() {
 		return connectionCreator.getConnectionProperties();
 	}
 
+	@Override
+	public boolean isValid(Connection connection) throws SQLException {
+		return true;
+	}
 
 	public static class PooledConnections {
 
@@ -243,6 +254,7 @@ public static class PooledConnections {
 		private static final CoreMessageLogger log = CoreLogging.messageLogger( DriverManagerConnectionProviderImpl.class );
 
 		private final ConnectionCreator connectionCreator;
+		private final ConnectionValidator connectionValidator;
 		private final boolean autoCommit;
 		private final int minSize;
 		private final int maxSize;
@@ -253,6 +265,9 @@ private PooledConnections(
 				Builder builder) {
 			log.debugf( "Initializing Connection pool with %s Connections", builder.initialSize );
 			connectionCreator = builder.connectionCreator;
+			connectionValidator = builder.connectionValidator == null
+					? ConnectionValidator.ALWAYS_VALID
+					: builder.connectionValidator;
 			autoCommit = builder.autoCommit;
 			maxSize = builder.maxSize;
 			minSize = builder.minSize;
@@ -283,26 +298,79 @@ else if ( size > maxSize ) {
 		}
 
 		public void add(Connection conn) throws SQLException {
-			conn.setAutoCommit( true );
-			conn.clearWarnings();
-			availableConnections.offer( conn );
+			final Connection connection = releaseConnection( conn );
+			if ( connection != null ) {
+				availableConnections.offer( connection );
+			}
+		}
+
+		protected Connection releaseConnection(Connection conn) {
+			Exception t = null;
+			try {
+				conn.setAutoCommit( true );
+				conn.clearWarnings();
+				if ( connectionValidator.isValid( conn ) ) {
+					return conn;
+				}
+			}
+			catch (SQLException ex) {
+				t = ex;
+			}
+			closeConnection( conn, t );
+			log.debug( "Connection release failed. Closing pooled connection", t );
+			return null;
 		}
 
 		public Connection poll() throws SQLException {
-			Connection conn = availableConnections.poll();
-			if ( conn == null ) {
-				synchronized (allConnections) {
-					if(allConnections.size() < maxSize) {
-						addConnections( 1 );
-						return poll();
+			Connection conn;
+			do {
+				conn = availableConnections.poll();
+				if ( conn == null ) {
+					synchronized (allConnections) {
+						if ( allConnections.size() < maxSize ) {
+							addConnections( 1 );
+							return poll();
+						}
 					}
+					throw new HibernateException(
+							"The internal connection pool has reached its maximum size and no connection is currently available!" );
 				}
-				throw new HibernateException( "The internal connection pool has reached its maximum size and no connection is currently available!" );
-			}
-			conn.setAutoCommit( autoCommit );
+				conn = prepareConnection( conn );
+			} while ( conn == null );
 			return conn;
 		}
 
+		protected Connection prepareConnection(Connection conn) {
+			Exception t = null;
+			try {
+				conn.setAutoCommit( autoCommit );
+				if ( connectionValidator.isValid( conn ) ) {
+					return conn;
+				}
+			}
+			catch (SQLException ex) {
+				t = ex;
+			}
+			closeConnection( conn, t );
+			log.debug( "Connection preparation failed. Closing pooled connection", t );
+			return null;
+		}
+
+		protected void closeConnection(Connection conn, Throwable t) {
+			try {
+				conn.close();
+			}
+			catch (SQLException ex) {
+				log.unableToCloseConnection( ex );
+				if ( t != null ) {
+					t.addSuppressed( ex );
+				}
+			}
+			finally {
+				allConnections.remove( conn );
+			}
+		}
+
 		public void close() throws SQLException {
 			try {
 				int allocationCount = allConnections.size() - availableConnections.size();
@@ -350,6 +418,7 @@ public String getUrl() {
 
 		public static class Builder {
 			private final ConnectionCreator connectionCreator;
+			private ConnectionValidator connectionValidator;
 			private boolean autoCommit;
 			private int initialSize = 1;
 			private int minSize = 1;
@@ -375,6 +444,11 @@ public Builder maxSize(int maxSize) {
 				return this;
 			}
 
+			public Builder validator(ConnectionValidator connectionValidator) {
+				this.connectionValidator = connectionValidator;
+				return this;
+			}
+
 			public PooledConnections build() {
 				return new PooledConnections( this );
 			}

hibernate-core/src/test/java/org/hibernate/jpa/test/BaseEntityManagerFunctionalTestCase.java

@@ -25,10 +25,15 @@
 import org.hibernate.cfg.AvailableSettings;
 import org.hibernate.cfg.Environment;
 import org.hibernate.dialect.Dialect;
+import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
 import org.hibernate.engine.spi.SessionFactoryImplementor;
+import org.hibernate.hql.spi.id.global.GlobalTemporaryTableBulkIdStrategy;
+import org.hibernate.hql.spi.id.local.LocalTemporaryTableBulkIdStrategy;
 import org.hibernate.jpa.HibernatePersistenceProvider;
 import org.hibernate.jpa.boot.spi.Bootstrap;
 import org.hibernate.jpa.boot.spi.PersistenceUnitDescriptor;
+
+import org.hibernate.testing.jdbc.SharedDriverManagerConnectionProviderImpl;
 import org.hibernate.testing.junit4.BaseUnitTestCase;
 import org.junit.After;
 import org.junit.Before;
@@ -223,6 +228,14 @@ protected Map getConfig() {
 			config.put( AvailableSettings.XML_FILE_NAMES, dds );
 		}
 
+		if ( !config.containsKey( Environment.CONNECTION_PROVIDER ) ) {
+			config.put( GlobalTemporaryTableBulkIdStrategy.DROP_ID_TABLES, "true" );
+			config.put( LocalTemporaryTableBulkIdStrategy.DROP_ID_TABLES, "true" );
+			config.put(
+					AvailableSettings.CONNECTION_PROVIDER,
+					SharedDriverManagerConnectionProviderImpl.getInstance()
+			);
+		}
 		addConfigOptions( config );
 		return config;
 	}

hibernate-core/src/test/java/org/hibernate/jpa/test/ejb3configuration/DisableDiscardPersistenceContextOnCloseTest.java

@@ -10,6 +10,7 @@
 import java.util.Map;
 import javax.persistence.EntityManager;
 
+import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
 import org.hibernate.jpa.AvailableSettings;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 import org.hibernate.jpa.test.Wallet;
@@ -34,6 +35,7 @@ public class DisableDiscardPersistenceContextOnCloseTest extends BaseEntityManag
 	@Override
 	protected Map getConfig() {
 		Map config = super.getConfig();
+		connectionProvider.setConnectionProvider( (ConnectionProvider) config.get( org.hibernate.cfg.AvailableSettings.CONNECTION_PROVIDER ) );
 		config.put( AvailableSettings.DISCARD_PC_ON_CLOSE, "false");
 		config.put(
 				org.hibernate.cfg.AvailableSettings.CONNECTION_PROVIDER,

hibernate-core/src/test/java/org/hibernate/jpa/test/ejb3configuration/EnableDiscardPersistenceContextOnCloseTest.java

@@ -10,6 +10,7 @@
 import javax.persistence.EntityManager;
 
 import org.hibernate.dialect.DB2Dialect;
+import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
 import org.hibernate.jpa.AvailableSettings;
 import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
 import org.hibernate.jpa.test.Wallet;
@@ -35,6 +36,7 @@ public class EnableDiscardPersistenceContextOnCloseTest extends BaseEntityManage
 	@Override
 	protected Map getConfig() {
 		Map config = super.getConfig();
+		connectionProvider.setConnectionProvider( (ConnectionProvider) config.get( org.hibernate.cfg.AvailableSettings.CONNECTION_PROVIDER ) );
 		config.put( AvailableSettings.DISCARD_PC_ON_CLOSE, "true");
 		config.put(
 				org.hibernate.cfg.AvailableSettings.CONNECTION_PROVIDER,