rustfmt

src/clients/cache/memcache/mod.rs

@@ -1,5 +1,5 @@
-use crate::clients::ResponseError;
 use super::*;
+use crate::clients::ResponseError;
 use crate::net::Connector;
 use protocol_memcache::{Compose, Parse, Request, Response, Ttl};
 use session::{Buf, BufMut, Buffer};

src/clients/cache/mod.rs

@@ -30,18 +30,12 @@ pub fn launch(
         .expect("failed to initialize tokio runtime");
 
     match config.general().protocol() {
-        Protocol::Memcache => {
-            memcache::launch_tasks(&mut client_rt, config.clone(), work_receiver)
-        }
-        Protocol::Momento => {
-            momento::launch_tasks(&mut client_rt, config.clone(), work_receiver)
-        }
+        Protocol::Memcache => memcache::launch_tasks(&mut client_rt, config.clone(), work_receiver),
+        Protocol::Momento => momento::launch_tasks(&mut client_rt, config.clone(), work_receiver),
         Protocol::Ping => {
             crate::clients::ping::ascii::launch_tasks(&mut client_rt, config.clone(), work_receiver)
         }
-        Protocol::Resp => {
-            redis::launch_tasks(&mut client_rt, config.clone(), work_receiver)
-        }
+        Protocol::Resp => redis::launch_tasks(&mut client_rt, config.clone(), work_receiver),
         protocol => {
             error!("keyspace is not supported for the {:?} protocol", protocol);
             std::process::exit(1);

src/clients/mod.rs

@@ -25,4 +25,4 @@ impl From<MomentoError> for ResponseError {
             _ => ResponseError::Exception,
         }
     }
-}
+}

src/clients/ping/ascii.rs

@@ -1,18 +1,18 @@
-use std::io::ErrorKind;
 use crate::clients::*;
-use tokio::io::AsyncReadExt;
-use tokio::io::AsyncWriteExt;
-use std::time::Instant;
-use std::io::{Error, Result};
-use tokio::time::timeout;
+use crate::net::Connector;
 use crate::workload::*;
-use async_channel::Receiver;
-use tokio::runtime::Runtime;
 use crate::*;
-use crate::net::Connector;
+use async_channel::Receiver;
 use protocol_ping::{Compose, Parse, Request, Response};
 use session::{Buf, BufMut, Buffer};
 use std::borrow::{Borrow, BorrowMut};
+use std::io::ErrorKind;
+use std::io::{Error, Result};
+use std::time::Instant;
+use tokio::io::AsyncReadExt;
+use tokio::io::AsyncWriteExt;
+use tokio::runtime::Runtime;
+use tokio::time::timeout;
 
 /// Launch tasks with one conncetion per task as ping protocol is not mux-enabled.
 pub fn launch_tasks(

src/clients/ping/mod.rs

@@ -1 +1 @@
-pub mod ascii;
+pub mod ascii;

src/clients/pubsub/mod.rs

@@ -152,7 +152,10 @@ fn launch_publishers(
             kafka::launch_publishers(&mut publisher_rt, config.clone(), work_receiver);
         }
         protocol => {
-            error!("pubsub is not supported for the selected protocol: {:?}", protocol);
+            error!(
+                "pubsub is not supported for the selected protocol: {:?}",
+                protocol
+            );
             std::process::exit(1);
         }
     }

src/clients/pubsub/momento.rs

@@ -1,8 +1,8 @@
 use crate::clients::pubsub::*;
-use async_channel::Receiver;
+use crate::clients::*;
 use crate::workload::*;
+use async_channel::Receiver;
 use tokio::runtime::Runtime;
-use crate::clients::*;
 
 use ::momento::topics::configurations::LowLatency;
 use ::momento::topics::{TopicClient, ValueKind};

src/clients/store/mod.rs

@@ -28,7 +28,10 @@ pub fn launch(
     match config.general().protocol() {
         Protocol::Momento => momento::launch_tasks(&mut client_rt, config.clone(), work_receiver),
         protocol => {
-            error!("store commands are not supported for the {:?} protocol", protocol);
+            error!(
+                "store commands are not supported for the {:?} protocol",
+                protocol
+            );
             std::process::exit(1);
         }
     }

src/clients/store/momento.rs

@@ -1,18 +1,18 @@
 use crate::clients::*;
-use crate::*;
 use crate::workload::*;
+use crate::*;
 
-use async_channel::Receiver;
-use tokio::runtime::Runtime;
 use ::momento::storage::configurations::LowLatency;
+use ::momento::storage::PutRequest;
 use ::momento::*;
+use async_channel::Receiver;
 use paste::paste;
-use ::momento::storage::PutRequest;
 use storage::GetResponse;
+use tokio::runtime::Runtime;
 use tokio::time::timeout;
 
-use std::time::Instant;
 use std::io::{Error, Result};
+use std::time::Instant;
 
 /// Launch tasks with one channel per task as gRPC is mux-enabled.
 pub fn launch_tasks(

src/main.rs

@@ -168,7 +168,8 @@ fn main() {
     let store_runtime = clients::store::launch(&config, store_receiver);
 
     // start publisher(s) and subscriber(s)
-    let mut pubsub_runtimes = clients::pubsub::launch(&config, pubsub_receiver, &workload_components);
+    let mut pubsub_runtimes =
+        clients::pubsub::launch(&config, pubsub_receiver, &workload_components);
 
     // start ratelimit controller thread if a dynamic ratelimit is configured
     {