Merge pull request #168 from saghm/format-and-lint

Format and lint

Author: saghm

src/apm/event.rs

@@ -15,8 +15,10 @@ pub struct CommandStarted {
 
 impl Display for CommandStarted {
     fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
-        fmt.write_fmt(format_args!("COMMAND.{} {} STARTED: {}", self.command_name,
-                                   self.connection_string, self.command))
+        fmt.write_fmt(format_args!("COMMAND.{} {} STARTED: {}",
+                                   self.command_name,
+                                   self.connection_string,
+                                   self.command))
     }
 }
 
@@ -35,22 +37,32 @@ pub enum CommandResult<'a> {
         failure: &'a MongoError,
         request_id: i64,
         connection_string: String,
-    }
+    },
 }
 
 impl<'a> Display for CommandResult<'a> {
     fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
         match *self {
-            CommandResult::Success { duration, ref reply, ref command_name, request_id: _,
-                                     ref connection_string } => {
-                fmt.write_fmt(format_args!("COMMAND.{} {} COMPLETED: {} ({} ns)", command_name,
-                                           connection_string, reply,
+            CommandResult::Success { duration,
+                                     ref reply,
+                                     ref command_name,
+                                     ref connection_string,
+                                     .. } => {
+                fmt.write_fmt(format_args!("COMMAND.{} {} COMPLETED: {} ({} ns)",
+                                           command_name,
+                                           connection_string,
+                                           reply,
                                            duration.separated_string()))
-            },
-            CommandResult::Failure { duration, ref command_name, ref failure, request_id: _,
-                                     ref connection_string } => {
-                fmt.write_fmt(format_args!("COMMAND.{} {} FAILURE: {} ({} ns)", command_name,
-                                           connection_string, failure,
+            }
+            CommandResult::Failure { duration,
+                                     ref command_name,
+                                     failure,
+                                     ref connection_string,
+                                     .. } => {
+                fmt.write_fmt(format_args!("COMMAND.{} {} FAILURE: {} ({} ns)",
+                                           command_name,
+                                           connection_string,
+                                           failure,
                                            duration.separated_string()))
             }
         }

src/apm/listener.rs

@@ -18,15 +18,18 @@ pub struct Listener {
 
 impl Listener {
     pub fn new() -> Listener {
-        Listener { no_start_hooks: AtomicBool::new(true),
-                   no_completion_hooks: AtomicBool::new(true),
-                   start_hooks: RwLock::new(vec![]), completion_hooks: RwLock::new(vec![]) }
+        Listener {
+            no_start_hooks: AtomicBool::new(true),
+            no_completion_hooks: AtomicBool::new(true),
+            start_hooks: RwLock::new(vec![]),
+            completion_hooks: RwLock::new(vec![]),
+        }
     }
 
     pub fn add_start_hook(&self, hook: StartHook) -> Result<()> {
         let mut guard = match self.start_hooks.write() {
             Ok(guard) => guard,
-            Err(_) => return Err(Error::PoisonLockError)
+            Err(_) => return Err(Error::PoisonLockError),
         };
 
         self.no_start_hooks.store(false, Ordering::SeqCst);
@@ -36,7 +39,7 @@ impl Listener {
     pub fn add_completion_hook(&self, hook: CompletionHook) -> Result<()> {
         let mut guard = match self.completion_hooks.write() {
             Ok(guard) => guard,
-            Err(_) => return Err(Error::PoisonLockError)
+            Err(_) => return Err(Error::PoisonLockError),
         };
 
         self.no_completion_hooks.store(false, Ordering::SeqCst);
@@ -50,7 +53,7 @@ impl Listener {
 
         let guard = match self.start_hooks.read() {
             Ok(guard) => guard,
-            Err(_) => return Err(Error::PoisonLockError)
+            Err(_) => return Err(Error::PoisonLockError),
         };
 
         for hook in guard.deref().iter() {
@@ -67,7 +70,7 @@ impl Listener {
 
         let guard = match self.completion_hooks.read() {
             Ok(guard) => guard,
-            Err(_) => return Err(Error::PoisonLockError)
+            Err(_) => return Err(Error::PoisonLockError),
         };
 
         for hook in guard.deref().iter() {

src/apm/mod.rs

@@ -1,9 +1,9 @@
 //! Command Monitoring
 //!
-//! The APM module provides an intuitive interface for monitoring and responding to runtime information
-//! about commands being executed on the server. All non-suppressed commands trigger start and completion
-//! hooks defined on the client. Each non-suppressed command is also logged, if a log file was specified
-//! during instantiation of the client.
+//! The APM module provides an intuitive interface for monitoring and responding to runtime
+//! information about commands being executed on the server. All non-suppressed commands trigger
+//! start and completion hooks defined on the client. Each non-suppressed command is also logged,
+//! if a log file was specified during instantiation of the client.
 pub mod client;
 mod event;
 mod listener;

src/auth.rs

@@ -16,9 +16,12 @@ use error::Result;
 use rustc_serialize::base64::{self, FromBase64, ToBase64};
 use textnonce::TextNonce;
 
-const B64_CONFIG : base64::Config = base64::Config { char_set: base64::CharacterSet::Standard,
-                                                     newline: base64::Newline::LF,
-                                                     pad: true, line_length: None };
+const B64_CONFIG: base64::Config = base64::Config {
+    char_set: base64::CharacterSet::Standard,
+    newline: base64::Newline::LF,
+    pad: true,
+    line_length: None,
+};
 
 /// Handles SCRAM-SHA-1 authentication logic.
 pub struct Authenticator {
@@ -57,7 +60,7 @@ impl Authenticator {
     fn start(&self, user: &str) -> Result<InitialData> {
         let text_nonce = match TextNonce::sized(64) {
             Ok(text_nonce) => text_nonce,
-            Err(string) => return Err(DefaultError(string))
+            Err(string) => return Err(DefaultError(string)),
         };
 
         let nonce = format!("{}", text_nonce);
@@ -76,51 +79,59 @@ impl Authenticator {
 
         let data = match doc.get("payload") {
             Some(&Binary(_, ref payload)) => payload.to_owned(),
-            _ => return Err(ResponseError("Invalid payload returned".to_owned()))
+            _ => return Err(ResponseError(String::from("Invalid payload returned"))),
         };
 
         let id = match doc.get("conversationId") {
             Some(bson) => bson.clone(),
-            None => return Err(ResponseError("No conversationId returned".to_owned()))
+            None => return Err(ResponseError(String::from("No conversationId returned"))),
         };
 
         let response = match String::from_utf8(data) {
             Ok(string) => string,
-            Err(_) => return Err(ResponseError("Invalid UTF-8 payload returned".to_owned()))
+            Err(_) => return Err(ResponseError(String::from("Invalid UTF-8 payload returned"))),
         };
 
-        Ok(InitialData { message: message, response: response, nonce: nonce,
-                          conversation_id: id })
+        Ok(InitialData {
+            message: message,
+            response: response,
+            nonce: nonce,
+            conversation_id: id,
+        })
     }
 
     fn next(&self, password: String, initial_data: InitialData) -> Result<AuthData> {
         // Parse out rnonce, salt, and iteration count
-        let (rnonce_opt, salt_opt, i_opt) = scan_fmt!(&initial_data.response[..], "r={},s={},i={}", String, String, u32);
+        let (rnonce_opt, salt_opt, i_opt) = scan_fmt!(&initial_data.response[..],
+                                                      "r={},s={},i={}",
+                                                      String,
+                                                      String,
+                                                      u32);
 
         let rnonce_b64 = match rnonce_opt {
             Some(val) => val,
-            None => return Err(ResponseError("Invalid rnonce returned".to_owned()))
+            None => return Err(ResponseError(String::from("Invalid rnonce returned"))),
         };
 
         // Validate rnonce to make sure server isn't malicious
         if !rnonce_b64.starts_with(&initial_data.nonce[..]) {
-            return Err(MaliciousServerError(MaliciousServerErrorType::InvalidRnonce))
+            return Err(MaliciousServerError(MaliciousServerErrorType::InvalidRnonce));
         }
 
         let salt_b64 = match salt_opt {
             Some(val) => val,
-            None => return Err(ResponseError("Invalid salt returned".to_owned()))
+            None => return Err(ResponseError(String::from("Invalid salt returned"))),
         };
 
         let salt = match salt_b64.from_base64() {
             Ok(val) => val,
-            Err(_) => return Err(ResponseError("Invalid base64 salt returned".to_owned()))
+            Err(_) => return Err(ResponseError(String::from("Invalid base64 salt returned"))),
         };
 
 
         let i = match i_opt {
             Some(val) => val,
-            None => return Err(ResponseError("Invalid iteration count returned".to_owned()))
+            None => return Err(ResponseError(String::from("Invalid iteration count returned"))),
         };
 
         // Hash password
@@ -130,24 +141,27 @@ impl Authenticator {
 
         // Salt password
         let mut hmac = Hmac::new(Sha1::new(), hashed_password.as_bytes());
-        let mut salted_password : Vec<_> = (0..hmac.output_bytes()).map(|_| 0).collect();
+        let mut salted_password: Vec<_> = (0..hmac.output_bytes()).map(|_| 0).collect();
         pbkdf2::pbkdf2(&mut hmac, &salt[..], i, &mut salted_password);
 
         // Compute client key
         let mut client_key_hmac = Hmac::new(Sha1::new(), &salted_password[..]);
-        let client_key_bytes = "Client Key".as_bytes();
+        let client_key_bytes = b"Client Key";
         client_key_hmac.input(client_key_bytes);
         let client_key = client_key_hmac.result().code().to_owned();
 
         // Hash into stored key
         let mut stored_key_sha1 = Sha1::new();
         stored_key_sha1.input(&client_key[..]);
-        let mut stored_key : Vec<_> = (0..stored_key_sha1.output_bytes()).map(|_| 0).collect();
+        let mut stored_key: Vec<_> = (0..stored_key_sha1.output_bytes()).map(|_| 0).collect();
         stored_key_sha1.result(&mut stored_key);
 
         // Create auth message
         let without_proof = format!("c=biws,r={}", rnonce_b64);
-        let auth_message = format!("{},{},{}", initial_data.message, initial_data.response, without_proof);
+        let auth_message = format!("{},{},{}",
+                                   initial_data.message,
+                                   initial_data.response,
+                                   without_proof);
 
         // Compute client signature
         let mut client_signature_hmac = Hmac::new(Sha1::new(), &stored_key[..]);
@@ -156,7 +170,8 @@ impl Authenticator {
 
         // Sanity check
         if client_key.len() != client_signature.len() {
-            return Err(DefaultError("Generated client key and/or client signature is invalid".to_owned()));
+            return Err(DefaultError(String::from("Generated client key and/or client signature \
+                                                  is invalid")));
         }
 
         // Compute proof by xor'ing key and signature
@@ -178,8 +193,11 @@ impl Authenticator {
 
         let response = try!(self.db.command(next_doc, Suppressed, None));
 
-        Ok(AuthData { salted_password: salted_password, message: auth_message,
-                      response: response })
+        Ok(AuthData {
+            salted_password: salted_password,
+            message: auth_message,
+            response: response,
+        })
     }
 
     fn finish(&self, conversation_id: Bson, auth_data: AuthData) -> Result<()> {
@@ -191,7 +209,7 @@ impl Authenticator {
 
         // Compute server key
         let mut server_key_hmac = Hmac::new(Sha1::new(), &auth_data.salted_password[..]);
-        let server_key_bytes = "Server Key".as_bytes();
+        let server_key_bytes = b"Server Key";
         server_key_hmac.input(server_key_bytes);
         let server_key = server_key_hmac.result().code().to_owned();
 
@@ -207,25 +225,29 @@ impl Authenticator {
             if let Some(&Binary(_, ref payload)) = doc.get("payload") {
                 let payload_str = match String::from_utf8(payload.to_owned()) {
                     Ok(string) => string,
-                    Err(_) => return Err(ResponseError("Invalid UTF-8 payload returned".to_owned()))
+                    Err(_) => {
+                        return Err(ResponseError(String::from("Invalid UTF-8 payload returned")))
+                    }
                 };
 
                 // Check that the signature exists
                 let verifier = match scan_fmt!(&payload_str[..], "v={}", String) {
                     Some(string) => string,
-                    None => return Err(MaliciousServerError(MaliciousServerErrorType::NoServerSignature)),
+                    None => return Err(
+                        MaliciousServerError(MaliciousServerErrorType::NoServerSignature)),
                 };
 
                 // Check that the signature is valid
                 if verifier.ne(&server_signature.to_base64(B64_CONFIG)[..]) {
-                    return Err(MaliciousServerError(MaliciousServerErrorType::InvalidServerSignature));
+                    return Err(
+                        MaliciousServerError(MaliciousServerErrorType::InvalidServerSignature));
                 }
             }
 
             doc = try!(self.db.command(final_doc.clone(), Suppressed, None));
 
             if let Some(&Bson::Boolean(true)) = doc.get("done") {
-                return Ok(())
+                return Ok(());
             }
         }
     }