peernet 0.4.2

easy and reliable p2p networking
Documentation 
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

# P2P
A p2p networking library

- transport: [quinn](https://github.com/quinn-rs/quinn)
- hole punching and relaying: [iroh-net](https://github.com/n0-computer/iroh)
- dht: [pkarr](https://github.com/nuhvi/pkarr)
- mdns: [simple-mdns](https://github.com/balliegojr/simple-dns)

## Example
```rust
const ALPN: &[u8] = b"/p2p/ping/1";

#[derive(Debug, Deserialize, Serialize)]
pub struct Ping(u16);

#[derive(Debug, Deserialize, Serialize)]
pub struct Pong(u16);

pub struct PingPong;

impl Protocol for PingPong {
    const ID: u16 = 0;
    const REQ_BUF: usize = 1024;
    const RES_BUF: usize = 1024;
    type Request = Ping;
    type Response = Pong;
}

impl RequestHandler<Self> for PingPong {
    fn request(
        &self,
        _peer_id: PeerId,
        request: <Self as Protocol>::Request,
        response: oneshot::Sender<<Self as Protocol>::Response>,
    ) -> Result<()> {
        response
            .send(Pong(request.0))
            .map_err(|_| anyhow::anyhow!("response channel closed"))?;
        Ok(())
    }
}

let mut builder = ProtocolHandler::builder();
builder.register_request_handler(PingPong);
let handler = builder.build();

let mut builder = Endpoint::builder(ALPN.to_vec());
builder.handler(handler);
let endpoint = builder.build().await?;
let pong = endpoint.request::<PingPong>(&peer, &Ping(42)).await?;
assert_eq!(pong.0, 42);
```

## License
Apache-2.0 + MIT