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

fix(perf): remove --secret-key-seed flag

Browse Source 
There is no need for the flag, given that rust-libp2p allows dialing multiaddr without `/p2p`.

Pull-Request: #3994.
This commit is contained in:
Max Inden 2023-05-29 10:04:52 +02:00 committed by GitHub
parent c5dd0a2e14
commit 9b765fa202
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 10 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
protocols/perf/src/bin/perf.rs
View File

@ -50,9 +50,6 @@ struct Opts {
/// Run in server mode. /// Run in server mode.
#[clap(long)] #[clap(long)]
run_server: bool, run_server: bool,
/// Fixed value to generate deterministic peer id.
#[clap(long)]
secret_key_seed: Option<u8>,
} }
/// Supported transports by rust-libp2p. /// Supported transports by rust-libp2p.
@ -88,15 +85,13 @@ async fn main() -> Result<()> {
upload_bytes: None, upload_bytes: None,
download_bytes: None, download_bytes: None,
run_server: true, run_server: true,
secret_key_seed: Some(secret_key_seed), } => server(server_address).await?,
} => server(server_address, secret_key_seed).await?,
Opts { Opts {
server_address: Some(server_address), server_address: Some(server_address),
transport: Some(transport), transport: Some(transport),
upload_bytes, upload_bytes,
download_bytes, download_bytes,
run_server: false, run_server: false,
secret_key_seed: None,
} => { } => {
client(server_address, transport, upload_bytes, download_bytes).await?; client(server_address, transport, upload_bytes, download_bytes).await?;
} }
@ -106,8 +101,8 @@ async fn main() -> Result<()> {
Ok(()) Ok(())
} }
async fn server(server_address: SocketAddr, secret_key_seed: u8) -> Result<()> { async fn server(server_address: SocketAddr) -> Result<()> {
let mut swarm = swarm::<libp2p_perf::server::Behaviour>(Some(secret_key_seed)).await?; let mut swarm = swarm::<libp2p_perf::server::Behaviour>().await?;
swarm.listen_on( swarm.listen_on(
Multiaddr::empty() Multiaddr::empty()
@ -201,7 +196,7 @@ async fn client(
async fn custom(server_address: Multiaddr, params: RunParams) -> Result<()> { async fn custom(server_address: Multiaddr, params: RunParams) -> Result<()> {
info!("start benchmark: custom"); info!("start benchmark: custom");
let mut swarm = swarm(None).await?; let mut swarm = swarm().await?;
let (server_peer_id, connection_established) = let (server_peer_id, connection_established) =
connect(&mut swarm, server_address.clone()).await?; connect(&mut swarm, server_address.clone()).await?;
@ -231,7 +226,7 @@ async fn custom(server_address: Multiaddr, params: RunParams) -> Result<()> {
async fn latency(server_address: Multiaddr) -> Result<()> { async fn latency(server_address: Multiaddr) -> Result<()> {
info!("start benchmark: round-trip-time latency"); info!("start benchmark: round-trip-time latency");
let mut swarm = swarm(None).await?; let mut swarm = swarm().await?;
let (server_peer_id, _) = connect(&mut swarm, server_address.clone()).await?; let (server_peer_id, _) = connect(&mut swarm, server_address.clone()).await?;
@ -278,7 +273,7 @@ fn percentile<V: PartialOrd + Copy>(values: &[V], percentile: f64) -> V {
async fn throughput(server_address: Multiaddr) -> Result<()> { async fn throughput(server_address: Multiaddr) -> Result<()> {
info!("start benchmark: single connection single channel throughput"); info!("start benchmark: single connection single channel throughput");
let mut swarm = swarm(None).await?; let mut swarm = swarm().await?;
let (server_peer_id, _) = connect(&mut swarm, server_address.clone()).await?; let (server_peer_id, _) = connect(&mut swarm, server_address.clone()).await?;
@ -294,7 +289,7 @@ async fn throughput(server_address: Multiaddr) -> Result<()> {
async fn requests_per_second(server_address: Multiaddr) -> Result<()> { async fn requests_per_second(server_address: Multiaddr) -> Result<()> {
info!("start benchmark: single connection parallel requests per second"); info!("start benchmark: single connection parallel requests per second");
let mut swarm = swarm(None).await?; let mut swarm = swarm().await?;
let (server_peer_id, _) = connect(&mut swarm, server_address.clone()).await?; let (server_peer_id, _) = connect(&mut swarm, server_address.clone()).await?;
@ -357,7 +352,7 @@ async fn sequential_connections_per_second(server_address: Multiaddr) -> Result<
break; break;
} }
let mut swarm = swarm(None).await?; let mut swarm = swarm().await?;
let start = Instant::now(); let start = Instant::now();
@ -397,12 +392,8 @@ async fn sequential_connections_per_second(server_address: Multiaddr) -> Result<
Ok(()) Ok(())
} }
async fn swarm<B: NetworkBehaviour + Default>(secret_key_seed: Option<u8>) -> Result<Swarm<B>> { async fn swarm<B: NetworkBehaviour + Default>() -> Result<Swarm<B>> {
let local_key = if let Some(seed) = secret_key_seed { let local_key = libp2p_identity::Keypair::generate_ed25519();
generate_ed25519(seed)
} else {
libp2p_identity::Keypair::generate_ed25519()
};
let local_peer_id = PeerId::from(local_key.public()); let local_peer_id = PeerId::from(local_key.public());
let transport = { let transport = {
@ -477,10 +468,3 @@ async fn perf(
Ok(duration) Ok(duration)
} }
fn generate_ed25519(secret_key_seed: u8) -> libp2p_identity::Keypair {
let mut bytes = [0u8; 32];
bytes[0] = secret_key_seed;
libp2p_identity::Keypair::ed25519_from_bytes(bytes).expect("only errors on wrong length")
}