add rustfmt config

tools/wsload/src/wsclient.rs

@@ -3,25 +3,24 @@
 #![allow(unused_variables)]
 extern crate actix;
 extern crate actix_web;
+extern crate clap;
 extern crate env_logger;
 extern crate futures;
-extern crate tokio_core;
-extern crate url;
-extern crate clap;
+extern crate num_cpus;
 extern crate rand;
 extern crate time;
-extern crate num_cpus;
+extern crate tokio_core;
+extern crate url;
 
-use std::time::Duration;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use futures::Future;
 use rand::{thread_rng, Rng};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::Duration;
 
 use actix::prelude::*;
 use actix_web::ws;
 
-
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=info");
     let _ = env_logger::init();
@@ -62,16 +61,20 @@ fn main() {
     let sample_rate = parse_u64_default(matches.value_of("sample-rate"), 1) as usize;
 
     let perf_counters = Arc::new(PerfCounters::new());
-    let payload = Arc::new(thread_rng()
-                           .gen_ascii_chars()
-                           .take(payload_size)
-                           .collect::<String>());
+    let payload = Arc::new(
+        thread_rng()
+            .gen_ascii_chars()
+            .take(payload_size)
+            .collect::<String>(),
+    );
 
     let sys = actix::System::new("ws-client");
 
-    let _: () = Perf{counters: perf_counters.clone(),
-                     payload: payload.len(),
-                     sample_rate_secs: sample_rate}.start();
+    let _: () = Perf {
+        counters: perf_counters.clone(),
+        payload: payload.len(),
+        sample_rate_secs: sample_rate,
+    }.start();
 
     for t in 0..threads {
         let pl = payload.clone();
@@ -79,46 +82,54 @@ fn main() {
         let perf = perf_counters.clone();
         let addr = Arbiter::new(format!("test {}", t));
 
-        addr.do_send(actix::msgs::Execute::new(move || -> Result<(), ()> {
-            for _ in 0..concurrency {
-                let pl2 = pl.clone();
-                let perf2 = perf.clone();
-                let ws2 = ws.clone();
+        addr.do_send(actix::msgs::Execute::new(
+            move || -> Result<(), ()> {
+                for _ in 0..concurrency {
+                    let pl2 = pl.clone();
+                    let perf2 = perf.clone();
+                    let ws2 = ws.clone();
 
-                Arbiter::handle().spawn(
-                    ws::Client::new(&ws)
-                        .write_buffer_capacity(0)
-                        .connect()
-                        .map_err(|e| {
-                            println!("Error: {}", e);
-                            //Arbiter::system().do_send(actix::msgs::SystemExit(0));
-                            ()
-                        })
-                        .map(move |(reader, writer)| {
-                            let addr: Addr<Syn, _> = ChatClient::create(move |ctx| {
-                                ChatClient::add_stream(reader, ctx);
-                                ChatClient{url: ws2,
-                                           conn: writer,
-                                           payload: pl2,
-                                           bin: bin,
-                                           ts: time::precise_time_ns(),
-                                           perf_counters: perf2,
-                                           sent: 0,
-                                           max_payload_size: max_payload_size,
-                                }
-                            });
-                        })
-                );
-            }
-            Ok(())
-        }));
+                    Arbiter::handle().spawn(
+                        ws::Client::new(&ws)
+                            .write_buffer_capacity(0)
+                            .connect()
+                            .map_err(|e| {
+                                println!("Error: {}", e);
+                                //Arbiter::system().do_send(actix::msgs::SystemExit(0));
+                                ()
+                            })
+                            .map(move |(reader, writer)| {
+                                let addr: Addr<Syn, _> =
+                                    ChatClient::create(move |ctx| {
+                                        ChatClient::add_stream(reader, ctx);
+                                        ChatClient {
+                                            url: ws2,
+                                            conn: writer,
+                                            payload: pl2,
+                                            bin: bin,
+                                            ts: time::precise_time_ns(),
+                                            perf_counters: perf2,
+                                            sent: 0,
+                                            max_payload_size: max_payload_size,
+                                        }
+                                    });
+                            }),
+                    );
+                }
+                Ok(())
+            },
+        ));
     }
 
     let res = sys.run();
 }
 
 fn parse_u64_default(input: Option<&str>, default: u64) -> u64 {
-    input.map(|v| v.parse().expect(&format!("not a valid number: {}", v)))
+    input
+        .map(|v| {
+            v.parse()
+                .expect(&format!("not a valid number: {}", v))
+        })
         .unwrap_or(default)
 }
 
@@ -138,29 +149,32 @@ impl Actor for Perf {
 
 impl Perf {
     fn sample_rate(&self, ctx: &mut Context<Self>) {
-        ctx.run_later(Duration::new(self.sample_rate_secs as u64, 0), |act, ctx| {
-            let req_count = act.counters.pull_request_count();
-            if req_count != 0 {
-                let conns = act.counters.pull_connections_count();
-                let latency = act.counters.pull_latency_ns();
-                let latency_max = act.counters.pull_latency_max_ns();
-                println!(
-                    "rate: {}, conns: {}, throughput: {:?} kb, latency: {}, latency max: {}",
-                    req_count / act.sample_rate_secs,
-                    conns / act.sample_rate_secs,
-                    (((req_count * act.payload) as f64) / 1024.0) /
-                        act.sample_rate_secs as f64,
-                    time::Duration::nanoseconds((latency / req_count as u64) as i64),
-                    time::Duration::nanoseconds(latency_max as i64)
-                );
-            }
+        ctx.run_later(
+            Duration::new(self.sample_rate_secs as u64, 0),
+            |act, ctx| {
+                let req_count = act.counters.pull_request_count();
+                if req_count != 0 {
+                    let conns = act.counters.pull_connections_count();
+                    let latency = act.counters.pull_latency_ns();
+                    let latency_max = act.counters.pull_latency_max_ns();
+                    println!(
+                        "rate: {}, conns: {}, throughput: {:?} kb, latency: {}, latency max: {}",
+                        req_count / act.sample_rate_secs,
+                        conns / act.sample_rate_secs,
+                        (((req_count * act.payload) as f64) / 1024.0)
+                            / act.sample_rate_secs as f64,
+                        time::Duration::nanoseconds((latency / req_count as u64) as i64),
+                        time::Duration::nanoseconds(latency_max as i64)
+                    );
+                }
 
-            act.sample_rate(ctx);
-        });
+                act.sample_rate(ctx);
+            },
+        );
     }
 }
 
-struct ChatClient{
+struct ChatClient {
     url: String,
     conn: ws::ClientWriter,
     payload: Arc<String>,
@@ -181,7 +195,6 @@ impl Actor for ChatClient {
 }
 
 impl ChatClient {
-
     fn send_text(&mut self) -> bool {
         self.sent += self.payload.len();
 
@@ -193,7 +206,8 @@ impl ChatClient {
             let max_payload_size = self.max_payload_size;
 
             Arbiter::handle().spawn(
-                ws::Client::new(&self.url).connect()
+                ws::Client::new(&self.url)
+                    .connect()
                     .map_err(|e| {
                         println!("Error: {}", e);
                         Arbiter::system().do_send(actix::msgs::SystemExit(0));
@@ -202,17 +216,18 @@ impl ChatClient {
                     .map(move |(reader, writer)| {
                         let addr: Addr<Syn, _> = ChatClient::create(move |ctx| {
                             ChatClient::add_stream(reader, ctx);
-                            ChatClient{url: ws,
-                                       conn: writer,
-                                       payload: pl,
-                                       bin: bin,
-                                       ts: time::precise_time_ns(),
-                                       perf_counters: perf_counters,
-                                       sent: 0,
-                                       max_payload_size: max_payload_size,
+                            ChatClient {
+                                url: ws,
+                                conn: writer,
+                                payload: pl,
+                                bin: bin,
+                                ts: time::precise_time_ns(),
+                                perf_counters: perf_counters,
+                                sent: 0,
+                                max_payload_size: max_payload_size,
                             }
                         });
-                    })
+                    }),
             );
             false
         } else {
@@ -229,7 +244,6 @@ impl ChatClient {
 
 /// Handle server websocket messages
 impl StreamHandler<ws::Message, ws::ProtocolError> for ChatClient {
-
     fn finished(&mut self, ctx: &mut Context<Self>) {
         ctx.stop()
     }
@@ -239,25 +253,25 @@ impl StreamHandler<ws::Message, ws::ProtocolError> for ChatClient {
             ws::Message::Text(txt) => {
                 if txt == self.payload.as_ref().as_str() {
                     self.perf_counters.register_request();
-                    self.perf_counters.register_latency(time::precise_time_ns() - self.ts);
+                    self.perf_counters
+                        .register_latency(time::precise_time_ns() - self.ts);
                     if !self.send_text() {
                         ctx.stop();
                     }
                 } else {
                     println!("not eaqual");
                 }
-            },
-            _ => ()
+            }
+            _ => (),
         }
     }
 }
 
-
 pub struct PerfCounters {
     req: AtomicUsize,
     conn: AtomicUsize,
     lat: AtomicUsize,
-    lat_max: AtomicUsize
+    lat_max: AtomicUsize,
 }
 
 impl PerfCounters {
@@ -299,7 +313,11 @@ impl PerfCounters {
         self.lat.fetch_add(nanos, Ordering::SeqCst);
         loop {
             let current = self.lat_max.load(Ordering::SeqCst);
-            if current >= nanos || self.lat_max.compare_and_swap(current, nanos, Ordering::SeqCst) == current {
+            if current >= nanos
+                || self.lat_max
+                    .compare_and_swap(current, nanos, Ordering::SeqCst)
+                    == current
+            {
                 break;
             }
         }