CSHARP-5736: Expose atClusterTime parameter in snapshot sessions

src/MongoDB.Driver/ClientSessionHandle.cs

@@ -91,6 +91,8 @@ public IServerSession ServerSession
             }
         }
 
+        public BsonTimestamp SnapshotTime => _coreSession.SnapshotTime;
+
         /// <inheritdoc />
         public ICoreSessionHandle WrappedCoreSession => _coreSession;
 

src/MongoDB.Driver/ClientSessionOptions.cs

@@ -14,6 +14,7 @@
 */
 
 using System;
+using MongoDB.Bson;
 using MongoDB.Driver.Core.Bindings;
 
 namespace MongoDB.Driver
@@ -46,6 +47,12 @@ public class ClientSessionOptions
         /// </value>
         public bool Snapshot { get; set;}
 
+        /// <summary>
+        /// Gets or sets the snapshot time. If set, Snapshot must be true.
+        /// </summary>
+        /// <value> The snapshot time. </value>
+        public BsonTimestamp SnapshotTime { get; set; }
+
         // internal methods
         internal CoreSessionOptions ToCore(bool isImplicit = false)
         {
@@ -55,7 +62,8 @@ internal CoreSessionOptions ToCore(bool isImplicit = false)
                 isCausallyConsistent: isCausallyConsistent,
                 isImplicit: isImplicit,
                 isSnapshot: Snapshot,
-                defaultTransactionOptions: DefaultTransactionOptions);
+                defaultTransactionOptions: DefaultTransactionOptions,
+                snapshotTime: SnapshotTime);
         }
     }
 }

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

