Allow more control of synchronization failures

Author: fredericDelaporte

build-common/teamcity-hibernate.cfg.xml

@@ -26,5 +26,7 @@
 			<property name="odbc.explicit_datetime_scale"></property>
 			<property name="oracle.use_n_prefixed_types_for_unicode"></property>
 			<property name="query.default_cast_length"></property>
+			<property name="transaction.ignore_session_synchronization_failures"></property>
+			<property name="transaction.system_completion_lock_timeout"></property>
 		</session-factory>
 	</hibernate-configuration>

default.build

@@ -139,6 +139,26 @@
 				<namespace prefix="hbm" uri="urn:nhibernate-configuration-2.2" />
 			</namespaces>
 		</xmlpoke>
+		
+		<!-- Make sure the property exists - it's only set for some scenarios. -->
+		<property name="nhibernate.transaction.ignore_session_synchronization_failures" value="" unless="${property::exists('nhibernate.transaction.ignore_session_synchronization_failures')}"/>
+		<xmlpoke file="${app.config}"
+			xpath="//*/hbm:property[@name='transaction.ignore_session_synchronization_failures']"
+			value="${nhibernate.transaction.ignore_session_synchronization_failures}">
+			<namespaces>
+				<namespace prefix="hbm" uri="urn:nhibernate-configuration-2.2" />
+			</namespaces>
+		</xmlpoke>
+		
+		<!-- Make sure the property exists - it's only set for some scenarios. -->
+		<property name="nhibernate.transaction.system_completion_lock_timeout" value="" unless="${property::exists('nhibernate.transaction.system_completion_lock_timeout')}"/>
+		<xmlpoke file="${app.config}"
+			xpath="//*/hbm:property[@name='transaction.system_completion_lock_timeout']"
+			value="${nhibernate.transaction.system_completion_lock_timeout}">
+			<namespaces>
+				<namespace prefix="hbm" uri="urn:nhibernate-configuration-2.2" />
+			</namespaces>
+		</xmlpoke>
 	</target>
 
 	<target name="put-connection-settings-into-app-config">

doc/reference/modules/configuration.xml

@@ -1050,8 +1050,8 @@ var session = sessions.OpenSession(conn);
                                 after scope disposal. This occurs when the transaction is distributed.
                                 This notably concerns <literal>ISessionImplementor.AfterTransactionCompletion(bool, ITransaction)</literal>.
                                 NHibernate protects the session from being concurrently used by the code following the scope disposal
-                                with a lock. To prevent any application freeze, this lock has a default timeout of five seconds. If the
-                                application appears to require longer (!) running transaction completion events, this setting allows to
+                                with a lock. To prevent any application freeze, this lock has a default timeout of one second. If the
+                                application appears to require longer running transaction completion events, this setting allows to
                                 raise this timeout. <literal>-1</literal> disables the timeout.
                             </para>
                             <para>
@@ -1060,6 +1060,33 @@ var session = sessions.OpenSession(conn);
                             </para>
                         </entry>
                     </row>
+                    <row>
+                        <entry>
+                            <literal>transaction.ignore_session_synchronization_failures</literal>
+                        </entry>
+                        <entry>
+                            Whether session synchronisation failures occuring during finalizations of system transaction should be
+                            ignored or not. <literal>false</literal> by default.
+                            <para>
+                                When a system transaction terminates abnormaly, especially through timeouts, it may have its
+                                completion events running on concurrent threads while the session is still performing some processing.
+                                To prevent threading concurrency failures, NHibernate then wait for the session to end its processing,
+                                up to <literal>transaction.system_completion_lock_timeout</literal>. If the session processing is still ongoing
+                                afterwards, it will by default log an error, perform transaction finalization processing concurrently,
+                                then throw a synchronization error. This setting allows to disable that later throw.
+                            </para>
+                            <para>
+                                Disabling the throw can be useful if the used data provider has its own locking mechanism applied
+                                during transaction completion, preventing the session to end its processing. It may then be safe to
+                                ignore this synchronization failure. In case of threading concurrency failure, you may then need to
+                                raise <literal>transaction.system_completion_lock_timeout</literal>.
+                            </para>
+                            <para>
+                                <emphasis role="strong">eg.</emphasis>
+                                <literal>true</literal> | <literal>false</literal>
+                            </para>
+                        </entry>
+                    </row>
                     <row>
                         <entry>
                             <literal>transaction.auto_join</literal>

psake.ps1

