POC Exposing SnapshotTime

Author: papafe

src/MongoDB.Driver/ClientSessionHandle.cs

@@ -89,6 +89,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,11 @@ public class ClientSessionOptions
         /// </value>
         public bool Snapshot { get; set;}
 
+        /// <summary>
+        /// //TODO
+        /// </summary>
+        public BsonTimestamp SnapshotTime { get; set; }
+
         // internal methods
         internal CoreSessionOptions ToCore(bool isImplicit = false)
         {
@@ -55,7 +61,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,8 +13,11 @@
 * limitations under the License.
 */
 
+using MongoDB.Bson;
+
 namespace MongoDB.Driver.Core.Bindings
 {
+    //TODO Why is this class public?
     /// <summary>
     /// Core session options.
     /// </summary>
@@ -25,6 +28,7 @@ public class CoreSessionOptions
         private readonly bool _isCausallyConsistent;
         private readonly bool _isImplicit;
         private readonly bool _isSnapshot;
+        private readonly BsonTimestamp _snapshotTime;
 
         // constructors
         /// <summary>
@@ -34,16 +38,19 @@ public class CoreSessionOptions
         /// <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">//TODO</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;
         }
 
         // public properties
@@ -78,5 +85,10 @@ public CoreSessionOptions(
         ///   <c>true</c> if this session is a snapshot session; otherwise, <c>false</c>.
         /// </value>
         public bool IsSnapshot => _isSnapshot;
+
+        /// <summary>
+        /// //TODO
+        /// </summary>
+        public BsonTimestamp SnapshotTime => _snapshotTime;
     }
 }

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

@@ -40,7 +40,7 @@ public static BsonDocument GetReadConcernForSnapshotSession(ICoreSession session
                 Feature.SnapshotReads.ThrowIfNotSupported(connectionDescription.MaxWireVersion);
 
                 var readConcernDocument = ReadConcern.Snapshot.ToBsonDocument();
-                if (session.SnapshotTime != null)
+                if (session.SnapshotTime != null)  // For the first read within a snapshot session, SnapshotTime will be null
                 {
                     readConcernDocument.Add("atClusterTime", session.SnapshotTime);
                 }

src/MongoDB.Driver/IClientSession.cs

@@ -83,6 +83,11 @@ public interface IClientSession : IDisposable
         /// </value>
         IServerSession ServerSession { get; }
 
+        /// <summary>
+        /// //TODO
+        /// </summary>
+        BsonTimestamp SnapshotTime { get; }
+
         /// <summary>
         /// Gets the wrapped core session (intended for internal use only).
         /// </summary>

src/MongoDB.Driver/MongoClient.cs

@@ -627,6 +627,8 @@ private IClientSessionHandle StartSession(ClientSessionOptions options)
                 throw new NotSupportedException("Combining both causal consistency and snapshot options is not supported.");
             }
 
+            //TODO Throw an exception if SnapshotTime is set and Snapshot is not true.
+
             options ??= new ClientSessionOptions();
             if (_settings.Timeout.HasValue && options.DefaultTransactionOptions?.Timeout == null)
             {

tests/MongoDB.Driver.Tests/AtClusterTimeTests.cs

@@ -0,0 +1,112 @@
+/* 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.Collections.Generic;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+using Xunit;
+
+namespace MongoDB.Driver.Tests;
+
+public class AtClusterTimeTests
+{
+    [Fact]
+    public void AtClusterTime_should_work()
+    {
+        const string collectionName = "atClusterTimeTests";
+        const string databaseName = "testDb";
+
+        using var client = DriverTestConfiguration.Client;
+        var database = client.GetDatabase(databaseName);
+        database.DropCollection(collectionName);
+        var collection = database.GetCollection<TestObject>(collectionName);
+
+        var obj1 = new TestObject { Name = "obj1" };
+        collection.InsertOne(obj1);
+
+        BsonTimestamp clusterTime1;
+
+        var filterDefinition = Builders<TestObject>.Filter.Empty;
+        var sortDefinition = Builders<TestObject>.Sort.Ascending(o => o.Name);
+
+        var sessionOptions1 = new ClientSessionOptions
+        {
+            Snapshot = true
+        };
+
+        using (var session1 = client.StartSession(sessionOptions1))
+        {
+            var results = collection.Find(session1, filterDefinition).Sort(sortDefinition).ToList();
+            AssertOneObj(results);
+
+            clusterTime1 = session1.SnapshotTime;
+            Assert.NotEqual(null, clusterTime1);
+        }
+
+        var obj2 = new TestObject { Name = "obj2" };
+        collection.InsertOne(obj2);
+
+        var sessionOptions2 = new ClientSessionOptions
+        {
+            Snapshot = true,
+            SnapshotTime = clusterTime1
+        };
+
+        //Snapshot read session at clusterTime1 should not see obj2
+        using (var session2 = client.StartSession(sessionOptions2))
+        {
+            var results = collection.Find(session2, filterDefinition).Sort(sortDefinition).ToList();
+            AssertOneObj(results);
+
+            var clusterTime2 = session2.SnapshotTime;
+            Assert.Equal(clusterTime2, clusterTime1);
+        }
+
+        var sessionOptions3 = new ClientSessionOptions
+        {
+            Snapshot = true,
+        };
+
+        //Snapshot read session without cluster time should see obj2
+        using (var session3 = client.StartSession(sessionOptions3))
+        {
+            var results = collection.Find(session3, filterDefinition).Sort(sortDefinition).ToList();
+            AssertTwoObjs(results);
+
+            var clusterTime3 = session3.WrappedCoreSession.SnapshotTime;
+            Assert.NotEqual(clusterTime3, clusterTime1);
+        }
+
+        void AssertOneObj(List<TestObject> objs)
+        {
+            Assert.Equal(1, objs.Count);
+            Assert.Equal("obj1", objs[0].Name);
+        }
+
+        void AssertTwoObjs(List<TestObject> objs)
+        {
+            Assert.Equal(2, objs.Count);
+            Assert.Equal("obj1", objs[0].Name);
+            Assert.Equal("obj2", objs[1].Name);
+        }
+    }
+
+    private class TestObject
+    {
+        [BsonId]
+        public ObjectId Id { get; set; }
+        public string Name { get; set; }
+    }
+}