CSHARP-3552: CSOT: Transactions

src/MongoDB.Driver/AbortTransactionOptions.cs

@@ -0,0 +1,34 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver
+{
+    // TODO: CSOT: Make it public when CSOT will be ready for GA
+    internal sealed class AbortTransactionOptions
+    {
+        public AbortTransactionOptions()
+        {}
+
+        public AbortTransactionOptions(TimeSpan? timeout)
+        {
+            Timeout = Ensure.IsNullOrValidTimeout(timeout, nameof(timeout));
+        }
+
+        public TimeSpan? Timeout { get; }
+    }
+}

src/MongoDB.Driver/ClientSessionHandle.cs

@@ -1,4 +1,4 @@
-/* Copyright 2017-present MongoDB Inc.
+/* Copyright 2010-present MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -94,16 +94,20 @@ public IServerSession ServerSession
 
         // public methods
         /// <inheritdoc />
-        public void AbortTransaction(CancellationToken cancellationToken = default(CancellationToken))
-        {
-            _coreSession.AbortTransaction(cancellationToken);
-        }
+        public void AbortTransaction(CancellationToken cancellationToken = default)
+            => _coreSession.AbortTransaction(cancellationToken);
+
+        // TODO: CSOT: Make it public when CSOT will be ready for GA
+        internal void AbortTransaction(AbortTransactionOptions options, CancellationToken cancellationToken = default)
+            => _coreSession.AbortTransaction(options, cancellationToken);
 
         /// <inheritdoc />
-        public Task AbortTransactionAsync(CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return _coreSession.AbortTransactionAsync(cancellationToken);
-        }
+        public Task AbortTransactionAsync(CancellationToken cancellationToken = default)
+            => _coreSession.AbortTransactionAsync(cancellationToken);
+
+        // TODO: CSOT: Make it public when CSOT will be ready for GA
+        internal Task AbortTransactionAsync(AbortTransactionOptions options, CancellationToken cancellationToken = default)
+            => _coreSession.AbortTransactionAsync(options, cancellationToken);
 
         /// <inheritdoc />
         public void AdvanceClusterTime(BsonDocument newClusterTime)
@@ -118,16 +122,20 @@ public void AdvanceOperationTime(BsonTimestamp newOperationTime)
         }
 
         /// <inheritdoc />
-        public void CommitTransaction(CancellationToken cancellationToken = default(CancellationToken))
-        {
-            _coreSession.CommitTransaction(cancellationToken);
-        }
+        public void CommitTransaction(CancellationToken cancellationToken = default)
+            => _coreSession.CommitTransaction(cancellationToken);
+
+        // TODO: CSOT: Make it public when CSOT will be ready for GA
+        internal void CommitTransaction(CommitTransactionOptions options, CancellationToken cancellationToken = default)
+            => _coreSession.CommitTransaction(options, cancellationToken);
 
         /// <inheritdoc />
-        public Task CommitTransactionAsync(CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return _coreSession.CommitTransactionAsync(cancellationToken);
-        }
+        public Task CommitTransactionAsync(CancellationToken cancellationToken = default)
+            => _coreSession.CommitTransactionAsync(cancellationToken);
+
+        // TODO: CSOT: Make it public when CSOT will be ready for GA
+        internal Task CommitTransactionAsync(CommitTransactionOptions options, CancellationToken cancellationToken = default)
+            => _coreSession.CommitTransactionAsync(options, cancellationToken);
 
         /// <inheritdoc />
         public void Dispose()

src/MongoDB.Driver/CommitTransactionOptions.cs

@@ -0,0 +1,36 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver
+{
+    // TODO: CSOT: Make it public when CSOT will be ready for GA
+    internal sealed class CommitTransactionOptions
+    {
+        public CommitTransactionOptions()
+        {}
+
+        public CommitTransactionOptions(TimeSpan? timeout)
+        {
+            Timeout = Ensure.IsNullOrValidTimeout(timeout, nameof(timeout));
+        }
+
+        public TimeSpan? Timeout { get; }
+    }
+
+}
+

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

@@ -1,4 +1,4 @@
-/* Copyright 2018-present MongoDB Inc.
+/* Copyright 2010-present MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -141,12 +141,15 @@ public bool IsInTransaction
 
         // public methods
         /// <inheritdoc />
-        public void AbortTransaction(CancellationToken cancellationToken = default(CancellationToken))
+        public void AbortTransaction(CancellationToken cancellationToken = default)
+            => AbortTransaction(null, cancellationToken);
+
+        // TODO: CSOT: Make it public when CSOT will be ready for GA
+        internal void AbortTransaction(AbortTransactionOptions options, CancellationToken cancellationToken = default)
         {
             EnsureAbortTransactionCanBeCalled(nameof(AbortTransaction));
 
-            // TODO: CSOT implement proper way to obtain the operationContext
-            var operationContext = new OperationContext(null, cancellationToken);
+            using var operationContext = new OperationContext(GetTimeout(options?.Timeout), cancellationToken);
             try
             {
                 if (_currentTransaction.IsEmpty)
@@ -192,12 +195,15 @@ public bool IsInTransaction
         }
 
         /// <inheritdoc />
-        public async Task AbortTransactionAsync(CancellationToken cancellationToken = default(CancellationToken))
+        public Task AbortTransactionAsync(CancellationToken cancellationToken = default)
+            => AbortTransactionAsync(null, cancellationToken);
+
+        // TODO: CSOT: Make it public when CSOT will be ready for GA
+        internal async Task AbortTransactionAsync(AbortTransactionOptions options, CancellationToken cancellationToken = default)
         {
             EnsureAbortTransactionCanBeCalled(nameof(AbortTransaction));
 
-            // TODO: CSOT implement proper way to obtain the operationContext
-            var operationContext = new OperationContext(null, cancellationToken);
+            using var operationContext = new OperationContext(GetTimeout(options?.Timeout), cancellationToken);
             try
             {
                 if (_currentTransaction.IsEmpty)
@@ -292,12 +298,15 @@ public long AdvanceTransactionNumber()
         }
 
         /// <inheritdoc />
-        public void CommitTransaction(CancellationToken cancellationToken = default(CancellationToken))
+        public void CommitTransaction(CancellationToken cancellationToken = default)
+            => CommitTransaction(null, cancellationToken);
+
+        // TODO: CSOT: Make it public when CSOT will be ready for GA
+        internal void CommitTransaction(CommitTransactionOptions options, CancellationToken cancellationToken = default)
         {
             EnsureCommitTransactionCanBeCalled(nameof(CommitTransaction));
 
-            // TODO: CSOT implement proper way to obtain the operationContext
-            var operationContext = new OperationContext(null, cancellationToken);
+            using var operationContext = new OperationContext(GetTimeout(options?.Timeout), cancellationToken);
             try
             {
                 _isCommitTransactionInProgress = true;
@@ -329,12 +338,15 @@ public long AdvanceTransactionNumber()
         }
 
         /// <inheritdoc />
-        public async Task CommitTransactionAsync(CancellationToken cancellationToken = default(CancellationToken))
+        public Task CommitTransactionAsync(CancellationToken cancellationToken = default)
+            => CommitTransactionAsync(null, cancellationToken);
+
+        // TODO: CSOT: Make it public when CSOT will be ready for GA
+        internal async Task CommitTransactionAsync(CommitTransactionOptions options, CancellationToken cancellationToken = default(CancellationToken))
         {
             EnsureCommitTransactionCanBeCalled(nameof(CommitTransaction));
 
-            // TODO: CSOT implement proper way to obtain the operationContext
-            var operationContext = new OperationContext(null, cancellationToken);
+            using var operationContext = new OperationContext(GetTimeout(options?.Timeout), cancellationToken);
             try
             {
                 _isCommitTransactionInProgress = true;
@@ -563,6 +575,9 @@ private async Task<TResult> ExecuteEndTransactionOnPrimaryAsync<TResult>(Operati
             }
         }
 
+        private TimeSpan? GetTimeout(TimeSpan? timeout)
+            => timeout ?? _options.DefaultTransactionOptions?.Timeout;
+
         private TransactionOptions GetEffectiveTransactionOptions(TransactionOptions transactionOptions)
         {
             var readConcern = transactionOptions?.ReadConcern ?? _options.DefaultTransactionOptions?.ReadConcern ?? ReadConcern.Default;

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

@@ -1,4 +1,4 @@
-/* Copyright 2018-present MongoDB Inc.
+/* Copyright 2010-present MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -56,6 +56,8 @@ public CoreTransaction(long transactionNumber, TransactionOptions transactionOpt
         /// </value>
         public bool IsEmpty => _isEmpty;
 
+        internal OperationContext OperationContext { get; set; }
+
         /// <summary>
         /// Gets the transaction state.
         /// </summary>

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

@@ -0,0 +1,137 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MongoDB.Driver.Core.Bindings
+{
+    // TODO: CSOT: Make it public when CSOT will be ready for GA
+    internal static class ICoreSessionExtensions
+    {
+        // TODO: CSOT: Merge this extension methods in ICoreSession interface on major release
+        /// <summary>
+        /// Aborts the transaction.
+        /// </summary>
+        /// <param name="session">The session.</param>
+        /// <param name="options">Abort transaction options.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static void AbortTransaction(this ICoreSession session, AbortTransactionOptions options, CancellationToken cancellationToken = default)
+        {
+            if (options == null || session.Options.DefaultTransactionOptions?.Timeout == options.Timeout)
+            {
+                session.AbortTransaction(cancellationToken);
+                return;
+            }
+
+            if (session is CoreSession coreSession)
+            {
+                coreSession.AbortTransaction(options, cancellationToken);
+                return;
+            }
+
+            if (session is WrappingCoreSession wrappingCoreSession)
+            {
+                wrappingCoreSession.AbortTransaction(options, cancellationToken);
+                return;
+            }
+
+            throw new InvalidOperationException("Cannot apply options on non CoreSession.");
+        }
+
+        /// <summary>
+        /// Aborts the transaction.
+        /// </summary>
+        /// <param name="session">The session.</param>
+        /// <param name="options">Abort transaction options.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static Task AbortTransactionAsync(this ICoreSession session, AbortTransactionOptions options, CancellationToken cancellationToken = default)
+        {
+            if (options == null || session.Options.DefaultTransactionOptions?.Timeout == options.Timeout)
+            {
+                return session.AbortTransactionAsync(cancellationToken);
+            }
+
+            if (session is CoreSession coreSession)
+            {
+                return coreSession.AbortTransactionAsync(options, cancellationToken);
+            }
+
+            if (session is WrappingCoreSession wrappingCoreSession)
+            {
+                return wrappingCoreSession.AbortTransactionAsync(options, cancellationToken);
+            }
+
+            throw new InvalidOperationException("Cannot apply options on non CoreSession.");
+        }
+
+        /// <summary>
+        /// Commits the transaction.
+        /// </summary>
+        /// <param name="session">The session.</param>
+        /// <param name="options">Commit transaction options.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static void CommitTransaction(this ICoreSession session, CommitTransactionOptions options, CancellationToken cancellationToken = default)
+        {
+            if (options == null || session.Options.DefaultTransactionOptions?.Timeout == options.Timeout)
+            {
+                session.CommitTransaction(cancellationToken);
+                return;
+            }
+
+            if (session is CoreSession coreSession)
+            {
+                coreSession.CommitTransaction(options, cancellationToken);
+                return;
+            }
+
+            if (session is WrappingCoreSession wrappingCoreSession)
+            {
+                wrappingCoreSession.CommitTransaction(options, cancellationToken);
+                return;
+            }
+
+            throw new InvalidOperationException("Cannot apply options on non CoreSession.");
+        }
+
+        /// <summary>
+        /// Commits the transaction.
+        /// </summary>
+        /// <param name="session">The session.</param>
+        /// <param name="options">Commit transaction options.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        public static Task CommitTransactionAsync(this ICoreSession session, CommitTransactionOptions options, CancellationToken cancellationToken = default)
+        {
+            if (options == null || session.Options.DefaultTransactionOptions?.Timeout == options.Timeout)
+            {
+                return session.CommitTransactionAsync(cancellationToken);
+            }
+
+            if (session is CoreSession coreSession)
+            {
+                return coreSession.CommitTransactionAsync(options, cancellationToken);
+            }
+
+            if (session is WrappingCoreSession wrappingCoreSession)
+            {
+                return wrappingCoreSession.CommitTransactionAsync(options, cancellationToken);
+            }
+
+            throw new InvalidOperationException("Cannot apply options on non CoreSession.");
+        }
+    }
+}
+