@@ -29,6 +29,8 @@ Task Set-Configuration {
             'connection.connection_string' = 'Server=(local)\SQL2017;Uid=sa;Pwd=Password12!;Database=nhibernateOdbc;Driver={SQL Server Native Client 11.0};Mars_Connection=yes;';
             'connection.driver_class' = 'NHibernate.Driver.OdbcDriver';
             'odbc.explicit_datetime_scale' = '3';
+            'transaction.ignore_session_synchronization_failures' = 'true';
+            'transaction.system_completion_lock_timeout' = '200';
             <# We need to use a dialect that avoids mapping DbType.Time to TIME on MSSQL. On modern SQL Server
                 this becomes TIME(7). Later, such values cannot be read back over ODBC. The
                 error we get is "System.ArgumentException : Unknown SQL type - SS_TIME_EX.". I don't know for certain

src/NHibernate.Config.Templates/SapSQLAnywhere.cfg.xml

@@ -17,5 +17,7 @@ for your own use before compiling tests in Visual Studio.
 		</property>
 		<property name="dialect">NHibernate.Dialect.SybaseSQLAnywhere12Dialect</property>
 		<property name="query.substitutions">true=1;false=0</property>
+		<property name="transaction.ignore_session_synchronization_failures">true</property>
+		<property name="transaction.system_completion_lock_timeout">200</property>
 	</session-factory>
 </hibernate-configuration>

src/NHibernate.Test/SystemTransactions/SystemTransactionFixture.cs

@@ -650,8 +650,9 @@ public void CanUseSessionWithManyDependentTransaction(bool explicitFlush)
 		public void SupportsTransactionTimeout()
 		{
 			Assume.That(TestDialect.SupportsTransactionScopeTimeouts, Is.True, "The tested dialect is not supported for transaction scope timeouts.");
-			// ODBC always freezes the session during transaction scopes timeouts.
-			Assume.That(Sfi.ConnectionProvider.Driver, Is.Not.InstanceOf(typeof(OdbcDriver)), "ODBC is not supported for transaction scope timeouts.");
+			// Other special cases: ODBC succeeds this test only with transaction.ignore_session_synchronization_failures enabled.
+			// It freezes the session during the transaction cancellation. To avoid the test to be very long, the synchronization
+			// lock timeout should be lowered too.
 
 			// Test case adapted from https://github.com/kaksmet/NHibBugRepro
 

src/NHibernate.Test/TestDialects/SapSQLAnywhere17TestDialect.cs

@@ -43,11 +43,5 @@ public SapSQLAnywhere17TestDialect(Dialect.Dialect dialect)
 		/// Does not support SELECT FOR UPDATE 
 		/// </summary>
 		public override bool SupportsSelectForUpdate => false;
-
-		/// <summary>
-		/// SQL Anywhere freezes on transaction scope timeout occuring on concurrent threads, always causing the
-		/// synchronization for end of session processing to timeout.
-		/// </summary>
-		public override bool SupportsTransactionScopeTimeouts => false;
 	}
 }

src/NHibernate/Cfg/Environment.cs

@@ -142,12 +142,29 @@ public static string Version
 		/// after scope disposal. This occurs when the transaction is distributed.
 		/// This notably concerns <see cref="ISessionImplementor.AfterTransactionCompletion(bool, ITransaction)"/>.
 		/// NHibernate protects the session from being concurrently used by the code following the scope disposal
-		/// with a lock. To prevent any application freeze, this lock has a default timeout of five seconds. If the
-		/// application appears to require longer (!) running transaction completion events, this setting allows to
+		/// with a lock. To prevent any application freeze, this lock has a default timeout of one second. If the
+		/// application appears to require longer running transaction completion events, this setting allows to
 		/// raise this timeout. <c>-1</c> disables the timeout.</para>
 		/// </summary>
 		public const string SystemTransactionCompletionLockTimeout = "transaction.system_completion_lock_timeout";
 		/// <summary>
+		/// Whether session synchronisation failures occuring during finalizations of system transaction should be
+		/// ignored or not. <see langword="false" /> by default.
+		/// </summary>
+		/// <remarks>
+		/// <para>When a system transaction terminates abnormaly, especially through timeouts, it may have its
+		/// completion events running on concurrent threads while the session is still performing some processing.
+		/// To prevent threading concurrency failures, NHibernate then wait for the session to end its processing,
+		/// up to <see cref="SystemTransactionCompletionLockTimeout" />. If the session processing is still ongoing
+		/// afterwards, it will by default log an error, perform transaction finalization processing concurrently,
+		/// then throw a synchronization error. This setting allows to disable that later throw.</para>
+		/// <para>Disabling the throw can be useful if the used data provider has its own locking mechanism applied
+		/// during transaction completion, preventing the session to end its processing. It may then be safe to
+		/// ignore this synchronization failure. In case of threading concurrency failure, you may then need to
+		/// raise <see cref="SystemTransactionCompletionLockTimeout" />.</para>
+		/// </remarks>
+		public const string IgnoreSessionSynchronizationFailuresOnSystemTransaction = "transaction.ignore_session_synchronization_failures";
+		/// <summary>
 		/// When a system transaction is being prepared, is using connection during this process enabled?
 		/// Default is <see langword="true"/>, for supporting <see cref="FlushMode.Commit"/> with transaction factories
 		/// supporting system transactions. But this requires enlisting additional connections, retaining disposed

