rustfmt

Author: abr-egn

src/cmap/establish/mod.rs

@@ -11,7 +11,7 @@ use super::{
 };
 use crate::{
     client::{auth::Credential, options::ServerApi},
-    error::{ErrorKind, Error as MongoError},
+    error::{Error as MongoError, ErrorKind},
     runtime::HttpClient,
     sdam::HandshakePhase,
 };
@@ -48,17 +48,20 @@ impl ConnectionEstablisher {
         pending_connection: PendingConnection,
     ) -> std::result::Result<Connection, EstablishError> {
         let pool_gen = pending_connection.generation.clone();
-        let mut connection = Connection::connect(pending_connection).await.map_err(|e| EstablishError::pre_hello(e, pool_gen.clone()))?;
+        let mut connection = Connection::connect(pending_connection)
+            .await
+            .map_err(|e| EstablishError::pre_hello(e, pool_gen.clone()))?;
 
-        let handshake = self.handshaker.handshake(&mut connection).await.map_err(|e| EstablishError::pre_hello(e, pool_gen.clone()))?;
+        let handshake = self
+            .handshaker
+            .handshake(&mut connection)
+            .await
+            .map_err(|e| EstablishError::pre_hello(e, pool_gen.clone()))?;
         let service_id = handshake.is_master_reply.command_response.service_id;
 
         // If the handshake response had a `serviceId` field, this is a connection to a load
         // balancer and must derive its generation from the service_generations map.
-        match (
-            pool_gen,
-            service_id,
-        ) {
+        match (pool_gen, service_id) {
             (PoolGeneration::Normal(_), _) => {}
             (PoolGeneration::LoadBalanced(gen_map), Some(service_id)) => {
                 connection.generation = ConnectionGeneration::LoadBalanced {
@@ -70,7 +73,8 @@ impl ConnectionEstablisher {
                 return Err(EstablishError::post_hello(
                     ErrorKind::Internal {
                         message: "load-balanced mode mismatch".to_string(),
-                    }.into(),
+                    }
+                    .into(),
                     connection.generation.clone(),
                 ));
             }
@@ -112,4 +116,4 @@ impl EstablishError {
             handshake_phase: HandshakePhase::PostHello { generation },
         }
     }
-}
+}

src/cmap/mod.rs

@@ -16,7 +16,7 @@ use derivative::Derivative;
 pub use self::conn::ConnectionInfo;
 pub(crate) use self::{
     conn::{Command, Connection, RawCommand, RawCommandResponse, StreamDescription},
-    establish::{EstablishError, handshake::Handshaker},
+    establish::{handshake::Handshaker, EstablishError},
     status::PoolGenerationSubscriber,
     worker::PoolGeneration,
 };

src/sdam/description/topology/test/sdam.rs

@@ -284,11 +284,9 @@ async fn run_test(test_file: TestFile) {
                     .unwrap_or(0);
                 let conn_generation = ConnectionGeneration::Normal(conn_generation);
                 let handshake_phase = match application_error.when {
-                    ErrorHandshakePhase::BeforeHandshakeCompletes => {
-                        HandshakePhase::PreHello {
-                            generation: pool_generation,
-                        }
-                    }
+                    ErrorHandshakePhase::BeforeHandshakeCompletes => HandshakePhase::PreHello {
+                        generation: pool_generation,
+                    },
                     ErrorHandshakePhase::AfterHandshakeCompletes => {
                         HandshakePhase::AfterCompletion {
                             generation: conn_generation,

src/sdam/monitor.rs

@@ -241,15 +241,9 @@ impl UpdateMonitor {
             };
 
             match update.into_message() {
-                ServerUpdate::Error {
-                    error,
-                } => {
+                ServerUpdate::Error { error } => {
                     topology
-                        .handle_application_error(
-                            error.cause,
-                            error.handshake_phase,
-                            &server,
-                        )
+                        .handle_application_error(error.cause, error.handshake_phase, &server)
                         .await;
                 }
             }

src/sdam/state/mod.rs

@@ -261,12 +261,14 @@ impl Topology {
                         }
                     }
                     // Pre-hello handshake errors are ignored in load-balanced mode.
-                    (PoolGeneration::LoadBalanced(_), PoolGeneration::LoadBalanced(_)) => return false,
+                    (PoolGeneration::LoadBalanced(_), PoolGeneration::LoadBalanced(_)) => {
+                        return false
+                    }
                     _ => {} // TODO RUST-230 Log an error for mode mismatch.
                 }
             }
-            HandshakePhase::PostHello { generation } |
-            HandshakePhase::AfterCompletion { generation, .. } => {
+            HandshakePhase::PostHello { generation }
+            | HandshakePhase::AfterCompletion { generation, .. } => {
                 if generation.is_stale(&server.pool.generation()) {
                     return false;
                 }

src/sdam/state/server.rs

@@ -8,7 +8,7 @@ use crate::{
     cmap::{options::ConnectionPoolOptions, ConnectionPool, EstablishError},
     options::{ClientOptions, ServerAddress},
     runtime::{AcknowledgedMessage, HttpClient},
-    sdam::{monitor::Monitor},
+    sdam::monitor::Monitor,
 };
 
 /// Contains the state for a given server in the topology.
@@ -73,9 +73,7 @@ impl Server {
 /// TODO: add success cases from application handshakes.
 #[derive(Debug)]
 pub(crate) enum ServerUpdate {
-    Error {
-        error: EstablishError,
-    },
+    Error { error: EstablishError },
 }
 
 #[derive(Debug)]
@@ -108,9 +106,7 @@ impl ServerUpdateSender {
     /// Update the server based on the given error.
     /// This will block until the topology has processed the error.
     pub(crate) async fn handle_error(&mut self, error: EstablishError) {
-        let reason = ServerUpdate::Error {
-            error,
-        };
+        let reason = ServerUpdate::Error { error };
 
         let (message, callback) = AcknowledgedMessage::package(reason);
         // These only fails if the other ends hang up, which means the monitor is