feat(iroh)!: make ProtocolHandler use async functions (#3320)

## Description

This changes the `ProtocolHandler` trait so that the functions return
`impl Future` instead of `BoxFuture`, which means implementors can
simply implement the trait with `async fn`. We don't even need a
`'static` bound on these futures, so you can use `&self` freely without
cloning and moving.

Internally, we still box the futures return by `accept`, `on_connecting`
and `shutdown`. So performance wise this change should not have any
effects. But the boxing is hidden from the user and implementing the
trait now feels a lot more normal and simpler.

## Breaking Changes

* `iroh::protocol::ProtocolHandler` methods now return `impl Future`
instead of `BoxFuture`. You can simply remove the `Box::pin(async move
{})` from the implementations and instead implement the methods as
`async fn`. See the updated documentation for the `iroh::protocol`
module for an example.
* `iroh::protocol::ProtocolHandler` is no longer dyn-compatible. If you
need a dyn-compatible version, you need to build your own dyn-compatible
wrapper trait. See the (non-public) `DynProtocolHandler` in
`iroh::protocol` as an example.

## Notes & open questions

<!-- Any notes, remarks or open questions you have to make about the PR.
-->

## Change checklist
<!-- Remove any that are not relevant. -->
- [x] Self-review.
- [x] Documentation updates following the [style
guide](https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text),
if relevant.
- [x] Tests if relevant.
- [x] All breaking changes documented.
- [x] List all breaking changes in the above "Breaking Changes" section.
- [ ] Open an issue or PR on any number0 repos that are affected by this
breaking change. Give guidance on how the updates should be handled or
do the actual updates themselves. The major ones are:
    - [ ] [`quic-rpc`](https://github.com/n0-computer/quic-rpc)
    - [ ] [`iroh-gossip`](https://github.com/n0-computer/iroh-gossip)
    - [ ] [`iroh-blobs`](https://github.com/n0-computer/iroh-blobs)
    - [ ] [`dumbpipe`](https://github.com/n0-computer/dumbpipe)
    - [ ] [`sendme`](https://github.com/n0-computer/sendme)

Author: Frando

README.md

@@ -97,18 +97,16 @@ let router = Router::builder(endpoint)
 struct Echo;
 
 impl ProtocolHandler for Echo {
-    fn accept(&self, connection: Connection) -> BoxedFuture<Result<()>> {
-        Box::pin(async move {
-            let (mut send, mut recv) = connection.accept_bi().await?;
+    async fn accept(&self, connection: Connection) -> Result<()> {
+        let (mut send, mut recv) = connection.accept_bi().await?;
 
-            // Echo any bytes received back directly.
-            let bytes_sent = tokio::io::copy(&mut recv, &mut send).await?;
+        // Echo any bytes received back directly.
+        let bytes_sent = tokio::io::copy(&mut recv, &mut send).await?;
 
-            send.finish()?;
-            connection.closed().await;
+        send.finish()?;
+        connection.closed().await;
 
-            Ok(())
-        })
+        Ok(())
     }
 }
 ```

iroh/examples/echo.rs

@@ -13,7 +13,6 @@ use iroh::{
     watcher::Watcher as _,
     Endpoint, NodeAddr,
 };
-use n0_future::boxed::BoxFuture;
 
 /// Each protocol is identified by its ALPN string.
 ///
@@ -84,31 +83,28 @@ impl ProtocolHandler for Echo {
     ///
     /// The returned future runs on a newly spawned tokio task, so it can run as long as
     /// the connection lasts.
-    fn accept(&self, connection: Connection) -> BoxFuture<Result<()>> {
-        // We have to return a boxed future from the handler.
-        Box::pin(async move {
-            // We can get the remote's node id from the connection.
-            let node_id = connection.remote_node_id()?;
-            println!("accepted connection from {node_id}");
-
-            // Our protocol is a simple request-response protocol, so we expect the
-            // connecting peer to open a single bi-directional stream.
-            let (mut send, mut recv) = connection.accept_bi().await?;
-
-            // Echo any bytes received back directly.
-            // This will keep copying until the sender signals the end of data on the stream.
-            let bytes_sent = tokio::io::copy(&mut recv, &mut send).await?;
-            println!("Copied over {bytes_sent} byte(s)");
-
-            // By calling `finish` on the send stream we signal that we will not send anything
-            // further, which makes the receive stream on the other end terminate.
-            send.finish()?;
-
-            // Wait until the remote closes the connection, which it does once it
-            // received the response.
-            connection.closed().await;
-
-            Ok(())
-        })
+    async fn accept(&self, connection: Connection) -> Result<()> {
+        // We can get the remote's node id from the connection.
+        let node_id = connection.remote_node_id()?;
+        println!("accepted connection from {node_id}");
+
+        // Our protocol is a simple request-response protocol, so we expect the
+        // connecting peer to open a single bi-directional stream.
+        let (mut send, mut recv) = connection.accept_bi().await?;
+
+        // Echo any bytes received back directly.
+        // This will keep copying until the sender signals the end of data on the stream.
+        let bytes_sent = tokio::io::copy(&mut recv, &mut send).await?;
+        println!("Copied over {bytes_sent} byte(s)");
+
+        // By calling `finish` on the send stream we signal that we will not send anything
+        // further, which makes the receive stream on the other end terminate.
+        send.finish()?;
+
+        // Wait until the remote closes the connection, which it does once it
+        // received the response.
+        connection.closed().await;
+
+        Ok(())
     }
 }

iroh/examples/search.rs

@@ -38,7 +38,6 @@ use iroh::{
     protocol::{ProtocolHandler, Router},
     Endpoint, NodeId,
 };
-use n0_future::boxed::BoxFuture;
 use tokio::sync::Mutex;
 use tracing_subscriber::{prelude::*, EnvFilter};
 
@@ -127,40 +126,36 @@ impl ProtocolHandler for BlobSearch {
     ///
     /// The returned future runs on a newly spawned tokio task, so it can run as long as
     /// the connection lasts.
-    fn accept(&self, connection: Connection) -> BoxFuture<Result<()>> {
-        let this = self.clone();
-        // We have to return a boxed future from the handler.
-        Box::pin(async move {
-            // We can get the remote's node id from the connection.
-            let node_id = connection.remote_node_id()?;
-            println!("accepted connection from {node_id}");
-
-            // Our protocol is a simple request-response protocol, so we expect the
-            // connecting peer to open a single bi-directional stream.
-            let (mut send, mut recv) = connection.accept_bi().await?;
-
-            // We read the query from the receive stream, while enforcing a max query length.
-            let query_bytes = recv.read_to_end(64).await?;
-
-            // Now, we can perform the actual query on our local database.
-            let query = String::from_utf8(query_bytes)?;
-            let num_matches = this.query_local(&query).await;
-
-            // We want to return a list of hashes. We do the simplest thing possible, and just send
-            // one hash after the other. Because the hashes have a fixed size of 32 bytes, this is
-            // very easy to parse on the other end.
-            send.write_all(&num_matches.to_le_bytes()).await?;
-
-            // By calling `finish` on the send stream we signal that we will not send anything
-            // further, which makes the receive stream on the other end terminate.
-            send.finish()?;
-
-            // Wait until the remote closes the connection, which it does once it
-            // received the response.
-            connection.closed().await;
-
-            Ok(())
-        })
+    async fn accept(&self, connection: Connection) -> Result<()> {
+        // We can get the remote's node id from the connection.
+        let node_id = connection.remote_node_id()?;
+        println!("accepted connection from {node_id}");
+
+        // Our protocol is a simple request-response protocol, so we expect the
+        // connecting peer to open a single bi-directional stream.
+        let (mut send, mut recv) = connection.accept_bi().await?;
+
+        // We read the query from the receive stream, while enforcing a max query length.
+        let query_bytes = recv.read_to_end(64).await?;
+
+        // Now, we can perform the actual query on our local database.
+        let query = String::from_utf8(query_bytes)?;
+        let num_matches = self.query_local(&query).await;
+
+        // We want to return a list of hashes. We do the simplest thing possible, and just send
+        // one hash after the other. Because the hashes have a fixed size of 32 bytes, this is
+        // very easy to parse on the other end.
+        send.write_all(&num_matches.to_le_bytes()).await?;
+
+        // By calling `finish` on the send stream we signal that we will not send anything
+        // further, which makes the receive stream on the other end terminate.
+        send.finish()?;
+
+        // Wait until the remote closes the connection, which it does once it
+        // received the response.
+        connection.closed().await;
+
+        Ok(())
     }
 }
 

iroh/src/endpoint.rs

@@ -1991,7 +1991,7 @@ impl Connection {
     /// [`Connecting::handshake_data()`] succeeds. See that method's documentations for
     /// details on the returned value.
     ///
-    /// [`Connection::handshake_data()`]: crate::Connecting::handshake_data
+    /// [`Connection::handshake_data()`]: crate::endpoint::Connecting::handshake_data
     #[inline]
     pub fn handshake_data(&self) -> Option<Box<dyn Any>> {
         self.inner.handshake_data()