CSHARP-2616: Allow applications to set maxTimeMS for commitTransaction.

Author: rstam

src/MongoDB.Driver.Core/Core/Bindings/CoreSession.cs

@@ -376,7 +376,9 @@ private IReadOperation<BsonDocument> CreateAbortTransactionOperation()
 
         private IReadOperation<BsonDocument> CreateCommitTransactionOperation(bool isCommitRetry)
         {
-            return new CommitTransactionOperation(_currentTransaction.RecoveryToken, GetCommitTransactionWriteConcern(isCommitRetry));
+            var writeConcern = GetCommitTransactionWriteConcern(isCommitRetry);
+            var maxCommitTime = _currentTransaction.TransactionOptions.MaxCommitTime;
+            return new CommitTransactionOperation(_currentTransaction.RecoveryToken, writeConcern) { MaxCommitTime = maxCommitTime };
         }
 
         private void EnsureAbortTransactionCanBeCalled(string methodName)
@@ -490,7 +492,8 @@ private TransactionOptions GetEffectiveTransactionOptions(TransactionOptions tra
             var readConcern = transactionOptions?.ReadConcern ?? _options.DefaultTransactionOptions?.ReadConcern ?? ReadConcern.Default;
             var readPreference = transactionOptions?.ReadPreference ?? _options.DefaultTransactionOptions?.ReadPreference ?? ReadPreference.Primary;
             var writeConcern = transactionOptions?.WriteConcern ?? _options.DefaultTransactionOptions?.WriteConcern ?? new WriteConcern();
-            return new TransactionOptions(readConcern, readPreference, writeConcern);
+            var maxCommitTime = transactionOptions?.MaxCommitTime ?? _options.DefaultTransactionOptions?.MaxCommitTime;
+            return new TransactionOptions(readConcern, readPreference, writeConcern, maxCommitTime);
         }
 
         private WriteConcern GetTransactionWriteConcern()

src/MongoDB.Driver.Core/Core/Misc/ExceptionMapper.cs

@@ -44,7 +44,7 @@ public static Exception Map(ConnectionId connectionId, BsonDocument response)
                     case 13475:
                     case 16986:
                     case 16712:
-                        return new MongoExecutionTimeoutException(connectionId, message: "Operation exceeded time limit.");
+                        return new MongoExecutionTimeoutException(connectionId, message: "Operation exceeded time limit.", response);
                 }
             }
 

src/MongoDB.Driver.Core/Core/Operations/EndTransactionOperation.cs

