fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-06-29 01:31:33 +00:00
Code Issues Projects Releases Wiki Activity

protocols/request-response: Remove throttled module (#2236)

Browse Source 
Co-authored-by: Thomas Eizinger <thomas@eizinger.io>
Co-authored-by: Max Inden <mail@max-inden.de>
This commit is contained in:
Pierre Krieger
2021-09-25 18:18:06 +02:00
committed by GitHub
parent 3c0f5c7848
commit f030b15be0
6 changed files with 5 additions and 1236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -21,7 +21,7 @@
//! Integration tests for the `RequestResponse` network behaviour.
use async_trait::async_trait;
use futures::{channel::mpsc, executor::LocalPool, prelude::*, task::SpawnExt, AsyncWriteExt};
use futures::{channel::mpsc, prelude::*, AsyncWriteExt};
use libp2p_core::{
identity,
muxing::StreamMuxerBox,
@ -34,7 +34,6 @@ use libp2p_request_response::*;
use libp2p_swarm::{Swarm, SwarmEvent};
use libp2p_tcp::TcpConfig;
use rand::{self, Rng};
use std::{collections::HashSet, num::NonZeroU16};
use std::{io, iter};
#[test]
@ -293,127 +292,6 @@ fn emits_inbound_connection_closed_if_channel_is_dropped() {
});
}
#[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);
let (peer2_id, trans) = mk_transport();
let ping_proto2 = RequestResponse::throttled(PingCodec(), protocols, cfg);
let mut swarm2 = Swarm::new(trans, ping_proto2, peer2_id);
let (mut tx, mut rx) = mpsc::channel::<Multiaddr>(1);
let addr = "/ip4/127.0.0.1/tcp/0".parse().unwrap();
swarm1.listen_on(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
.behaviour_mut()
.set_receive_limit(NonZeroU16::new(limit1).unwrap());
swarm2
.behaviour_mut()
.set_receive_limit(NonZeroU16::new(limit2).unwrap());
let peer1 = async move {
for i in 1.. {
match swarm1.select_next_some().await {
SwarmEvent::NewListenAddr { address, .. } => tx.send(address).await.unwrap(),
SwarmEvent::Behaviour(throttled::Event::Event(RequestResponseEvent::Message {
peer,
message:
RequestResponseMessage::Request {
request, channel, ..
},
})) => {
assert_eq!(&request, &expected_ping);
assert_eq!(&peer, &peer2_id);
swarm1
.behaviour_mut()
.send_response(channel, pong.clone())
.unwrap();
}
SwarmEvent::Behaviour(throttled::Event::Event(
RequestResponseEvent::ResponseSent { peer, .. },
)) => {
assert_eq!(&peer, &peer2_id);
}
SwarmEvent::Behaviour(e) => panic!("Peer1: Unexpected event: {:?}", e),
_ => {}
}
if i % 31 == 0 {
let lim = rand::thread_rng().gen_range(1, 17);
swarm1
.behaviour_mut()
.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.behaviour_mut().add_address(&peer1_id, addr.clone());
let mut blocked = false;
let mut req_ids = HashSet::new();
loop {
if !blocked {
while let Some(id) = swarm2
.behaviour_mut()
.send_request(&peer1_id, ping.clone())
.ok()
{
req_ids.insert(id);
}
blocked = true;
}
match swarm2.select_next_some().await {
SwarmEvent::Behaviour(throttled::Event::ResumeSending(peer)) => {
assert_eq!(peer, peer1_id);
blocked = false
}
SwarmEvent::Behaviour(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;
}
}
SwarmEvent::Behaviour(e) => panic!("Peer2: Unexpected event: {:?}", e),
_ => {}
}
}
};
let mut pool = LocalPool::new();
pool.spawner().spawn(peer1.boxed()).unwrap();
pool.run_until(peer2);
}
fn mk_transport() -> (PeerId, transport::Boxed<(PeerId, StreamMuxerBox)>) {
let id_keys = identity::Keypair::generate_ed25519();
let peer_id = id_keys.public().to_peer_id();