File size: 5,056 Bytes
f0f4f2b |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 |
use std::{io, time::Duration};
use anyhow::{Context, Result};
use futures::{AsyncReadExt, AsyncWriteExt, StreamExt};
use libp2p::{multiaddr::Protocol, Multiaddr, PeerId, Stream, StreamProtocol};
use libp2p_stream as stream;
use rand::RngCore;
use tracing::level_filters::LevelFilter;
use tracing_subscriber::EnvFilter;
const ECHO_PROTOCOL: StreamProtocol = StreamProtocol::new("/echo");
#[tokio::main]
async fn main() -> Result<()> {
tracing_subscriber::fmt()
.with_env_filter(
EnvFilter::builder()
.with_default_directive(LevelFilter::INFO.into())
.from_env()?,
)
.init();
let maybe_address = std::env::args()
.nth(1)
.map(|arg| arg.parse::<Multiaddr>())
.transpose()
.context("Failed to parse argument as `Multiaddr`")?;
let mut swarm = libp2p::SwarmBuilder::with_new_identity()
.with_tokio()
.with_quic()
.with_behaviour(|_| stream::Behaviour::new())?
.with_swarm_config(|c| c.with_idle_connection_timeout(Duration::from_secs(10)))
.build();
swarm.listen_on("/ip4/127.0.0.1/udp/0/quic-v1".parse()?)?;
let mut incoming_streams = swarm
.behaviour()
.new_control()
.accept(ECHO_PROTOCOL)
.unwrap();
// Deal with incoming streams.
// Spawning a dedicated task is just one way of doing this.
// libp2p doesn't care how you handle incoming streams but you _must_ handle them somehow.
// To mitigate DoS attacks, libp2p will internally drop incoming streams if your application cannot keep up processing them.
tokio::spawn(async move {
// This loop handles incoming streams _sequentially_ but that doesn't have to be the case.
// You can also spawn a dedicated task per stream if you want to.
// Be aware that this breaks backpressure though as spawning new tasks is equivalent to an unbounded buffer.
// Each task needs memory meaning an aggressive remote peer may force you OOM this way.
while let Some((peer, stream)) = incoming_streams.next().await {
match echo(stream).await {
Ok(n) => {
tracing::info!(%peer, "Echoed {n} bytes!");
}
Err(e) => {
tracing::warn!(%peer, "Echo failed: {e}");
continue;
}
};
}
});
// In this demo application, the dialing peer initiates the protocol.
if let Some(address) = maybe_address {
let Some(Protocol::P2p(peer_id)) = address.iter().last() else {
anyhow::bail!("Provided address does not end in `/p2p`");
};
swarm.dial(address)?;
tokio::spawn(connection_handler(peer_id, swarm.behaviour().new_control()));
}
// Poll the swarm to make progress.
loop {
let event = swarm.next().await.expect("never terminates");
match event {
libp2p::swarm::SwarmEvent::NewListenAddr { address, .. } => {
let listen_address = address.with_p2p(*swarm.local_peer_id()).unwrap();
tracing::info!(%listen_address);
}
event => tracing::trace!(?event),
}
}
}
/// A very simple, `async fn`-based connection handler for our custom echo protocol.
async fn connection_handler(peer: PeerId, mut control: stream::Control) {
loop {
tokio::time::sleep(Duration::from_secs(1)).await; // Wait a second between echos.
let stream = match control.open_stream(peer, ECHO_PROTOCOL).await {
Ok(stream) => stream,
Err(error @ stream::OpenStreamError::UnsupportedProtocol(_)) => {
tracing::info!(%peer, %error);
return;
}
Err(error) => {
// Other errors may be temporary.
// In production, something like an exponential backoff / circuit-breaker may be more appropriate.
tracing::debug!(%peer, %error);
continue;
}
};
if let Err(e) = send(stream).await {
tracing::warn!(%peer, "Echo protocol failed: {e}");
continue;
}
tracing::info!(%peer, "Echo complete!")
}
}
async fn echo(mut stream: Stream) -> io::Result<usize> {
let mut total = 0;
let mut buf = [0u8; 100];
loop {
let read = stream.read(&mut buf).await?;
if read == 0 {
return Ok(total);
}
total += read;
stream.write_all(&buf[..read]).await?;
}
}
async fn send(mut stream: Stream) -> io::Result<()> {
let num_bytes = rand::random::<usize>() % 1000;
let mut bytes = vec![0; num_bytes];
rand::thread_rng().fill_bytes(&mut bytes);
stream.write_all(&bytes).await?;
let mut buf = vec![0; num_bytes];
stream.read_exact(&mut buf).await?;
if bytes != buf {
return Err(io::Error::new(io::ErrorKind::Other, "incorrect echo"));
}
stream.close().await?;
Ok(())
}
|