Require global opt-in for distributed transactions (#76376)

src/libraries/System.Transactions.Local/ref/System.Transactions.Local.cs

@@ -4,6 +4,8 @@
 // Changes to this file must follow the https://aka.ms/api-review process.
 // ------------------------------------------------------------------------------
 
+using System.Runtime.Versioning;
+
 namespace System.Transactions
 {
  [System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
@@ -191,6 +193,7 @@ public static partial class TransactionManager
  [System.Diagnostics.CodeAnalysis.DisallowNullAttribute]
  public static System.Transactions.HostCurrentTransactionCallback? HostCurrentCallback { get { throw null; } set { } }
  public static System.TimeSpan MaximumTimeout { get { throw null; } set { } }
+ public static bool ImplicitDistributedTransactions { get; [System.Runtime.Versioning.SupportedOSPlatform("windows")] [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Distributed transactions support may not be compatible with trimming. If your program creates a distributed transaction via System.Transactions, the correctness of the application cannot be guaranteed after trimming.")] set; }
  public static event System.Transactions.TransactionStartedEventHandler? DistributedTransactionStarted { add { } remove { } }
  public static void RecoveryComplete(System.Guid resourceManagerIdentifier) { }
  public static System.Transactions.Enlistment Reenlist(System.Guid resourceManagerIdentifier, byte[] recoveryInformation, System.Transactions.IEnlistmentNotification enlistmentNotification) { throw null; }

src/libraries/System.Transactions.Local/src/Resources/Strings.resx

@@ -423,4 +423,10 @@
  <data name="DistributedNotSupportedOn32Bits" xml:space="preserve">
  <value>Distributed transactions are currently unsupported in 32-bit processes.</value>
  </data>
-</root>
+ <data name="ImplicitDistributedTransactionsDisabled" xml:space="preserve">
+ <value>Implicit distributed transactions have not been enabled. If you're intentionally starting a distributed transaction, set TransactionManager.ImplicitDistributedTransactions to true.</value>
+ </data>
+ <data name="ImplicitDistributedTransactionsCannotBeChanged" xml:space="preserve">
+ <value>TransactionManager.ImplicitDistributedTransaction cannot be changed once set, or once System.Transactions distributed transactions have been initialized. Set this flag once at the start of your program.</value>
+ </data>
+</root>

src/libraries/System.Transactions.Local/src/System/Transactions/DtcProxyShim/DtcProxyShimFactory.cs

@@ -21,6 +21,11 @@ internal sealed class DtcProxyShimFactory
  // at the same time.
  private static readonly object _proxyInitLock = new();
 
+ // This object will perform the actual distributed transaction connection.
+ // It will be set only if TransactionManager.ImplicitDefaultTransactions
+ // is set to true, allowing the relevant code to be trimmed otherwise.
+ internal static ITransactionConnector? s_transactionConnector;
+
  // Lock to protect access to listOfNotifications.
  private readonly object _notificationLock = new();
 
@@ -41,6 +46,7 @@ internal DtcProxyShimFactory(EventWaitHandle notificationEventHandle)
 
  // https://docs.microsoft.com/previous-versions/windows/desktop/ms678898(v=vs.85)
  [DllImport(Interop.Libraries.Xolehlp, CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = false)]
+ [RequiresUnreferencedCode(TransactionManager.DistributedTransactionTrimmingWarning)]
  private static extern void DtcGetTransactionManagerExW(
  [MarshalAs(UnmanagedType.LPWStr)] string? pszHost,
  [MarshalAs(UnmanagedType.LPWStr)] string? pszTmName,
@@ -49,7 +55,7 @@ private static extern void DtcGetTransactionManagerExW(
  object? pvConfigPararms,
  [MarshalAs(UnmanagedType.Interface)] out ITransactionDispenser ppvObject);
 
- [RequiresUnreferencedCode("Distributed transactions support may not be compatible with trimming. If your program creates a distributed transaction via System.Transactions, the correctness of the application cannot be guaranteed after trimming.")]
+ [RequiresUnreferencedCode(TransactionManager.DistributedTransactionTrimmingWarning)]
  private static void DtcGetTransactionManager(string? nodeName, out ITransactionDispenser localDispenser) =>
  DtcGetTransactionManagerExW(nodeName, null, Guids.IID_ITransactionDispenser_Guid, 0, null, out localDispenser);
 
@@ -61,15 +67,27 @@ public void ConnectToProxy(
  out byte[] whereabouts,
  out ResourceManagerShim resourceManagerShim)
  {
- switch (RuntimeInformation.ProcessArchitecture)
+ if (RuntimeInformation.ProcessArchitecture == Architecture.X86)
+ {
+ throw new PlatformNotSupportedException(SR.DistributedNotSupportedOn32Bits);
+ }
+
+ lock (TransactionManager.s_implicitDistributedTransactionsLock)
  {
- case Architecture.X86:
- throw new PlatformNotSupportedException(SR.DistributedNotSupportedOn32Bits);
+ if (s_transactionConnector is null)
+ {
+ // We set TransactionManager.ImplicitDistributedTransactionsInternal, so that any attempt to change it
+ // later will cause an exception.
+ TransactionManager.s_implicitDistributedTransactions = false;
+
+ throw new NotSupportedException(SR.ImplicitDistributedTransactionsDisabled);
+ }
  }
 
- ConnectToProxyCore(nodeName, resourceManagerIdentifier, managedIdentifier, out nodeNameMatches, out whereabouts, out resourceManagerShim);
+ s_transactionConnector.ConnectToProxyCore(this, nodeName, resourceManagerIdentifier, managedIdentifier, out nodeNameMatches, out whereabouts, out resourceManagerShim);
  }
 
+ [RequiresUnreferencedCode(TransactionManager.DistributedTransactionTrimmingWarning)]
  private void ConnectToProxyCore(
  string? nodeName,
  Guid resourceManagerIdentifier,
@@ -80,9 +98,7 @@ private void ConnectToProxyCore(
  {
  lock (_proxyInitLock)
  {
-#pragma warning disable IL2026 // This warning is left in the product so developers get an ILLink warning when trimming an app using this transaction support
  DtcGetTransactionManager(nodeName, out ITransactionDispenser? localDispenser);
-#pragma warning restore IL2026
 
  // Check to make sure the node name matches.
  if (nodeName is not null)
@@ -353,6 +369,8 @@ internal ITransactionTransmitter GetCachedTransmitter(ITransaction transaction)
 
  internal void ReturnCachedTransmitter(ITransactionTransmitter transmitter)
  {
+ // Note that due to race conditions, we may end up enqueuing above s_maxCachedInterfaces.
+ // This is benign, as this is only a best-effort cache, and there are no negative consequences.
  if (_cachedTransmitters.Count < s_maxCachedInterfaces)
  {
  transmitter.Reset();
@@ -375,10 +393,46 @@ internal ITransactionReceiver GetCachedReceiver()
 
  internal void ReturnCachedReceiver(ITransactionReceiver receiver)
  {
+ // Note that due to race conditions, we may end up enqueuing above s_maxCachedInterfaces.
+ // This is benign, as this is only a best-effort cache, and there are no negative consequences.
  if (_cachedReceivers.Count < s_maxCachedInterfaces)
  {
  receiver.Reset();
  _cachedReceivers.Enqueue(receiver);
  }
  }
+
+ internal interface ITransactionConnector
+ {
+ void ConnectToProxyCore(
+ DtcProxyShimFactory proxyShimFactory,
+ string? nodeName,
+ Guid resourceManagerIdentifier,
+ object managedIdentifier,
+ out bool nodeNameMatches,
+ out byte[] whereabouts,
+ out ResourceManagerShim resourceManagerShim);
+ }
+
+ [RequiresUnreferencedCode(TransactionManager.DistributedTransactionTrimmingWarning)]
+ internal sealed class DtcTransactionConnector : ITransactionConnector
+ {
+ public void ConnectToProxyCore(
+ DtcProxyShimFactory proxyShimFactory,
+ string? nodeName,
+ Guid resourceManagerIdentifier,
+ object managedIdentifier,
+ out bool nodeNameMatches,
+ out byte[] whereabouts,
+ out ResourceManagerShim resourceManagerShim)
+ {
+ proxyShimFactory.ConnectToProxyCore(
+ nodeName,
+ resourceManagerIdentifier,
+ managedIdentifier,
+ out nodeNameMatches,
+ out whereabouts,
+ out resourceManagerShim);
+ }
+ }
 }

src/libraries/System.Transactions.Local/src/System/Transactions/TransactionManager.cs

@@ -4,8 +4,12 @@
 using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Runtime.Versioning;
 using System.Threading;
 using System.Transactions.Configuration;
+#if WINDOWS
+using System.Transactions.DtcProxyShim;
+#endif
 using System.Transactions.Oletx;
 
 namespace System.Transactions
@@ -29,6 +33,10 @@ public static class TransactionManager
  private static TransactionTable? s_transactionTable;
 
  private static TransactionStartedEventHandler? s_distributedTransactionStartedDelegate;
+
+ internal const string DistributedTransactionTrimmingWarning =
+ "Distributed transactions support may not be compatible with trimming. If your program creates a distributed transaction via System.Transactions, the correctness of the application cannot be guaranteed after trimming.";
+
  public static event TransactionStartedEventHandler? DistributedTransactionStarted
  {
  add
@@ -391,6 +399,60 @@ public static TimeSpan MaximumTimeout
  }
  }
 
+ /// <summary>
+ /// Controls whether usage of System.Transactions APIs that require escalation to a distributed transaction will do so;
+ /// if your application requires distributed transaction, opt into using them by setting this to <see langword="true" />.
+ /// If set to <see langword="false" /> (the default), escalation to a distributed transaction will throw a <see cref="NotSupportedException" />.
+ /// </summary>
+#if WINDOWS
+ public static bool ImplicitDistributedTransactions
+ {
+ get => DtcProxyShimFactory.s_transactionConnector is not null;
+
+ [SupportedOSPlatform("windows")]
+ [RequiresUnreferencedCode(DistributedTransactionTrimmingWarning)]
+ set
+ {
+ lock (s_implicitDistributedTransactionsLock)
+ {
+ // Make sure this flag can only be set once, and that once distributed transactions have been initialized,
+ // it's frozen.
+ if (s_implicitDistributedTransactions is null)
+ {
+ s_implicitDistributedTransactions = value;
+
+ if (value)
+ {
+ DtcProxyShimFactory.s_transactionConnector ??= new DtcProxyShimFactory.DtcTransactionConnector();
+ }
+ }
+ else if (value != s_implicitDistributedTransactions)
+ {
+ throw new InvalidOperationException(SR.ImplicitDistributedTransactionsCannotBeChanged);
+ }
+ }
+ }
+ }
+
+ internal static bool? s_implicitDistributedTransactions;
+ internal static object s_implicitDistributedTransactionsLock = new();
+#else
+ public static bool ImplicitDistributedTransactions
+ {
+ get => false;
+
+ [SupportedOSPlatform("windows")]
+ [RequiresUnreferencedCode(DistributedTransactionTrimmingWarning)]
+ set
+ {
+ if (value)
+ {
+ throw new PlatformNotSupportedException(SR.DistributedNotSupported);
+ }
+ }
+ }
+#endif
+
  // This routine writes the "header" for the recovery information, based on the
  // type of the calling object and its provided parameter collection. This information
  // we be read back by the static Reenlist method to create the necessary transaction

src/libraries/System.Transactions.Local/tests/OleTxTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.IO;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
 using Microsoft.DotNet.RemoteExecutor;
@@ -492,6 +493,80 @@ public void GetDtcTransaction()
  Retry(() => Assert.Equal(TransactionStatus.Committed, tx.TransactionInformation.Status));
  });
 
+ [ConditionalFact(nameof(IsRemoteExecutorSupportedAndNotNano))]
+ public void Distributed_transactions_require_ImplicitDistributedTransactions_true()
+ {
+ // Temporarily skip on 32-bit where we have an issue.
+ if (!Environment.Is64BitProcess)
+ {
+ return;
+ }
+
+ using var _ = RemoteExecutor.Invoke(() =>
+ {
+ Assert.False(TransactionManager.ImplicitDistributedTransactions);
+
+ using var tx = new CommittableTransaction();
+
+ Assert.Throws<NotSupportedException>(MinimalOleTxScenario);
+ });
+ }
+
+ [ConditionalFact(nameof(IsRemoteExecutorSupportedAndNotNano))]
+ public void ImplicitDistributedTransactions_cannot_be_changed_after_being_set()
+ {
+ // Temporarily skip on 32-bit where we have an issue.
+ if (!Environment.Is64BitProcess)
+ {
+ return;
+ }
+
+ using var _ = RemoteExecutor.Invoke(() =>
+ {
+ TransactionManager.ImplicitDistributedTransactions = true;
+
+ Assert.Throws<InvalidOperationException>(() => TransactionManager.ImplicitDistributedTransactions = false);
+ });
+ }
+
+ [ConditionalFact(nameof(IsRemoteExecutorSupportedAndNotNano))]
+ public void ImplicitDistributedTransactions_cannot_be_changed_after_being_read_as_true()
+ {
+ // Temporarily skip on 32-bit where we have an issue.
+ if (!Environment.Is64BitProcess)
+ {
+ return;
+ }
+
+ using var _ = RemoteExecutor.Invoke(() =>
+ {
+ TransactionManager.ImplicitDistributedTransactions = true;
+
+ MinimalOleTxScenario();
+
+ Assert.Throws<InvalidOperationException>(() => TransactionManager.ImplicitDistributedTransactions = false);
+ TransactionManager.ImplicitDistributedTransactions = true;
+ });
+ }
+
+ [ConditionalFact(nameof(IsRemoteExecutorSupportedAndNotNano))]
+ public void ImplicitDistributedTransactions_cannot_be_changed_after_being_read_as_false()
+ {
+ // Temporarily skip on 32-bit where we have an issue.
+ if (!Environment.Is64BitProcess)
+ {
+ return;
+ }
+
+ using var _ = RemoteExecutor.Invoke(() =>
+ {
+ Assert.Throws<NotSupportedException>(MinimalOleTxScenario);
+
+ Assert.Throws<InvalidOperationException>(() => TransactionManager.ImplicitDistributedTransactions = true);
+ TransactionManager.ImplicitDistributedTransactions = false;
+ });
+ }
+
  private static void Test(Action action)
  {
  // Temporarily skip on 32-bit where we have an issue.
@@ -500,6 +575,8 @@ private static void Test(Action action)
  return;
  }
 
+ TransactionManager.ImplicitDistributedTransactions = true;
+
  // In CI, we sometimes get XACT_E_TMNOTAVAILABLE; when it happens, it's typically on the very first
  // attempt to connect to MSDTC (flaky/slow on-demand startup of MSDTC), though not only.
  // This catches that error and retries.
@@ -549,23 +626,25 @@ private static void Retry(Action action)
  }
  }
 
+ static void MinimalOleTxScenario()
+ {
+ using var tx = new CommittableTransaction();
+
+ var enlistment1 = new TestEnlistment(Phase1Vote.Prepared, EnlistmentOutcome.Committed);
+ var enlistment2 = new TestEnlistment(Phase1Vote.Prepared, EnlistmentOutcome.Committed);
+
+ tx.EnlistDurable(Guid.NewGuid(), enlistment1, EnlistmentOptions.None);
+ tx.EnlistDurable(Guid.NewGuid(), enlistment2, EnlistmentOptions.None);
+
+ tx.Commit();
+ }
+
  public class OleTxFixture
  {
  // In CI, we sometimes get XACT_E_TMNOTAVAILABLE on the very first attempt to connect to MSDTC;
  // this is likely due to on-demand slow startup of MSDTC. Perform pre-test connecting with retry
  // to ensure that MSDTC is properly up when the first test runs.
  public OleTxFixture()
- => Test(() =>
- {
- using var tx = new CommittableTransaction();
-
- var enlistment1 = new TestEnlistment(Phase1Vote.Prepared, EnlistmentOutcome.Committed);
- var enlistment2 = new TestEnlistment(Phase1Vote.Prepared, EnlistmentOutcome.Committed);
-
- tx.EnlistDurable(Guid.NewGuid(), enlistment1, EnlistmentOptions.None);
- tx.EnlistDurable(Guid.NewGuid(), enlistment2, EnlistmentOptions.None);
-
- tx.Commit();
- });
+ => Test(MinimalOleTxScenario);
  }
 }