fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-08-01 01:11:58 +00:00
Code Issues Projects Releases Wiki Activity

Restore RequestResponse::throttled. (#1726)

Browse Source 
* Restore `RequestResponse::throttled`.

In contrast to the existing "throttled" approach this PR adds back-
pressure to the protocol without requiring pre-existing knowledge
of all nodes about their limits. It adds small, CBOR-encoded headers
to the actual payload data. Extra credit messages communicate back
to the sender how many more requests it is allowed to send.

* Remove some noise.

* Resend credit grant after connection closed.

Should an error in some lower layer cause a connection to be closed,
our previously sent credit grant may not have reached the remote peer.
Therefore, pessimistically, a credit grant is resent whenever a
connection is closed. The remote ignores duplicate grants.

* Remove inbound/outbound tracking per peer.

* Send ACK as response to duplicate credit grants.

* Simplify.

* Fix grammar.

* Incorporate review feedback.

- Remove `ResponseSent` which was a leftover from previous attemps
  and issue a credit grant immediately in `send_response`.
- Only resend credit grants after a connection is closed if we are
  still connected to this peer.

* Move codec/header.rs to throttled/codec.rs.

* More review suggestions.

* Generalise `ProtocolWrapper` and use shorter prefix.

* Update protocols/request-response/src/lib.rs

Co-authored-by: Roman Borschel <romanb@users.noreply.github.com>

* Update protocols/request-response/src/throttled.rs

Co-authored-by: Roman Borschel <romanb@users.noreply.github.com>

* Update protocols/request-response/src/throttled.rs

Co-authored-by: Roman Borschel <romanb@users.noreply.github.com>

* Minor comment changes.

* Limit max. header size to 8KiB

* Always construct initial limit with 1.

Since honest senders always assume a send budget of 1 and wait for
credit afterwards, setting the default limit to a higher value
can only become effective after informing the peer about it which
means leaving `max_recv` at 1 and setting `next_max` to the desired
value.

Co-authored-by: Roman Borschel <romanb@users.noreply.github.com>
This commit is contained in:
Toralf Wittner
2020-09-07 17:22:40 +02:00
committed by GitHub
parent ed5aec14f3
commit d988b05f85
8 changed files with 903 additions and 480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

295
protocols/request-response/tests/ping.rs
View File

@@ -36,7 +36,7 @@ use libp2p_tcp::TcpConfig;
use futures::{prelude::*, channel::mpsc};
use rand::{self, Rng};
use std::{io, iter};
// use std::{collections::HashSet, num::NonZeroU16}; // Disabled until #1706 is fixed.
use std::{collections::HashSet, num::NonZeroU16};
/// Exercises a simple ping protocol.
#[test]
@@ -73,7 +73,7 @@ fn ping_protocol() {
match swarm1.next().await {
RequestResponseEvent::Message {
peer,
message: RequestResponseMessage::Request { request, channel }
message: RequestResponseMessage::Request { request, channel, .. }
} => {
assert_eq!(&request, &expected_ping);
assert_eq!(&peer, &peer2_id);
@@ -117,202 +117,101 @@ fn ping_protocol() {
let () = async_std::task::block_on(peer2);
}
// Disabled until #1706 is fixed.
///// Like `ping_protocol`, but throttling concurrent requests.
//#[test]
//fn ping_protocol_throttled() {
// let ping = Ping("ping".to_string().into_bytes());
// let pong = Pong("pong".to_string().into_bytes());
//
// let protocols = iter::once((PingProtocol(), ProtocolSupport::Full));
// let cfg = RequestResponseConfig::default();
//
// let (peer1_id, trans) = mk_transport();
// let ping_proto1 = RequestResponse::new(PingCodec(), protocols.clone(), cfg.clone()).throttled();
// let mut swarm1 = Swarm::new(trans, ping_proto1, peer1_id.clone());
//
// let (peer2_id, trans) = mk_transport();
// let ping_proto2 = RequestResponse::new(PingCodec(), protocols, cfg).throttled();
// let mut swarm2 = Swarm::new(trans, ping_proto2, peer2_id.clone());
//
// let (mut tx, mut rx) = mpsc::channel::<Multiaddr>(1);
//
// let addr = "/ip4/127.0.0.1/tcp/0".parse().unwrap();
// Swarm::listen_on(&mut swarm1, addr).unwrap();
//
// let expected_ping = ping.clone();
// let expected_pong = pong.clone();
//
// let limit: u16 = rand::thread_rng().gen_range(1, 10);
// swarm1.set_default_limit(NonZeroU16::new(limit).unwrap());
// swarm2.set_default_limit(NonZeroU16::new(limit).unwrap());
//
// let peer1 = async move {
// while let Some(_) = swarm1.next().now_or_never() {}
//
// let l = Swarm::listeners(&swarm1).next().unwrap();
// tx.send(l.clone()).await.unwrap();
//
// loop {
// match swarm1.next().await {
// throttled::Event::Event(RequestResponseEvent::Message {
// peer,
// message: RequestResponseMessage::Request { request, channel }
// }) => {
// assert_eq!(&request, &expected_ping);
// assert_eq!(&peer, &peer2_id);
// swarm1.send_response(channel, pong.clone());
// },
// e => panic!("Peer1: Unexpected event: {:?}", e)
// }
// }
// };
//
// let num_pings: u8 = rand::thread_rng().gen_range(1, 100);
//
// let peer2 = async move {
// let mut count = 0;
// let addr = rx.next().await.unwrap();
// swarm2.add_address(&peer1_id, addr.clone());
// let mut blocked = false;
// let mut req_ids = HashSet::new();
//
// loop {
// if !blocked {
// while let Some(id) = swarm2.send_request(&peer1_id, ping.clone()).ok() {
// req_ids.insert(id);
// }
// blocked = true;
// }
// match swarm2.next().await {
// throttled::Event::ResumeSending(peer) => {
// assert_eq!(peer, peer1_id);
// blocked = false
// }
// throttled::Event::Event(RequestResponseEvent::Message {
// peer,
// message: RequestResponseMessage::Response { request_id, response }
// }) => {
// count += 1;
// assert_eq!(&response, &expected_pong);
// assert_eq!(&peer, &peer1_id);
// assert!(req_ids.remove(&request_id));
// if count >= num_pings {
// break
// }
// }
// e => panic!("Peer2: Unexpected event: {:?}", e)
// }
// }
// };
//
// async_std::task::spawn(Box::pin(peer1));
// let () = async_std::task::block_on(peer2);
//}
//
//#[test]
//fn ping_protocol_limit_violation() {
// let ping = Ping("ping".to_string().into_bytes());
// let pong = Pong("pong".to_string().into_bytes());
//
// let protocols = iter::once((PingProtocol(), ProtocolSupport::Full));
// let cfg = RequestResponseConfig::default();
//
// let (peer1_id, trans) = mk_transport();
// let ping_proto1 = RequestResponse::new(PingCodec(), protocols.clone(), cfg.clone()).throttled();
// let mut swarm1 = Swarm::new(trans, ping_proto1, peer1_id.clone());
//
// let (peer2_id, trans) = mk_transport();
// let ping_proto2 = RequestResponse::new(PingCodec(), protocols, cfg).throttled();
// let mut swarm2 = Swarm::new(trans, ping_proto2, peer2_id.clone());
//
// let (mut tx, mut rx) = mpsc::channel::<Multiaddr>(1);
//
// let addr = "/ip4/127.0.0.1/tcp/0".parse().unwrap();
// Swarm::listen_on(&mut swarm1, addr).unwrap();
//
// let expected_ping = ping.clone();
// let expected_pong = pong.clone();
//
// swarm2.set_default_limit(NonZeroU16::new(2).unwrap());
//
// let peer1 = async move {
// while let Some(_) = swarm1.next().now_or_never() {}
//
// let l = Swarm::listeners(&swarm1).next().unwrap();
// tx.send(l.clone()).await.unwrap();
//
// let mut pending_responses = Vec::new();
//
// loop {
// match swarm1.next().await {
// throttled::Event::Event(RequestResponseEvent::Message {
// peer,
// message: RequestResponseMessage::Request { request, channel }
// }) => {
// assert_eq!(&request, &expected_ping);
// assert_eq!(&peer, &peer2_id);
// pending_responses.push((channel, pong.clone()));
// },
// throttled::Event::TooManyInboundRequests(p) => {
// assert_eq!(p, peer2_id);
// break
// }
// e => panic!("Peer1: Unexpected event: {:?}", e)
// }
// if pending_responses.len() >= 2 {
// for (channel, pong) in pending_responses.drain(..) {
// swarm1.send_response(channel, pong)
// }
// }
// }
// };
//
// let num_pings: u8 = rand::thread_rng().gen_range(1, 100);
//
// let peer2 = async move {
// let mut count = 0;
// let addr = rx.next().await.unwrap();
// swarm2.add_address(&peer1_id, addr.clone());
// let mut blocked = false;
// let mut req_ids = HashSet::new();
//
// loop {
// if !blocked {
// while let Some(id) = swarm2.send_request(&peer1_id, ping.clone()).ok() {
// req_ids.insert(id);
// }
// blocked = true;
// }
// match swarm2.next().await {
// throttled::Event::ResumeSending(peer) => {
// assert_eq!(peer, peer1_id);
// blocked = false
// }
// throttled::Event::Event(RequestResponseEvent::Message {
// peer,
// message: RequestResponseMessage::Response { request_id, response }
// }) => {
// count += 1;
// assert_eq!(&response, &expected_pong);
// assert_eq!(&peer, &peer1_id);
// assert!(req_ids.remove(&request_id));
// if count >= num_pings {
// break
// }
// }
// throttled::Event::Event(RequestResponseEvent::OutboundFailure { error, .. }) => {
// assert!(matches!(error, OutboundFailure::ConnectionClosed));
// break
// }
// e => panic!("Peer2: Unexpected event: {:?}", e)
// }
// }
// };
//
// async_std::task::spawn(Box::pin(peer1));
// let () = async_std::task::block_on(peer2);
//}
#[test]
fn ping_protocol_throttled() {
let ping = Ping("ping".to_string().into_bytes());
let pong = Pong("pong".to_string().into_bytes());
let protocols = iter::once((PingProtocol(), ProtocolSupport::Full));
let cfg = RequestResponseConfig::default();
let (peer1_id, trans) = mk_transport();
let ping_proto1 = RequestResponse::throttled(PingCodec(), protocols.clone(), cfg.clone());
let mut swarm1 = Swarm::new(trans, ping_proto1, peer1_id.clone());
let (peer2_id, trans) = mk_transport();
let ping_proto2 = RequestResponse::throttled(PingCodec(), protocols, cfg);
let mut swarm2 = Swarm::new(trans, ping_proto2, peer2_id.clone());
let (mut tx, mut rx) = mpsc::channel::<Multiaddr>(1);
let addr = "/ip4/127.0.0.1/tcp/0".parse().unwrap();
Swarm::listen_on(&mut swarm1, addr).unwrap();
let expected_ping = ping.clone();
let expected_pong = pong.clone();
let limit1: u16 = rand::thread_rng().gen_range(1, 10);
let limit2: u16 = rand::thread_rng().gen_range(1, 10);
swarm1.set_receive_limit(NonZeroU16::new(limit1).unwrap());
swarm2.set_receive_limit(NonZeroU16::new(limit2).unwrap());
let peer1 = async move {
while let Some(_) = swarm1.next().now_or_never() {}
let l = Swarm::listeners(&swarm1).next().unwrap();
tx.send(l.clone()).await.unwrap();
for i in 1.. {
match swarm1.next().await {
throttled::Event::Event(RequestResponseEvent::Message {
peer,
message: RequestResponseMessage::Request { request, channel, .. },
}) => {
assert_eq!(&request, &expected_ping);
assert_eq!(&peer, &peer2_id);
swarm1.send_response(channel, pong.clone());
},
e => panic!("Peer1: Unexpected event: {:?}", e)
}
if i % 31 == 0 {
let lim = rand::thread_rng().gen_range(1, 17);
swarm1.override_receive_limit(&peer2_id, NonZeroU16::new(lim).unwrap());
}
}
};
let num_pings: u16 = rand::thread_rng().gen_range(100, 1000);
let peer2 = async move {
let mut count = 0;
let addr = rx.next().await.unwrap();
swarm2.add_address(&peer1_id, addr.clone());
let mut blocked = false;
let mut req_ids = HashSet::new();
loop {
if !blocked {
while let Some(id) = swarm2.send_request(&peer1_id, ping.clone()).ok() {
req_ids.insert(id);
}
blocked = true;
}
match swarm2.next().await {
throttled::Event::ResumeSending(peer) => {
assert_eq!(peer, peer1_id);
blocked = false
}
throttled::Event::Event(RequestResponseEvent::Message {
peer,
message: RequestResponseMessage::Response { request_id, response }
}) => {
count += 1;
assert_eq!(&response, &expected_pong);
assert_eq!(&peer, &peer1_id);
assert!(req_ids.remove(&request_id));
if count >= num_pings {
break
}
}
e => panic!("Peer2: Unexpected event: {:?}", e)
}
}
};
async_std::task::spawn(Box::pin(peer1));
let () = async_std::task::block_on(peer2);
}
fn mk_transport() -> (PeerId, Boxed<(PeerId, StreamMuxerBox), io::Error>) {
let id_keys = identity::Keypair::generate_ed25519();