feat(server): Make sleep_on_error duration configurable and enable it per default

Author: klausi

examples/hello.rs

@@ -20,7 +20,6 @@ fn main() {
     }));
 
     let server = Http::new()
-        .sleep_on_errors(true)
         .bind(&addr, new_service)
         .unwrap();
     println!("Listening on http://{} with 1 thread.", server.local_addr().unwrap());

src/server/mod.rs

@@ -59,7 +59,7 @@ pub struct Http<B = ::Chunk> {
     max_buf_size: Option<usize>,
     keep_alive: bool,
     pipeline: bool,
-    sleep_on_errors: bool,
+    sleep_on_errors: Option<Duration>,
     _marker: PhantomData<B>,
 }
 
@@ -106,7 +106,7 @@ pub struct AddrIncoming {
     keep_alive_timeout: Option<Duration>,
     listener: TcpListener,
     handle: Handle,
-    sleep_on_errors: bool,
+    sleep_on_errors: Option<Duration>,
     timeout: Option<Timeout>,
 }
 
@@ -121,7 +121,7 @@ impl<B: AsRef<[u8]> + 'static> Http<B> {
             keep_alive: true,
             max_buf_size: None,
             pipeline: false,
-            sleep_on_errors: false,
+            sleep_on_errors: Some(Duration::from_millis(10)),
             _marker: PhantomData,
         }
     }
@@ -156,9 +156,11 @@ impl<B: AsRef<[u8]> + 'static> Http<B> {
     /// (like "too many files open") may consume 100% CPU and a timout of 10ms
     /// is used in that case.
     ///
-    /// Default is false.
-    pub fn sleep_on_errors(&mut self, enabled: bool) -> &mut Self {
-        self.sleep_on_errors = enabled;
+    /// This can be disabled by setting the duration to None.
+    ///
+    /// Default is 10ms.
+    pub fn sleep_on_errors(&mut self, duration: Option<Duration>) -> &mut Self {
+        self.sleep_on_errors = duration;
         self
     }
 
@@ -544,7 +546,7 @@ where
 // ===== impl AddrIncoming =====
 
 impl AddrIncoming {
-    fn new(listener: TcpListener, handle: Handle, sleep_on_errors: bool) -> io::Result<AddrIncoming> {
+    fn new(listener: TcpListener, handle: Handle, sleep_on_errors: Option<Duration>) -> io::Result<AddrIncoming> {
          Ok(AddrIncoming {
             addr: listener.local_addr()?,
             keep_alive_timeout: None,
@@ -590,29 +592,30 @@ impl Stream for AddrIncoming {
                     return Ok(Async::Ready(Some(AddrStream::new(socket, addr))));
                 },
                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return Ok(Async::NotReady),
-                Err(ref e) if self.sleep_on_errors => {
-                    // Connection errors can be ignored directly, continue by
-                    // accepting the next request.
-                    if connection_error(e) {
-                        continue;
-                    }
-                    // Sleep 10ms.
-                    let delay = ::std::time::Duration::from_millis(10);
-                    debug!("accept error: {}; sleeping {:?}",
-                        e, delay);
-                    let mut timeout = Timeout::new(delay, &self.handle)
-                        .expect("can always set a timeout");
-                    let result = timeout.poll()
-                        .expect("timeout never fails");
-                    match result {
-                        Async::Ready(()) => continue,
-                        Async::NotReady => {
-                            self.timeout = Some(timeout);
-                            return Ok(Async::NotReady);
+                Err(e) => {
+                    if let Some(delay) = self.sleep_on_errors {
+                        // Connection errors can be ignored directly, continue
+                        // by accepting the next request.
+                        if connection_error(&e) {
+                            continue;
+                        }
+                        // Sleep for a short duration (default: 10ms).
+                        debug!("accept error: {}; sleeping {:?}",
+                            e, delay);
+                        let mut timeout = Timeout::new(delay, &self.handle)
+                            .expect("can always set a timeout");
+                        let result = timeout.poll()
+                            .expect("timeout never fails");
+                        match result {
+                            Async::Ready(()) => continue,
+                            Async::NotReady => {
+                                self.timeout = Some(timeout);
+                                return Ok(Async::NotReady);
+                            }
                         }
                     }
+                    return Err(e);
                 },
-                Err(e) => return Err(e),
             }
         }
     }