fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-05-19 22:21:21 +00:00
Code Issues Projects Releases Wiki Activity

Add loops around stream polling (#251)

Browse Source
This commit is contained in:
Pierre Krieger 2018-06-22 11:02:47 +02:00 committed by GitHub
parent 02bf7604d0
commit ab96f7efe0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 108 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
core/src/connection_reuse.rs
View File

@ -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
// the next iteration.
loop {
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.

37
core/src/swarm.rs
View File

@ -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