@@ -119,7 +119,7 @@ public virtual async Task<BsonDocument> ExecuteAsync(IReadBinding binding, Cance
         /// Creates the command for the operation.
         /// </summary>
         /// <returns>The command.</returns>
-        private BsonDocument CreateCommand()
+        protected virtual BsonDocument CreateCommand()
         {
             return new BsonDocument
             {
@@ -175,6 +175,9 @@ public AbortTransactionOperation(WriteConcern writeConcern)
     /// </summary>
     public sealed class CommitTransactionOperation : EndTransactionOperation
     {
+        // private fields
+        private TimeSpan? _maxCommitTime;
+
         // public constructors
         /// <summary>
         /// Initializes a new instance of the <see cref="AbortTransactionOperation"/> class.
@@ -195,6 +198,15 @@ public CommitTransactionOperation(BsonDocument recoveryToken, WriteConcern write
         {
         }
 
+        // public properties
+        /// <summary>Gets the maximum commit time.</summary>
+        /// <value>The maximum commit time.</value>
+        public TimeSpan? MaxCommitTime
+        {
+            get => _maxCommitTime;
+            set => _maxCommitTime = Ensure.IsNullOrGreaterThanZero(value, nameof(value));
+        }
+
         // protected properties
         /// <inheritdoc />
         protected override string CommandName => "commitTransaction";
@@ -228,6 +240,18 @@ public override async Task<BsonDocument> ExecuteAsync(IReadBinding binding, Canc
             }
         }
 
+        // protected methods
+        /// <inheritdoc />
+        protected override BsonDocument CreateCommand()
+        {
+            var command = base.CreateCommand();
+            if (_maxCommitTime.HasValue)
+            {
+                command.Add("maxTimeMS", (long)_maxCommitTime.Value.TotalMilliseconds);
+            }
+            return command;
+        }
+
         // private methods
         private void ReplaceTransientTransactionErrorWithUnknownTransactionCommitResult(MongoException exception)
         {
@@ -242,7 +266,9 @@ private bool ShouldReplaceTransientTransactionErrorWithUnknownTransactionCommitR
                 return true;
             }
 
-            if (exception is MongoNotPrimaryException || exception is MongoNodeIsRecoveringException)
+            if (exception is MongoNotPrimaryException ||
+                exception is MongoNodeIsRecoveringException ||
+                exception is MongoExecutionTimeoutException) // MaxTimeMSExpired
             {
                 return true;
             }

src/MongoDB.Driver.Core/MongoExecutionTimeoutException.cs

@@ -14,6 +14,7 @@
 */
 
 using System;
+using MongoDB.Bson;
 #if NET452
 using System.Runtime.Serialization;
 #endif
@@ -29,6 +30,8 @@ namespace MongoDB.Driver
 #endif
     public class MongoExecutionTimeoutException : MongoServerException
     {
+        private readonly BsonDocument _result;
+
         // constructors
         /// <summary>
         /// Initializes a new instance of the <see cref="MongoExecutionTimeoutException"/> class.
@@ -51,6 +54,30 @@ public MongoExecutionTimeoutException(ConnectionId connectionId, string message,
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MongoExecutionTimeoutException"/> class.
+        /// </summary>
+        /// <param name="connectionId">The connection identifier.</param>
+        /// <param name="message">The error message.</param>
+        /// <param name="result">The command result.</param>
+        public MongoExecutionTimeoutException(ConnectionId connectionId, string message, BsonDocument result)
+            : this(connectionId, message, null, result)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MongoExecutionTimeoutException"/> class.
+        /// </summary>
+        /// <param name="connectionId">The connection identifier.</param>
+        /// <param name="message">The error message.</param>
+        /// <param name="innerException">The inner exception.</param>
+        /// <param name="result">The command result.</param>
+        public MongoExecutionTimeoutException(ConnectionId connectionId, string message, Exception innerException, BsonDocument result)
+            : base(connectionId, message, innerException)
+        {
+            _result = result;
+        }
+
 #if NET452
         /// <summary>
         /// Initializes a new instance of the <see cref="MongoExecutionTimeoutException"/> class.
@@ -62,5 +89,25 @@ public MongoExecutionTimeoutException(SerializationInfo info, StreamingContext c
         {
         }
 #endif
+
+        // properties
+        /// <summary>
+        /// Gets the error code.
+        /// </summary>
+        /// <value>
+        /// The error code.
+        /// </value>
+        public int Code =>
+            _result != null && _result.TryGetValue("code", out var code)
+                ? code.ToInt32()
+                : -1;
+
+        /// <summary>
+        /// Gets the name of the error code.
+        /// </summary>
+        /// <value>
+        /// The name of the error code.
+        /// </value>
+        public string CodeName => _result?.GetValue("codeName", null)?.AsString;
     }
 }

src/MongoDB.Driver.Core/TransactionOptions.cs

@@ -14,11 +14,6 @@
 */
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using MongoDB.Bson;
 
 namespace MongoDB.Driver
 {
@@ -28,6 +23,7 @@ namespace MongoDB.Driver
     public class TransactionOptions
     {
         // private fields
+        private readonly TimeSpan? _maxCommitTime;
         private readonly ReadConcern _readConcern;
         private readonly ReadPreference _readPreference;
         private readonly WriteConcern _writeConcern;
@@ -39,17 +35,28 @@ public class TransactionOptions
         /// <param name="readConcern">The read concern.</param>
         /// <param name="readPreference">The read preference.</param>
         /// <param name="writeConcern">The write concern.</param>
+        /// <param name="maxCommitTime">The max commit time.</param>
         public TransactionOptions(
             Optional<ReadConcern> readConcern = default(Optional<ReadConcern>),
             Optional<ReadPreference> readPreference = default(Optional<ReadPreference>),
-            Optional<WriteConcern> writeConcern = default(Optional<WriteConcern>))
+            Optional<WriteConcern> writeConcern = default(Optional<WriteConcern>),
+            Optional<TimeSpan?> maxCommitTime = default(Optional<TimeSpan?>))
         {
             _readConcern = readConcern.WithDefault(null);
             _readPreference = readPreference.WithDefault(null);
             _writeConcern = writeConcern.WithDefault(null);
+            _maxCommitTime = maxCommitTime.WithDefault(null);
         }
 
         // public properties
+        /// <summary>
+        /// Gets the max commit time.
+        /// </summary>
+        /// <value>
+        /// The max commit time.
+        /// </value>
+        public TimeSpan? MaxCommitTime => _maxCommitTime;
+
         /// <summary>
         /// Gets the read concern.
         /// </summary>
@@ -81,18 +88,21 @@ public TransactionOptions(
         /// <param name="readConcern">The new read concern.</param>
         /// <param name="readPreference">The read preference.</param>
         /// <param name="writeConcern">The new write concern.</param>
+        /// <param name="maxCommitTime">The max commit time.</param>
         /// <returns>
         /// The new TransactionOptions.
         /// </returns>
         public TransactionOptions With(
             Optional<ReadConcern> readConcern = default(Optional<ReadConcern>),
             Optional<ReadPreference> readPreference = default(Optional<ReadPreference>),
-            Optional<WriteConcern> writeConcern = default(Optional<WriteConcern>))
+            Optional<WriteConcern> writeConcern = default(Optional<WriteConcern>),
+            Optional<TimeSpan?> maxCommitTime = default(Optional<TimeSpan?>))
         {
             return new TransactionOptions(
                 readConcern: readConcern.WithDefault(_readConcern),
                 readPreference: readPreference.WithDefault(_readPreference),
-                writeConcern: writeConcern.WithDefault(_writeConcern));
+                writeConcern: writeConcern.WithDefault(_writeConcern),
+                maxCommitTime: maxCommitTime.WithDefault(_maxCommitTime));
         }
     }
 }

src/MongoDB.Driver/ClientSessionHandle.cs

@@ -166,8 +166,9 @@ private TransactionOptions GetEffectiveTransactionOptions(TransactionOptions tra
             var readConcern = transactionOptions?.ReadConcern ?? defaultTransactionOptions?.ReadConcern ?? _client.Settings?.ReadConcern ?? ReadConcern.Default;
             var readPreference = transactionOptions?.ReadPreference ?? defaultTransactionOptions?.ReadPreference ?? _client.Settings?.ReadPreference ?? ReadPreference.Primary;
             var writeConcern = transactionOptions?.WriteConcern ?? defaultTransactionOptions?.WriteConcern ?? _client.Settings?.WriteConcern ?? new WriteConcern();
+            var maxCommitTime = transactionOptions?.MaxCommitTime ?? defaultTransactionOptions?.MaxCommitTime;
 
-            return new TransactionOptions(readConcern, readPreference, writeConcern);
+            return new TransactionOptions(readConcern, readPreference, writeConcern, maxCommitTime);
         }
     }
 }

src/MongoDB.Driver/TransactionExecutor.cs

@@ -26,6 +26,7 @@ internal static class TransactionExecutor
         // constants
         private const string TransientTransactionErrorLabel = "TransientTransactionError";
         private const string UnknownTransactionCommitResultLabel = "UnknownTransactionCommitResult";
+        private const int ExceededTimeLimitErrorCode = 50;
         private static readonly TimeSpan __transactionTimeout = TimeSpan.FromSeconds(120);
 
         public static TResult ExecuteWithRetries<TResult>(
@@ -152,7 +153,7 @@ private static bool CommitWithRetries(IClientSessionHandle clientSession, DateTi
                 catch (Exception ex)
                 {
                     var now = clock.UtcNow; // call UtcNow once since we need to facilitate predictable mocking
-                    if (HasErrorLabel(ex, UnknownTransactionCommitResultLabel) && !HasTimedOut(startTime, now))
+                    if (ShouldRetryCommit(ex, startTime, now))
                     {
                         continue;
                     }
@@ -179,7 +180,7 @@ private static async Task<bool> CommitWithRetriesAsync(IClientSessionHandle clie
                 catch (Exception ex)
                 {
                     var now = clock.UtcNow; // call UtcNow once since we need to facilitate predictable mocking
-                    if (HasErrorLabel(ex, UnknownTransactionCommitResultLabel) && !HasTimedOut(startTime, now))
+                    if (ShouldRetryCommit(ex, startTime, now))
                     {
                         continue;
                     }
@@ -206,6 +207,30 @@ private static bool HasErrorLabel(Exception ex, string errorLabel)
             }
         }
 
+        private static bool IsExceededTimeLimitException(Exception ex)
+        {
+            if (ex is MongoExecutionTimeoutException timeoutException && 
+                timeoutException.Code == ExceededTimeLimitErrorCode)
+            {
+                return true;
+            }
+
+            if (ex is MongoWriteConcernException writeConcernException)
+            {
+                var writeConcernError = writeConcernException.WriteConcernResult.Response?.GetValue("writeConcernError", null)?.AsBsonDocument;
+                if (writeConcernError != null)
+                {
+                    var code = writeConcernError.GetValue("code", -1).ToInt32();
+                    if (code == ExceededTimeLimitErrorCode)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
         private static bool IsTransactionInStartingOrInProgressState(IClientSessionHandle clientSession)
         {
             var currentTransaction = clientSession.WrappedCoreSession.CurrentTransaction;
@@ -220,6 +245,14 @@ private static bool IsTransactionInStartingOrInProgressState(IClientSessionHandl
             }
         }
 
+        private static bool ShouldRetryCommit(Exception ex, DateTime startTime, DateTime now)
+        {
+            return
+                HasErrorLabel(ex, UnknownTransactionCommitResultLabel) &&
+                !HasTimedOut(startTime, now) &&
+                !IsExceededTimeLimitException(ex);
+        }
+
         // nested types
         internal abstract class CallbackOutcome<TResult>
         {

tests/MongoDB.Driver.Core.TestHelpers/JsonDrivenTests/CommandStartedEventAsserter.cs

@@ -100,6 +100,7 @@ private void AssertCommandAspect(BsonDocument actualCommand, string name, BsonVa
                     case "startTransaction":
                     case "txnNumber":
                     case "writeConcern":
+                    case "maxTimeMS":
                         if (actualCommand.Contains(name))
                         {
                             throw new AssertionFailedException($"Did not expect field '{name}' in command: {actualCommand.ToJson()}.");
@@ -130,7 +131,7 @@ private void AssertCommandAspect(BsonDocument actualCommand, string name, BsonVa
                 AdaptExpectedUpdateModels(actualValue.AsBsonArray.Cast<BsonDocument>().ToList(), expectedValue.AsBsonArray.Cast<BsonDocument>().ToList());
             }
 
-            var namesToUseOrderInsensitiveComparisonWith = new[] { "writeConcern" };
+            var namesToUseOrderInsensitiveComparisonWith = new[] { "writeConcern", "maxTimeMS" };
             var useOrderInsensitiveComparison = namesToUseOrderInsensitiveComparisonWith.Contains(name);
 
             if (!(useOrderInsensitiveComparison ? BsonValueEquivalencyComparer.Compare(actualValue, expectedValue) : actualValue.Equals(expectedValue)))

tests/MongoDB.Driver.Tests/JsonDrivenTests/JsonDrivenAggregateTest.cs

@@ -13,6 +13,7 @@
 * limitations under the License.
 */
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -93,6 +94,10 @@ protected override void SetArgument(string name, BsonValue value)
                 case "session":
                     _session = (IClientSessionHandle)_objectMap[value.AsString];
                     return;
+
+                case "maxTimeMS":
+                    _options.MaxTime = TimeSpan.FromMilliseconds(value.ToInt32());
+                    return;
             }
 
             base.SetArgument(name, value);

tests/MongoDB.Driver.Tests/JsonDrivenTests/JsonDrivenCommandTest.cs

@@ -51,6 +51,11 @@ protected override void AssertException()
                     }
                 }
 
+                if (actualErrorCodeName == null && _actualException is MongoExecutionTimeoutException mongoExecutionTimeout)
+                {
+                    actualErrorCodeName = mongoExecutionTimeout.CodeName;
+                }
+
                 if (actualErrorCodeName == null)
                 {
                     throw new Exception("Exception was missing \"errorCodeName\".");