NH-3807 - Distributed transactions not supported in .netstandard.

Enlisted transactions are still supported, as long as they are single-phase with the durable resource.

Author: ngbrown

src/NHibernate.Test/NHSpecificTest/NH2420/Fixture.cs

@@ -65,13 +65,11 @@ public void ShouldBeAbleToReleaseSuppliedConnectionAfterDistributedTransaction()
 					EnlistmentOptions.None);
 
 				DbConnection connection;
-#if !NETCOREAPP2_0
 				if (sessions.ConnectionProvider.Driver.GetType() == typeof(OdbcDriver))
 				{
 					connection = new OdbcConnection(connectionString);
 				}
 				else
-#endif
 				{
 					connection = new SqlConnection(connectionString);
 				}

src/NHibernate.Test/NHibernate.Test.csproj

@@ -17,7 +17,9 @@
 
   <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp2.0'">
     <Compile Remove="DriverTest\**" />
+    <Compile Remove="NHSpecificTest\DtcFailures\**" /> <!--Distributed-->
     <Compile Remove="NHSpecificTest\NH2188\**" />
+    <Compile Remove="NHSpecificTest\NH2420\**" /> <!--Distributed-->
     <Compile Remove="NHSpecificTest\NH2484\**" />
     <Compile Remove="NHSpecificTest\NH2985\**" />
     <Compile Remove="NHSpecificTest\NH3121\**" />

src/NHibernate.Test/TestCase.cs

@@ -167,12 +167,13 @@ public void TearDown()
 				var wereClosed = CheckSessionsWereClosed();
 				var wasCleaned = CheckDatabaseWasCleaned();
 				var wereConnectionsClosed = CheckConnectionsWereClosed();
-				fail = !wereClosed || !wasCleaned || !wereConnectionsClosed;
+				var wereTransactionsDisposed = CheckEnlistedTransactionsWereDisposed();
+				fail = !wereClosed || !wasCleaned || !wereConnectionsClosed || !wereTransactionsDisposed;
 
 				if (fail)
 				{
 					badCleanupMessage = "Test didn't clean up after itself. session closed: " + wereClosed + "; database cleaned: " + wasCleaned
-						+ "; connection closed: " + wereConnectionsClosed;
+						+ "; connection closed: " + wereConnectionsClosed + "; transactions disposed:" + wereTransactionsDisposed;
 					if (testResult != null && testResult.Outcome.Status == TestStatus.Failed)
 					{
 						// Avoid hiding a test failure (asserts are usually not hidden, but other exception would be).
@@ -270,6 +271,31 @@ private bool CheckConnectionsWereClosed()
 			return false;
 		}
 
+		private bool CheckEnlistedTransactionsWereDisposed()
+		{
+			System.Transactions.Transaction current = System.Transactions.Transaction.Current;
+			bool notAborted = ((System.Transactions.Transaction.Current?.TransactionInformation.Status) ?? System.Transactions.TransactionStatus.Aborted) != System.Transactions.TransactionStatus.Aborted;
+			if (!notAborted) return true;
+
+			do
+			{
+				notAborted = current.TransactionInformation.Status != System.Transactions.TransactionStatus.Aborted;
+
+				try
+				{
+					current.Dispose();
+				}
+				catch (Exception ex)
+				{
+					log.Error("Error disposing enlisted transaction", ex);
+				}
+
+				current = System.Transactions.Transaction.Current;
+			} while (current != null && notAborted);
+
+			return false;
+		}
+
 		private void Configure()
 		{
 			cfg = TestConfigurationHelper.GetDefaultConfiguration();

src/NHibernate/Transaction/AdoNetWithDistributedTransactionFactory.cs

@@ -90,7 +90,7 @@ public void ExecuteWorkInIsolation(ISessionImplementor session, IIsolatedWork wo
 			}
 		}
 
-		public class DistributedTransactionContext : ITransactionContext, IEnlistmentNotification
+		public class DistributedTransactionContext : ITransactionContext, IEnlistmentNotification, IPromotableSinglePhaseNotification
 		{
 			public System.Transactions.Transaction AmbientTransation { get; set; }
 			public bool ShouldCloseSessionOnDistributedTransactionCompleted { get; set; }
@@ -104,6 +104,79 @@ public DistributedTransactionContext(ISessionImplementor sessionImplementor, Sys
 				IsInActiveTransaction = true;
 			}
 
+			#region IPromotableSinglePhaseNotification Members
+
+			void IPromotableSinglePhaseNotification.Initialize()
+			{
+				logger.Error("promotable single-phase transaction initialize");
+				using (new SessionIdLoggingContext(sessionImplementor.SessionId))
+				{
+					try
+					{
+						using (var tx = new TransactionScope(AmbientTransation))
+						{
+							sessionImplementor.BeforeTransactionCompletion(null);
+							if (sessionImplementor.FlushMode != FlushMode.Manual && sessionImplementor.ConnectionManager.IsConnected)
+							{
+								using (sessionImplementor.ConnectionManager.FlushingFromDtcTransaction)
+								{
+									logger.Debug(string.Format("[session-id={0}] Flushing from Dtc Transaction", sessionImplementor.SessionId));
+									sessionImplementor.Flush();
+								}
+							}
+							logger.Debug("prepared for promotable single-phase transaction");
+
+							tx.Complete();
+						}
+					}
+					catch (Exception exception)
+					{
+						logger.Error("promotable single-phase transaction prepare phase failed", exception);
+					}
+				}
+			}
+
+			void IPromotableSinglePhaseNotification.SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment)
+			{
+				using (new SessionIdLoggingContext(sessionImplementor.SessionId))
+				{
+					try
+					{
+						sessionImplementor.BeforeTransactionCompletion(null);
+						logger.Debug("committing promotable single-phase transaction");
+						// we have nothing to do here, since it is the actual
+						// DB connection that will commit the transaction
+						singlePhaseEnlistment.Committed();
+						IsInActiveTransaction = false;
+					}
+					catch (Exception exception)
+					{
+						logger.Error("promotable single-phase transaction prepare phase failed", exception);
+						singlePhaseEnlistment.Aborted(exception);
+					}
+				}
+			}
+
+			void IPromotableSinglePhaseNotification.Rollback(SinglePhaseEnlistment singlePhaseEnlistment)
+			{
+				using (new SessionIdLoggingContext(sessionImplementor.SessionId))
+				{
+					logger.Debug("rolled back promotable single-phase transaction");
+					// Currently AfterTransactionCompletion is called by the handler for the TransactionCompleted event.
+					//sessionImplementor.AfterTransactionCompletion(false, null);
+					singlePhaseEnlistment.Done();
+					IsInActiveTransaction = false;
+				}
+			}
+
+			byte[] ITransactionPromoter.Promote()
+			{
+				logger.Error("promotable single-phase transaction promote not implemented");
+				throw new TransactionPromotionException("Not implemented");
+			}
+
+			#endregion
+
 			#region IEnlistmentNotification Members
 
 			void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment)
@@ -181,4 +254,4 @@ public void Dispose()
 			}
 		}
 	}
-}
+}