RUST-734 Document support for sharded transactions

Author: Nathan Blinn

src/client/executor.rs

@@ -88,7 +88,6 @@ impl Client {
                         .into());
                     }
                 }
-
                 self.execute_operation_with_retry(op, Some(session)).await
             }
             None => {

src/client/session/mod.rs

@@ -47,10 +47,10 @@ lazy_static! {
 /// collections atomically. For more information about when and how to use transactions in MongoDB,
 /// see the [manual](https://docs.mongodb.com/manual/core/transactions/).
 ///
-/// Replica set transactions are supported on MongoDB 4.0+. Transactions are associated with a
-/// `ClientSession`. To begin a transaction, call [`ClientSession::start_transaction`] on a
-/// `ClientSession`. The `ClientSession` must be passed to operations to be executed within the
-/// transaction.
+/// Replica set transactions are supported on MongoDB 4.0+. Sharded transactions are supported on
+/// MongoDDB 4.2+. Transactions are associated with a `ClientSession`. To begin a transaction, call
+/// [`ClientSession::start_transaction`] on a `ClientSession`. The `ClientSession` must be passed to
+/// operations to be executed within the transaction.
 ///
 /// ```rust
 /// use mongodb::{
@@ -99,9 +99,6 @@ lazy_static! {
 ///     }
 /// }
 /// ```
-// TODO RUST-734 Remove this note and adjust the above description to indicate that sharded
-// transactions are supported on 4.2+
-/// Note: the driver does not currently support transactions on sharded clusters.
 #[derive(Clone, Debug)]
 pub struct ClientSession {
     cluster_time: Option<ClusterTime>,

src/concern/test.rs

@@ -179,8 +179,9 @@ async fn snapshot_read_concern() {
         .database(function_name!())
         .collection::<Document>(function_name!());
 
-    // TODO RUST-734: Run this test on sharded clusters when transactions are complete.
-    if client.is_replica_set() && client.server_version_gte(4, 0) {
+    if client.is_replica_set() && client.server_version_gte(4, 0)
+        || client.is_sharded() && client.server_version_gte(4, 2)
+    {
         let mut session = client.start_session(None).await.unwrap();
         let options = TransactionOptions::builder()
             .read_concern(ReadConcern::snapshot())

src/sdam/description/topology/mod.rs

@@ -326,8 +326,6 @@ impl TopologyDescription {
             self.transaction_support_status = TransactionSupportStatus::Unsupported;
         }
         if let Ok(Some(max_wire_version)) = server_description.max_wire_version() {
-            // TODO RUST-734: Evaluate whether we should permanently support sharded transactions.
-            //                If we leave the feature as unsupported, we should revert this code.
             self.transaction_support_status = if max_wire_version < 7
                 || (max_wire_version < 8 && self.topology_type == TopologyType::Sharded)
             {
@@ -742,8 +740,8 @@ pub(crate) enum TransactionSupportStatus {
     Unsupported,
 
     /// Transactions are supported by this topology. A topology supports transactions if it
-    /// supports sessions and its maxWireVersion >= 7. Transactions are not currently supported
-    /// on sharded clusters (TODO RUST-734).
+    /// supports sessions and its maxWireVersion >= 7. If the topology is sharded, maxWireVersion
+    /// must be >= 8 for transactions to be supported.
     ///
     /// Note that meeting these conditions does not guarantee that a deployment
     /// supports transactions; any other missing qualification will be reported by the server.

src/sync/test.rs

@@ -202,8 +202,8 @@ fn transactions() {
 
     let should_skip = RUNTIME.block_on(async {
         let test_client = AsyncTestClient::new().await;
-        // TODO RUST-734: Unskip this test on sharded clusters when transactions are complete.
-        !test_client.is_replica_set() || test_client.server_version_lt(4, 0)
+        !(test_client.is_replica_set() && test_client.server_version_gte(4, 0)
+            || test_client.is_sharded() && test_client.server_version_gte(4, 2))
     });
     if should_skip {
         return;