src/NHibernate/Transaction/AdoNetWithSystemTransactionFactory.cs

@@ -24,6 +24,10 @@ public partial class AdoNetWithSystemTransactionFactory : AdoNetTransactionFacto
 		/// </summary>
 		protected int SystemTransactionCompletionLockTimeout { get; private set; }
 		/// <summary>
+		/// See <see cref="Cfg.Environment.IgnoreSessionSynchronizationFailuresOnSystemTransaction"/>.
+		/// </summary>
+		protected bool IgnoreSessionSynchronizationFailuresOnSystemTransaction { get; private set; }
+		/// <summary>
 		/// See <see cref="Cfg.Environment.UseConnectionOnSystemTransactionPrepare"/>.
 		/// </summary>
 		protected bool UseConnectionOnSystemTransactionPrepare { get; private set; }
@@ -33,10 +37,12 @@ public override void Configure(IDictionary<string, string> props)
 		{
 			base.Configure(props);
 			SystemTransactionCompletionLockTimeout =
-				PropertiesHelper.GetInt32(Cfg.Environment.SystemTransactionCompletionLockTimeout, props, 5000);
+				PropertiesHelper.GetInt32(Cfg.Environment.SystemTransactionCompletionLockTimeout, props, 1000);
 			if (SystemTransactionCompletionLockTimeout < -1)
 				throw new HibernateException(
 					$"Invalid {Cfg.Environment.SystemTransactionCompletionLockTimeout} value: {SystemTransactionCompletionLockTimeout}. It can not be less than -1.");
+			IgnoreSessionSynchronizationFailuresOnSystemTransaction =
+				PropertiesHelper.GetBoolean(Cfg.Environment.IgnoreSessionSynchronizationFailuresOnSystemTransaction, props, true);
 			UseConnectionOnSystemTransactionPrepare =
 				PropertiesHelper.GetBoolean(Cfg.Environment.UseConnectionOnSystemTransactionPrepare, props, true);
 		}
