Add loops around stream polling (#251)

core/src/connection_reuse.rs

@@ -278,27 +278,30 @@ where
         // Check for any incoming connection on the listening socket.
         // Note that since `self.listener` is a `Fuse`, it's not a problem to continue polling even
         // after it is finished or after it error'ed.
+        loop {
             match self.listener.poll() {
                 Ok(Async::Ready(Some(upgrade))) => {
                     self.current_upgrades.push(upgrade);
                 }
-            Ok(Async::NotReady) => {}
+                Ok(Async::NotReady) => break,
                 Ok(Async::Ready(None)) => {
                     debug!("listener has been closed");
                     if self.connections.is_empty() && self.current_upgrades.is_empty() {
                         return Ok(Async::Ready(None));
                     }
+                    break
                 }
                 Err(err) => {
                     debug!("error while polling listener: {:?}", err);
                     if self.connections.is_empty() && self.current_upgrades.is_empty() {
                         return Err(err);
                     }
+                    break
+                }
+            }
         }
-        };
 
-        // We extract everything at the start, then insert back the elements that we still want at
+        loop {
-        // the next iteration.
             match self.current_upgrades.poll() {
                 Ok(Async::Ready(Some((muxer, client_addr)))) => {
                     let next_incoming = muxer.clone().inbound();
@@ -306,11 +309,11 @@ where
                         .push((muxer.clone(), next_incoming, client_addr.clone()));
                 }
                 Err(err) => {
-                // Insert the rest of the pending upgrades, but not the current one.
                     debug!("error while upgrading listener connection: {:?}", err);
                     return Ok(Async::Ready(Some(future::err(err))));
                 }
-            _ => {}
+                _ => break,
+            }
         }
 
         // Check whether any incoming substream is ready.

core/src/swarm.rs

@@ -205,8 +205,9 @@ where
                 debug!("Error in multiplexed incoming connection: {:?}", err);
                 self.next_incoming = self.transport.clone().next_incoming();
             }
-        };
+        }
 
+        loop {
             match self.new_listeners.poll() {
                 Ok(Async::Ready(Some(new_listener))) => {
                     let new_listener = Box::new(
@@ -222,29 +223,37 @@ where
                 }
                 Ok(Async::Ready(None)) | Err(_) => {
                     // New listener sender has been closed.
+                    break;
+                }
+                Ok(Async::NotReady) => break,
+            }
         }
-            Ok(Async::NotReady) => {}
-        };
 
+        loop {
             match self.new_dialers.poll() {
                 Ok(Async::Ready(Some(new_dialer))) => {
                     self.dialers.push(new_dialer);
                 }
                 Ok(Async::Ready(None)) | Err(_) => {
                     // New dialers sender has been closed.
+                    break
+                }
+                Ok(Async::NotReady) => break,
+            }
         }
-            Ok(Async::NotReady) => {}
-        };
 
+        loop {
             match self.new_toprocess.poll() {
                 Ok(Async::Ready(Some(new_toprocess))) => {
                     self.to_process.push(future::Either::B(new_toprocess));
                 }
                 Ok(Async::Ready(None)) | Err(_) => {
                     // New to-process sender has been closed.
+                    break
+                }
+                Ok(Async::NotReady) => break,
+            }
         }
-            Ok(Async::NotReady) => {}
-        };
 
         loop {
             match self.listeners.poll() {
@@ -261,6 +270,7 @@ where
             }
         }
 
+        loop {
             match self.listeners_upgrade.poll() {
                 Ok(Async::Ready(Some((output, client_addr)))) => {
                     debug!("Successfully upgraded incoming connection");
@@ -270,10 +280,13 @@ where
                 }
                 Err(err) => {
                     debug!("Error in listener upgrade: {:?}", err);
+                    break;
+                }
+                _ => break
             }
-            _ => {}
         }
 
+        loop {
             match self.dialers.poll() {
                 Ok(Async::Ready(Some((output, addr)))) => {
                     trace!("Successfully upgraded dialed connection");
@@ -282,10 +295,13 @@ where
                 }
                 Err(err) => {
                     debug!("Error in dialer upgrade: {:?}", err);
+                    break;
+                }
+                _ => break
             }
-            _ => {}
         }
 
+        loop {
             match self.to_process.poll() {
                 Ok(Async::Ready(Some(()))) => {
                     trace!("Future returned by swarm handler driven to completion");
@@ -293,7 +309,8 @@ where
                 Err(err) => {
                     debug!("Error in processing: {:?}", err);
                 }
-            _ => {}
+                _ => break,
+            }
         }
 
         // TODO: we never return `Ok(Ready)` because there's no way to know whether