clippy warnings; fmt

src/server/srv.rs

@@ -219,10 +219,7 @@ where
             if let Some(e) = err.take() {
                 Err(e)
             } else {
-                Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    "Can not bind to address.",
-                ))
+                Err(io::Error::new(io::ErrorKind::Other, "Can not bind to address."))
             }
         } else {
             Ok(self)
@@ -230,7 +227,7 @@ where
     }
 
     fn start_workers(
-        &mut self, settings: &ServerSettings, handler: &StreamHandlerType
+        &mut self, settings: &ServerSettings, handler: &StreamHandlerType,
     ) -> Vec<(usize, mpsc::UnboundedSender<Conn<net::TcpStream>>)> {
         // start workers
         let mut workers = Vec::new();
@@ -332,9 +329,9 @@ impl<H: IntoHttpHandler> HttpServer<H> {
                 ctx.add_stream(rx);
                 self
             });
-            signals.map(|signals| {
+            if let Some(signals) = signals {
                 signals.do_send(signal::Subscribe(addr.clone().recipient()))
-            });
+            }
             addr
         }
     }
@@ -378,10 +375,7 @@ impl<H: IntoHttpHandler> HttpServer<H> {
     /// Start listening for incoming tls connections.
     pub fn start_tls(mut self, acceptor: TlsAcceptor) -> io::Result<Addr<Syn, Self>> {
         if self.sockets.is_empty() {
-            Err(io::Error::new(
-                io::ErrorKind::Other,
-                "No socket addresses are bound",
-            ))
+            Err(io::Error::new(io::ErrorKind::Other, "No socket addresses are bound"))
         } else {
             let (tx, rx) = mpsc::unbounded();
             let addrs: Vec<(net::SocketAddr, net::TcpListener)> =
@@ -427,13 +421,10 @@ impl<H: IntoHttpHandler> HttpServer<H> {
     ///
     /// This method sets alpn protocols to "h2" and "http/1.1"
     pub fn start_ssl(
-        mut self, mut builder: SslAcceptorBuilder
+        mut self, mut builder: SslAcceptorBuilder,
     ) -> io::Result<Addr<Syn, Self>> {
         if self.sockets.is_empty() {
-            Err(io::Error::new(
-                io::ErrorKind::Other,
-                "No socket addresses are bound",
-            ))
+            Err(io::Error::new(io::ErrorKind::Other, "No socket addresses are bound"))
         } else {
             // alpn support
             if !self.no_http2 {
@@ -545,8 +536,9 @@ impl<H: IntoHttpHandler> HttpServer<H> {
             }));
             self
         });
-        signals
-            .map(|signals| signals.do_send(signal::Subscribe(addr.clone().recipient())));
+        if let Some(signals) = signals {
+            signals.do_send(signal::Subscribe(addr.clone().recipient()))
+        }
         addr
     }
 }
@@ -562,17 +554,35 @@ impl<H: IntoHttpHandler> Handler<signal::Signal> for HttpServer<H> {
             signal::SignalType::Int => {
                 info!("SIGINT received, exiting");
                 self.exit = true;
-                Handler::<StopServer>::handle(self, StopServer { graceful: false }, ctx);
+                Handler::<StopServer>::handle(
+                    self,
+                    StopServer {
+                        graceful: false,
+                    },
+                    ctx,
+                );
             }
             signal::SignalType::Term => {
                 info!("SIGTERM received, stopping");
                 self.exit = true;
-                Handler::<StopServer>::handle(self, StopServer { graceful: true }, ctx);
+                Handler::<StopServer>::handle(
+                    self,
+                    StopServer {
+                        graceful: true,
+                    },
+                    ctx,
+                );
             }
             signal::SignalType::Quit => {
                 info!("SIGQUIT received, exiting");
                 self.exit = true;
-                Handler::<StopServer>::handle(self, StopServer { graceful: false }, ctx);
+                Handler::<StopServer>::handle(
+                    self,
+                    StopServer {
+                        graceful: false,
+                    },
+                    ctx,
+                );
             }
             _ => (),
         }
@@ -696,7 +706,9 @@ impl<H: IntoHttpHandler> Handler<StopServer> for HttpServer<H> {
             let tx2 = tx.clone();
             worker
                 .1
-                .send(StopWorker { graceful: dur })
+                .send(StopWorker {
+                    graceful: dur,
+                })
                 .into_actor(self)
                 .then(move |_, slf, ctx| {
                     slf.workers.pop();
@@ -746,9 +758,8 @@ fn start_accept_thread(
 
     // start accept thread
     #[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
-    let _ = thread::Builder::new()
-        .name(format!("Accept on {}", addr))
-        .spawn(move || {
+    let _ = thread::Builder::new().name(format!("Accept on {}", addr)).spawn(
+        move || {
             const SRV: mio::Token = mio::Token(0);
             const CMD: mio::Token = mio::Token(1);
 
@@ -773,12 +784,9 @@ fn start_accept_thread(
             }
 
             // Start listening for incoming commands
-            if let Err(err) = poll.register(
-                &reg,
-                CMD,
-                mio::Ready::readable(),
-                mio::PollOpt::edge(),
-            ) {
+            if let Err(err) =
+                poll.register(&reg, CMD, mio::Ready::readable(), mio::PollOpt::edge())
+            {
                 panic!("Can not register Registration: {}", err);
             }
 
@@ -909,13 +917,14 @@ fn start_accept_thread(
                     }
                 }
             }
-        });
+        },
+    );
 
     (readiness, tx)
 }
 
 fn create_tcp_listener(
-    addr: net::SocketAddr, backlog: i32
+    addr: net::SocketAddr, backlog: i32,
 ) -> io::Result<net::TcpListener> {
     let builder = match addr {
         net::SocketAddr::V4(_) => TcpBuilder::new_v4()?,