@@ -130,7 +136,7 @@ protected virtual ITransactionContext CreateAndEnlistMainContext(
 		{
 			var transactionContext = new SystemTransactionContext(
 				session, transaction, SystemTransactionCompletionLockTimeout,
-				UseConnectionOnSystemTransactionPrepare);
+				UseConnectionOnSystemTransactionPrepare, IgnoreSessionSynchronizationFailuresOnSystemTransaction);
 			transactionContext.EnlistedTransaction.EnlistVolatile(
 				transactionContext,
 				UseConnectionOnSystemTransactionPrepare
@@ -189,6 +195,7 @@ public class SystemTransactionContext : ITransactionContext, IEnlistmentNotifica
 
 			private readonly ISessionImplementor _session;
 			private readonly bool _useConnectionOnSystemTransactionPrepare;
+			private readonly bool _ignoreSessionSynchronizationFailures;
 			private readonly System.Transactions.Transaction _originalTransaction;
 			private readonly ManualResetEventSlim _lock = new ManualResetEventSlim(true);
 			private volatile bool _needCompletionLocking = true;
@@ -204,6 +211,8 @@ public class SystemTransactionContext : ITransactionContext, IEnlistmentNotifica
 			/// <param name="transaction">The transaction into which the context will be enlisted.</param>
 			/// <param name="systemTransactionCompletionLockTimeout">See <see cref="Cfg.Environment.SystemTransactionCompletionLockTimeout"/>.</param>
 			/// <param name="useConnectionOnSystemTransactionPrepare">See <see cref="Cfg.Environment.UseConnectionOnSystemTransactionPrepare"/>.</param>
+			// Since 5.6
+			[Obsolete("Use overload with an additionnal boolean parameter")]
 			public SystemTransactionContext(
 				ISessionImplementor session,
 				System.Transactions.Transaction transaction,
@@ -217,6 +226,29 @@ public SystemTransactionContext(
 				_useConnectionOnSystemTransactionPrepare = useConnectionOnSystemTransactionPrepare;
 			}
 
+			/// <summary>
+			/// Default constructor.
+			/// </summary>
+			/// <param name="session">The session to enlist with the transaction.</param>
+			/// <param name="transaction">The transaction into which the context will be enlisted.</param>
+			/// <param name="systemTransactionCompletionLockTimeout">See <see cref="Cfg.Environment.SystemTransactionCompletionLockTimeout"/>.</param>
+			/// <param name="useConnectionOnSystemTransactionPrepare">See <see cref="Cfg.Environment.UseConnectionOnSystemTransactionPrepare"/>.</param>
+			/// <param name="ignoreSessionSynchronizationFailures">See <see cref="Cfg.Environment.IgnoreSessionSynchronizationFailuresOnSystemTransaction"/>.</param>
+			public SystemTransactionContext(
+				ISessionImplementor session,
+				System.Transactions.Transaction transaction,
+				int systemTransactionCompletionLockTimeout,
+				bool useConnectionOnSystemTransactionPrepare,
+				bool ignoreSessionSynchronizationFailures)
+			{
+				_session = session ?? throw new ArgumentNullException(nameof(session));
+				_originalTransaction = transaction ?? throw new ArgumentNullException(nameof(transaction));
+				EnlistedTransaction = transaction.Clone();
+				_systemTransactionCompletionLockTimeout = systemTransactionCompletionLockTimeout;
+				_useConnectionOnSystemTransactionPrepare = useConnectionOnSystemTransactionPrepare;
+				_ignoreSessionSynchronizationFailures = ignoreSessionSynchronizationFailures;
+			}
+
 			/// <inheritdoc />
 			public virtual void Wait()
 			{
@@ -524,14 +556,16 @@ protected virtual void CompleteTransaction(bool isCommitted)
 					Dispose();
 				}
 
-				if (isSessionProcessing)
+				if (isSessionProcessing && !_ignoreSessionSynchronizationFailures)
 				{
 					throw new HibernateException(
 						"A synchronization timeout occurred at transaction completion: the session was still processing. " +
 							$"You may raise {Cfg.Environment.SystemTransactionCompletionLockTimeout} if it is set too low. " +
 							"It may also be a limitation of the data provider, " +
 							"like locks applied on its side while processing transaction cancellations occurring on concurrent threads, " +
-							"thus preventing the session to finish its current processing during a transaction cancellation.");
+							"thus preventing the session to finish its current processing during a transaction cancellation. " +
+							$"In such case, you may enable {Cfg.Environment.IgnoreSessionSynchronizationFailuresOnSystemTransaction}, " +
+							$"and possibly lower {Cfg.Environment.SystemTransactionCompletionLockTimeout}.");
 				}
 			}
 

src/NHibernate/nhibernate-configuration.xsd

@@ -233,12 +233,32 @@
 													after scope disposal. This occurs when the transaction is distributed.
 													This notably concerns ISessionImplementor.AfterTransactionCompletion(bool, ITransaction).
 													NHibernate protects the session from being concurrently used by the code following the scope disposal
-													with a lock. To prevent any application freeze, this lock has a default timeout of five seconds. If the
-													application appears to require longer (!) running transaction completion events, this setting allows to
+													with a lock. To prevent any application freeze, this lock has a default timeout of one second. If the
+													application appears to require longer running transaction completion events, this setting allows to
 													raise this timeout. -1 disables the timeout.
 												</xs:documentation>
 											</xs:annotation>
 										</xs:enumeration>
+										<xs:enumeration value="transaction.ignore_session_synchronization_failures">
+											<xs:annotation>
+												<xs:documentation>
+													Whether session synchronisation failures occuring during finalizations of system transaction should be
+													ignored or not. false by default.
+
+													When a system transaction terminates abnormaly, especially through timeouts, it may have its
+													completion events running on concurrent threads while the session is still performing some processing.
+													To prevent threading concurrency failures, NHibernate then wait for the session to end its processing,
+													up to transaction.system_completion_lock_timeout. If the session processing is still ongoing
+													afterwards, it will by default log an error, perform transaction finalization processing concurrently,
+													then throw a synchronization error. This setting allows to disable that later throw.
+
+													Disabling the throw can be useful if the used data provider has its own locking mechanism applied
+													during transaction completion, preventing the session to end its processing. It may then be safe to
+													ignore this synchronization failure. In case of threading concurrency failure, you may then need to
+													raise transaction.system_completion_lock_timeout.
+												</xs:documentation>
+											</xs:annotation>
+										</xs:enumeration>
 										<xs:enumeration value="transaction.use_connection_on_system_prepare">
 											<xs:annotation>
 												<xs:documentation>

teamcity.build

@@ -50,6 +50,8 @@
 		<property name="db-service" value="MSSQL$SQLEXPRESS" />
 		<property name="nhibernate.connection.driver_class" value="NHibernate.Driver.OdbcDriver" />
 		<property name="nhibernate.odbc.explicit_datetime_scale" value="3" />
+		<property name="nhibernate.transaction.ignore_session_synchronization_failures" value="true" />
+		<property name="nhibernate.transaction.system_completion_lock_timeout" value="200" />
 	<!-- We need to use a dialect that avoids mapping DbType.Time to TIME on MSSQL. On modern SQL Server
 		this becomes TIME(7). Later, such values cannot be read back over ODBC. The
 		error we get is "System.ArgumentException : Unknown SQL type - SS_TIME_EX.". I don't know for certain