@@ -71,6 +71,7 @@ private CoreSession(
         {
             _cluster = Ensure.IsNotNull(cluster, nameof(cluster));
             _options = Ensure.IsNotNull(options, nameof(options));
+            _snapshotTime = options.SnapshotTime;
         }
 
         // public properties

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

@@ -13,6 +13,9 @@
 * limitations under the License.
 */
 
+using MongoDB.Bson;
+using MongoDB.Driver.Core.Misc;
+
 namespace MongoDB.Driver.Core.Bindings
 {
     /// <summary>
@@ -25,25 +28,45 @@ public class CoreSessionOptions
         private readonly bool _isCausallyConsistent;
         private readonly bool _isImplicit;
         private readonly bool _isSnapshot;
+        private readonly BsonTimestamp _snapshotTime;
 
         // constructors
         /// <summary>
         /// Initializes a new instance of the <see cref="CoreSessionOptions" /> class.
         /// </summary>
-        /// <param name="isCausallyConsistent">if set to <c>true</c> this session is causally consistent]</param>
+        /// <param name="isCausallyConsistent">if set to <c>true</c> this session is causally consistent</param>
         /// <param name="isImplicit">if set to <c>true</c> this session is an implicit session.</param>
         /// <param name="isSnapshot">if set to <c>true</c> this session is a snapshot session.</param>
         /// <param name="defaultTransactionOptions">The default transaction options.</param>
+        /// <param name="snapshotTime">The snapshot time. If this is set, isSnapshot must be true.</param>
         public CoreSessionOptions(
             bool isCausallyConsistent = false,
             bool isImplicit = false,
             TransactionOptions defaultTransactionOptions = null,
-            bool isSnapshot = false)
+            bool isSnapshot = false,
+            BsonTimestamp snapshotTime = null)
         {
             _isCausallyConsistent = isCausallyConsistent;
             _isImplicit = isImplicit;
             _isSnapshot = isSnapshot;
             _defaultTransactionOptions = defaultTransactionOptions;
+            _snapshotTime = snapshotTime;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CoreSessionOptions" /> class.
+        /// </summary>
+        /// <param name="isCausallyConsistent">if set to <c>true</c> this session is causally consistent</param>
+        /// <param name="isImplicit">if set to <c>true</c> this session is an implicit session.</param>
+        /// <param name="isSnapshot">if set to <c>true</c> this session is a snapshot session.</param>
+        /// <param name="defaultTransactionOptions">The default transaction options.</param>
+        public CoreSessionOptions(
+            bool isCausallyConsistent,
+            bool isImplicit,
+            TransactionOptions defaultTransactionOptions,
+            bool isSnapshot)
+        : this(isCausallyConsistent, isImplicit, defaultTransactionOptions, isSnapshot, null)
+        {
         }
 
         // public properties
@@ -78,5 +101,13 @@ public CoreSessionOptions(
         ///   <c>true</c> if this session is a snapshot session; otherwise, <c>false</c>.
         /// </value>
         public bool IsSnapshot => _isSnapshot;
+
+        /// <summary>
+        /// Gets the snapshot time for snapshot sessions.
+        /// </summary>
+        /// <value>
+        /// The snapshot time as a <see cref="BsonTimestamp"/>, or <c>null</c> if not set.
+        /// </value>
+        public BsonTimestamp SnapshotTime => _snapshotTime;
     }
 }

src/MongoDB.Driver/IClientSessionExtensions.cs

@@ -13,16 +13,35 @@
  * limitations under the License.
  */
 
+using System;
 using System.Threading;
 using System.Threading.Tasks;
+using MongoDB.Bson;
 
 namespace MongoDB.Driver
 {
-    // TODO: CSOT: Make it public when CSOT will be ready for GA
-    internal static class IClientSessionExtensions
+    /// <summary>
+    /// Extension methods for <see cref="IClientSession"/>.
+    /// </summary>
+    public static class IClientSessionExtensions
     {
+        /// <summary>
+        /// Gets the snapshot time for a snapshot session.
+        /// </summary>
+        /// <param name="session">The client session handle.</param>
+        /// <returns>The snapshot time as a <see cref="BsonTimestamp"/>.</returns>
+        /// <exception cref="InvalidOperationException">Thrown when the session is not a snapshot session.</exception>
+        public static BsonTimestamp GetSnapshotTime(this IClientSession session)
+        {
+            var clientSessionHandle = (ClientSessionHandle)session;
+            return clientSessionHandle.WrappedCoreSession.IsSnapshot ?
+                clientSessionHandle.SnapshotTime
+                : throw new InvalidOperationException("Cannot retrieve snapshot time from a non-snapshot session.");
+        }
+
+        // TODO: CSOT: Make the following methods public when CSOT will be ready for GA
         // TODO: Merge these extension methods in IClientSession interface on major release
-        public static void AbortTransaction(this IClientSession session, AbortTransactionOptions options, CancellationToken cancellationToken = default)
+        internal static void AbortTransaction(this IClientSession session, AbortTransactionOptions options, CancellationToken cancellationToken = default)
         {
             if (options?.Timeout == null || session.Options.DefaultTransactionOptions?.Timeout == options.Timeout)
             {
@@ -33,7 +52,7 @@ public static void AbortTransaction(this IClientSession session, AbortTransactio
             ((IClientSessionInternal)session).AbortTransaction(options, cancellationToken);
         }
 
-        public static Task AbortTransactionAsync(this IClientSession session, AbortTransactionOptions options, CancellationToken cancellationToken = default)
+        internal static Task AbortTransactionAsync(this IClientSession session, AbortTransactionOptions options, CancellationToken cancellationToken = default)
         {
             if (options?.Timeout == null || session.Options.DefaultTransactionOptions?.Timeout == options.Timeout)
             {
@@ -43,7 +62,7 @@ public static Task AbortTransactionAsync(this IClientSession session, AbortTrans
             return ((IClientSessionInternal)session).AbortTransactionAsync(options, cancellationToken);
         }
 
-        public static void CommitTransaction(this IClientSession session, CommitTransactionOptions options, CancellationToken cancellationToken = default)
+        internal static void CommitTransaction(this IClientSession session, CommitTransactionOptions options, CancellationToken cancellationToken = default)
         {
             if (options?.Timeout == null || session.Options.DefaultTransactionOptions?.Timeout == options.Timeout)
             {
@@ -54,7 +73,7 @@ public static void CommitTransaction(this IClientSession session, CommitTransact
             ((IClientSessionInternal)session).CommitTransaction(options, cancellationToken);
         }
 
-        public static Task CommitTransactionAsync(this IClientSession session, CommitTransactionOptions options, CancellationToken cancellationToken = default)
+        internal static Task CommitTransactionAsync(this IClientSession session, CommitTransactionOptions options, CancellationToken cancellationToken = default)
         {
             if (options?.Timeout == null || session.Options.DefaultTransactionOptions?.Timeout == options.Timeout)
             {

src/MongoDB.Driver/MongoClient.cs

@@ -622,9 +622,17 @@ private RenderArgs<BsonDocument> GetRenderArgs()
 
         private IClientSessionHandle StartSession(ClientSessionOptions options)
         {
-            if (options != null && options.Snapshot && options.CausalConsistency == true)
+            if (options != null)
             {
-                throw new NotSupportedException("Combining both causal consistency and snapshot options is not supported.");
+                if (options.SnapshotTime != null && !options.Snapshot)
+                {
+                    throw new InvalidOperationException("Specifying a snapshot time requires snapshot to be true.");
+                }
+
+                if (options.Snapshot && options.CausalConsistency == true)
+                {
+                    throw new NotSupportedException("Combining both causal consistency and snapshot options is not supported.");
+                }
             }
 
             options ??= new ClientSessionOptions();

tests/MongoDB.Driver.Tests/ClientSessionExtensionsTests.cs

@@ -13,8 +13,10 @@
  * limitations under the License.
  */
 
+using System;
 using System.Collections.Generic;
 using FluentAssertions;
+using MongoDB.Bson;
 using MongoDB.Driver.Core.Bindings;
 using Moq;
 using Xunit;
@@ -35,6 +37,41 @@ public void GetEffectiveReadPreferenceTests(
             result.Should().Be(expectedReadPreference);
         }
 
+        [Fact]
+        public void GetSnapshotTime_on_snapshot_session_returns_expected_value()
+        {
+            var snapshotTime = new BsonTimestamp(1234567890, 1);
+            var coreSessionMock = new Mock<ICoreSessionHandle>();
+            coreSessionMock.SetupGet(s => s.IsSnapshot).Returns(true);
+            coreSessionMock.SetupGet(s => s.SnapshotTime).Returns(snapshotTime);
+
+            var session = new ClientSessionHandle(
+                Mock.Of<IMongoClient>(),
+                new ClientSessionOptions(),
+                coreSessionMock.Object);
+
+            var result = session.GetSnapshotTime();
+
+            result.Should().Be(snapshotTime);
+        }
+
+        [Fact]
+        public void GetSnapshotTime_on_non_snapshot_session_throws_InvalidOperationException()
+        {
+            var coreSessionMock = new Mock<ICoreSessionHandle>();
+            coreSessionMock.SetupGet(s => s.IsSnapshot).Returns(false);
+
+            var session = new ClientSessionHandle(
+                Mock.Of<IMongoClient>(),
+                new ClientSessionOptions(),
+                coreSessionMock.Object);
+
+            var exception = Record.Exception(() => session.GetSnapshotTime());
+
+            exception.Should().BeOfType<InvalidOperationException>();
+            exception.Message.Should().Contain("non-snapshot session");
+        }
+
         public static IEnumerable<object[]> GetEffectiveReadPreferenceTestCases()
         {
             var noTransactionSession = CreateSessionMock(null);

tests/MongoDB.Driver.Tests/ClientSessionHandleTests.cs

@@ -155,6 +155,19 @@ public void ServerSession_returns_expected_result()
             result.Should().BeSameAs(subject._serverSession());
         }
 
+        [Fact]
+        public void SnapshotTime_returns_expected_result()
+        {
+            var subject = CreateSubject();
+            var value = new BsonTimestamp(1234567890, 1);
+            var mockCoreSession = Mock.Get(subject.WrappedCoreSession);
+            mockCoreSession.SetupGet(m => m.SnapshotTime).Returns(value);
+
+            var result = subject.SnapshotTime;
+
+            result.Should().BeSameAs(value);
+        }
+
         [Fact]
         public void WrappedCoreSession_returns_expected_result()
         {

tests/MongoDB.Driver.Tests/ClientSessionOptionsTests.cs

@@ -14,6 +14,7 @@
 */
 
 using FluentAssertions;
+using MongoDB.Bson;
 using MongoDB.TestHelpers.XunitExtensions;
 using Xunit;
 
@@ -79,34 +80,77 @@ public void DefaultTransactionOptions_set_should_have_expected_result(
             subject.DefaultTransactionOptions.Should().BeSameAs(value);
         }
 
+        [Theory]
+        [ParameterAttributeData]
+        public void SnapshotTime_get_should_return_expected_result(
+            [Values(false, true)] bool nullValue)
+        {
+            var value = nullValue ? null : new BsonTimestamp(1234567890, 1);
+            var subject = CreateSubject(snapshotTime: value);
+
+            var result = subject.SnapshotTime;
+
+            result.Should().Be(value);
+        }
+
+        [Theory]
+        [ParameterAttributeData]
+        public void SnapshotTime_set_should_have_expected_result(
+            [Values(false, true)] bool nullValue)
+        {
+            var subject = CreateSubject();
+            var value = nullValue ? null : new BsonTimestamp(1234567890, 1);
+
+            subject.SnapshotTime = value;
+
+            subject.SnapshotTime.Should().Be(value);
+        }
+
         [Theory]
         [ParameterAttributeData]
         public void ToCore_should_return_expected_result(
             [Values(null, false, true)] bool? causalConsistency,
             [Values(false, true)] bool isImplicit,
-            [Values(false, true)] bool nullDefaultTransactionOptions)
+            [Values(false, true)] bool snapshot,
+            [Values(false, true)] bool nullDefaultTransactionOptions,
+            [Values(false, true)] bool nullSnapshotTime)
         {
+            // Skip invalid combinations: snapshotTime can only be set if snapshot is true
+            if (!snapshot && !nullSnapshotTime)
+            {
+                return;
+            }
+
             var defaultTransactionOptions = nullDefaultTransactionOptions ? null : new TransactionOptions();
+            var snapshotTime = nullSnapshotTime ? null : new BsonTimestamp(1234567890, 1);
             var subject = CreateSubject(
                 causalConsistency: causalConsistency,
-                defaultTransactionOptions: defaultTransactionOptions);
+                defaultTransactionOptions: defaultTransactionOptions,
+                snapshot: snapshot,
+                snapshotTime: snapshotTime);
 
             var result = subject.ToCore(isImplicit: isImplicit);
 
             result.DefaultTransactionOptions.Should().BeSameAs(defaultTransactionOptions);
-            result.IsCausallyConsistent.Should().Be(causalConsistency ?? true);
+            result.IsCausallyConsistent.Should().Be(causalConsistency ?? !snapshot);
             result.IsImplicit.Should().Be(isImplicit);
+            result.IsSnapshot.Should().Be(snapshot);
+            result.SnapshotTime.Should().Be(snapshotTime);
         }
 
         // private methods
         private ClientSessionOptions CreateSubject(
             bool? causalConsistency = null,
-            TransactionOptions defaultTransactionOptions = null)
+            TransactionOptions defaultTransactionOptions = null,
+            bool snapshot = false,
+            BsonTimestamp snapshotTime = null)
         {
             return new ClientSessionOptions
             {
                 CausalConsistency = causalConsistency,
-                DefaultTransactionOptions = defaultTransactionOptions
+                DefaultTransactionOptions = defaultTransactionOptions,
+                Snapshot = snapshot,
+                SnapshotTime = snapshotTime
             };
         }
     }