HHH-7910 Transaction timeout can cause non-threadsafe session access by reaper thread

hibernate-core/src/main/java/org/hibernate/cfg/AvailableSettings.java

@@ -623,4 +623,13 @@ public interface AvailableSettings {
 	public static final String USE_DIRECT_REFERENCE_CACHE_ENTRIES = "hibernate.cache.use_reference_entries";
 
 	public static final String USE_NATIONALIZED_CHARACTER_DATA = "hibernate.use_nationalized_character_data";
+
+	/**
+	 * A transaction can be rolled back by another thread -- not the original
+	 * application. Examples of this include a JTA transaction timeout handled
+	 * by a background reaper thread.  The ability to handle this situation
+	 * requires checking the Thread ID every time Session is called.  This can
+	 * certainly have performance considerations.  Default is enabled;
+	 */
+	public static final String ENABLE_JTA_THREAD_HANDLING = "hibernate.enable_jta_thread_handling";
 }

hibernate-core/src/main/java/org/hibernate/cfg/Settings.java

@@ -96,6 +96,8 @@ public final class Settings {
 	private MultiTableBulkIdStrategy multiTableBulkIdStrategy;
 	private BatchFetchStyle batchFetchStyle;
 	private boolean directReferenceCacheEntriesEnabled;
+
+	private boolean jtaThreadHandling;
 
 
 	/**
@@ -508,4 +510,12 @@ public void setDirectReferenceCacheEntriesEnabled(boolean directReferenceCacheEn
 	void setDefaultNullPrecedence(NullPrecedence defaultNullPrecedence) {
 		this.defaultNullPrecedence = defaultNullPrecedence;
 	}
+
+	public boolean isJtaThreadHandling() {
+		return jtaThreadHandling;
+	}
+
+	public void setJtaThreadHandling(boolean jtaThreadHandling) {
+		this.jtaThreadHandling = jtaThreadHandling;
+	}
 }

hibernate-core/src/main/java/org/hibernate/cfg/SettingsFactory.java

@@ -395,6 +395,16 @@ public Settings buildSettings(Properties props, ServiceRegistry serviceRegistry)
 		}
 		settings.setInitializeLazyStateOutsideTransactions( initializeLazyStateOutsideTransactionsEnabled );
 
+		boolean enableJtaThreadHandling = ConfigurationHelper.getBoolean(
+				AvailableSettings.ENABLE_JTA_THREAD_HANDLING,
+				properties,
+				true
+		);
+		if ( debugEnabled ) {
+			LOG.debugf( "JTA Thread Handling: %s", enabledDisabled(enableJtaThreadHandling) );
+		}
+		settings.setJtaThreadHandling( enableJtaThreadHandling );
+
 		return settings;
 
 	}

hibernate-core/src/main/java/org/hibernate/engine/transaction/internal/TransactionCoordinatorImpl.java

@@ -267,6 +267,7 @@ public SynchronizationCallbackCoordinator getSynchronizationCallbackCoordinator(
 	}
 
 	public void pulse() {
+		getSynchronizationCallbackCoordinator().pulse();
 		if ( transactionFactory().compatibleWithJtaSynchronization() ) {
 			// the configured transaction strategy says it supports callbacks via JTA synchronization, so attempt to
 			// register JTA synchronization if possible

hibernate-core/src/main/java/org/hibernate/engine/transaction/synchronization/internal/SynchronizationCallbackCoordinatorImpl.java

@@ -25,9 +25,8 @@
 
 import javax.transaction.SystemException;
 
-import org.jboss.logging.Logger;
-
 import org.hibernate.TransactionException;
+import org.hibernate.cfg.Settings;
 import org.hibernate.engine.transaction.internal.jta.JtaStatusHelper;
 import org.hibernate.engine.transaction.spi.TransactionContext;
 import org.hibernate.engine.transaction.spi.TransactionCoordinator;
@@ -36,31 +35,43 @@
 import org.hibernate.engine.transaction.synchronization.spi.ManagedFlushChecker;
 import org.hibernate.engine.transaction.synchronization.spi.SynchronizationCallbackCoordinator;
 import org.hibernate.internal.CoreMessageLogger;
+import org.jboss.logging.Logger;
 
 /**
  * Manages callbacks from the {@link javax.transaction.Synchronization} registered by Hibernate.
- *
+ * 
  * @author Steve Ebersole
+ * @author Brett Meyer
  */
 public class SynchronizationCallbackCoordinatorImpl implements SynchronizationCallbackCoordinator {
 
-	private static final CoreMessageLogger LOG = Logger.getMessageLogger( CoreMessageLogger.class, SynchronizationCallbackCoordinatorImpl.class.getName() );
+	private static final CoreMessageLogger LOG = Logger.getMessageLogger( CoreMessageLogger.class,
+			SynchronizationCallbackCoordinatorImpl.class.getName() );
 
 	private final TransactionCoordinator transactionCoordinator;
+	private final Settings settings;
 
 	private ManagedFlushChecker managedFlushChecker;
 	private AfterCompletionAction afterCompletionAction;
 	private ExceptionMapper exceptionMapper;
 
+	private long registrationThreadId;
+	private final int NO_STATUS = -1;
+	private int delayedCompletionHandlingStatus;
+
 	public SynchronizationCallbackCoordinatorImpl(TransactionCoordinator transactionCoordinator) {
 		this.transactionCoordinator = transactionCoordinator;
+		this.settings = transactionCoordinator.getTransactionContext()
+				.getTransactionEnvironment().getSessionFactory().getSettings();
 		reset();
+		pulse();
 	}
 
 	public void reset() {
 		managedFlushChecker = STANDARD_MANAGED_FLUSH_CHECKER;
 		exceptionMapper = STANDARD_EXCEPTION_MAPPER;
 		afterCompletionAction = STANDARD_AFTER_COMPLETION_ACTION;
+		delayedCompletionHandlingStatus = NO_STATUS;
 	}
 
 	@Override
@@ -78,24 +89,21 @@ public void setAfterCompletionAction(AfterCompletionAction afterCompletionAction
 		this.afterCompletionAction = afterCompletionAction;
 	}
 
-
 	// sync callbacks ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 	public void beforeCompletion() {
 		LOG.trace( "Transaction before completion callback" );
 
 		boolean flush;
 		try {
-			final int status = transactionCoordinator
-					.getTransactionContext()
-					.getTransactionEnvironment()
-					.getJtaPlatform()
-					.getCurrentStatus();
+			final int status = transactionCoordinator.getTransactionContext().getTransactionEnvironment()
+					.getJtaPlatform().getCurrentStatus();
 			flush = managedFlushChecker.shouldDoManagedFlush( transactionCoordinator, status );
 		}
 		catch ( SystemException se ) {
 			setRollbackOnly();
-			throw exceptionMapper.mapStatusCheckFailure( "could not determine transaction status in beforeCompletion()", se );
+			throw exceptionMapper.mapStatusCheckFailure(
+					"could not determine transaction status in beforeCompletion()", se );
 		}
 
 		try {
@@ -119,6 +127,35 @@ private void setRollbackOnly() {
 	}
 
 	public void afterCompletion(int status) {
+		if ( !settings.isJtaThreadHandling() || isRegistrationThread() ) {
+			doAfterCompletion( status );
+		}
+		else if ( JtaStatusHelper.isRollback( status ) ) {
+			// The transaction was rolled back by another thread -- not the
+			// original application. Examples of this include a JTA transaction
+			// timeout getting cleaned up by a reaper thread. If this happens,
+			// afterCompletion must be handled by the original thread in order
+			// to prevent non-threadsafe session use. Set the flag here and
+			// check for it in SessionImpl. See HHH-7910.
+			LOG.warnv( "Transaction afterCompletion called by a background thread! Delaying action until the original thread can handle it. [status={0}]", status );
+			delayedCompletionHandlingStatus = status;
+		}
+	}
+
+	public void pulse() {
+		if ( settings.isJtaThreadHandling() ) {
+			registrationThreadId = Thread.currentThread().getId();
+		}
+	}
+
+	public void delayedAfterCompletion() {
+		if ( delayedCompletionHandlingStatus != NO_STATUS ) {
+			doAfterCompletion( delayedCompletionHandlingStatus );
+			delayedCompletionHandlingStatus = NO_STATUS;
+		}
+	}
+
+	private void doAfterCompletion(int status) {
 		LOG.tracev( "Transaction after completion callback [status={0}]", status );
 
 		try {
@@ -134,24 +171,29 @@ public void afterCompletion(int status) {
 		}
 	}
 
+	private boolean isRegistrationThread() {
+		return Thread.currentThread().getId() == registrationThreadId;
+	}
+
 	private TransactionContext transactionContext() {
 		return transactionCoordinator.getTransactionContext();
 	}
 
 	private static final ManagedFlushChecker STANDARD_MANAGED_FLUSH_CHECKER = new ManagedFlushChecker() {
 		@Override
 		public boolean shouldDoManagedFlush(TransactionCoordinator coordinator, int jtaStatus) {
-			return ! coordinator.getTransactionContext().isClosed() &&
-					! coordinator.getTransactionContext().isFlushModeNever() &&
-					coordinator.getTransactionContext().isFlushBeforeCompletionEnabled() &&
-					! JtaStatusHelper.isRollback( jtaStatus );
+			return !coordinator.getTransactionContext().isClosed()
+					&& !coordinator.getTransactionContext().isFlushModeNever()
+					&& coordinator.getTransactionContext().isFlushBeforeCompletionEnabled()
+					&& !JtaStatusHelper.isRollback( jtaStatus );
 		}
 	};
 
 	private static final ExceptionMapper STANDARD_EXCEPTION_MAPPER = new ExceptionMapper() {
 		public RuntimeException mapStatusCheckFailure(String message, SystemException systemException) {
 			LOG.error( LOG.unableToDetermineTransactionStatus(), systemException );
-			return new TransactionException( "could not determine transaction status in beforeCompletion()", systemException );
+			return new TransactionException( "could not determine transaction status in beforeCompletion()",
+					systemException );
 		}
 
 		public RuntimeException mapManagedFlushFailure(String message, RuntimeException failure) {

hibernate-core/src/main/java/org/hibernate/engine/transaction/synchronization/spi/SynchronizationCallbackCoordinator.java

@@ -31,5 +31,7 @@
 public interface SynchronizationCallbackCoordinator extends Synchronization{
 	public void setManagedFlushChecker(ManagedFlushChecker managedFlushChecker);
 	public void setAfterCompletionAction(AfterCompletionAction afterCompletionAction);
+	public void pulse();
+	public void delayedAfterCompletion();
 	public void setExceptionMapper(ExceptionMapper exceptionMapper);
 }