feat: make Connection::remote_id and Connection::alpn infallible

Author: “ramfox”

iroh/examples/0rtt.rs

@@ -1,15 +1,21 @@
-use std::{env, future::Future, str::FromStr, time::Instant};
+use std::{
+    env,
+    future::Future,
+    str::FromStr,
+    time::{Duration, Instant},
+};
 
 use clap::Parser;
 use data_encoding::HEXLOWER;
 use iroh::{
     SecretKey,
-    endpoint::{Connecting, Connection},
+    endpoint::{Connecting, Connection, ZRTTConnection},
 };
 use iroh_base::ticket::EndpointTicket;
 use n0_future::{StreamExt, future};
 use n0_snafu::ResultExt;
 use n0_watcher::Watcher;
+use quinn::VarInt;
 use tracing::{info, trace};
 
 const PINGPONG_ALPN: &[u8] = b"0rtt-pingpong";
@@ -50,7 +56,7 @@ pub fn get_or_generate_secret_key() -> n0_snafu::Result<SecretKey> {
 /// read the response immediately. Otherwise, the stream pair is bad and we need
 /// to open a new stream pair.
 async fn pingpong(
-    connection: &Connection,
+    connection: &Conn,
     proceed: impl Future<Output = bool>,
     x: u64,
 ) -> n0_snafu::Result<()> {
@@ -74,16 +80,46 @@ async fn pingpong(
     Ok(())
 }
 
-async fn pingpong_0rtt(connecting: Connecting, i: u64) -> n0_snafu::Result<Connection> {
+enum Conn {
+    ZRTT(ZRTTConnection),
+    Full(Connection),
+}
+
+impl Conn {
+    fn open_bi(&self) -> quinn::OpenBi<'_> {
+        match self {
+            Conn::ZRTT(conn) => conn.open_bi(),
+            Conn::Full(conn) => conn.open_bi(),
+        }
+    }
+
+    fn close(&self, error_code: VarInt, reason: &[u8]) {
+        match self {
+            Conn::ZRTT(conn) => conn.close(error_code, reason),
+            Conn::Full(conn) => conn.close(error_code, reason),
+        }
+    }
+
+    fn rtt(&self) -> Duration {
+        match self {
+            Conn::ZRTT(conn) => conn.rtt(),
+            Conn::Full(conn) => conn.rtt(),
+        }
+    }
+}
+
+async fn pingpong_0rtt(connecting: Connecting, i: u64) -> n0_snafu::Result<Conn> {
     let connection = match connecting.into_0rtt() {
         Ok((connection, accepted)) => {
             trace!("0-RTT possible from our side");
+            let connection = Conn::ZRTT(connection);
             pingpong(&connection, accepted, i).await?;
             connection
         }
         Err(connecting) => {
             trace!("0-RTT not possible from our side");
             let connection = connecting.await.e()?;
+            let connection = Conn::Full(connection);
             pingpong(&connection, future::ready(true), i).await?;
             connection
         }
@@ -106,6 +142,7 @@ async fn connect(args: Args) -> n0_snafu::Result<()> {
             .await?;
         let connection = if args.disable_0rtt {
             let connection = connecting.await.e()?;
+            let connection = Conn::Full(connection);
             trace!("connecting without 0-RTT");
             pingpong(&connection, future::ready(true), i).await?;
             connection

iroh/examples/dht_discovery.rs

@@ -89,7 +89,7 @@ async fn chat_server(args: Args) -> n0_snafu::Result<()> {
         };
         tokio::spawn(async move {
             let connection = connecting.await.e()?;
-            let remote_endpoint_id = connection.remote_id()?;
+            let remote_endpoint_id = connection.remote_id();
             println!("got connection from {remote_endpoint_id}");
             // just leave the tasks hanging. this is just an example.
             let (mut writer, mut reader) = connection.accept_bi().await.e()?;

iroh/examples/echo-no-router.rs

@@ -90,7 +90,7 @@ async fn start_accept_side() -> Result<Endpoint> {
                     let connection = incoming.await.e()?;
 
                     // We can get the remote's endpoint id from the connection.
-                    let endpoint_id = connection.remote_id()?;
+                    let endpoint_id = connection.remote_id();
                     println!("accepted connection from {endpoint_id}");
 
                     // Our protocol is a simple request-response protocol, so we expect the

iroh/examples/echo.rs

@@ -86,7 +86,7 @@ impl ProtocolHandler for Echo {
     /// the connection lasts.
     async fn accept(&self, connection: Connection) -> Result<(), AcceptError> {
         // We can get the remote's endpoint id from the connection.
-        let endpoint_id = connection.remote_id()?;
+        let endpoint_id = connection.remote_id();
         println!("accepted connection from {endpoint_id}");
 
         // Our protocol is a simple request-response protocol, so we expect the

iroh/examples/listen-unreliable.rs

@@ -73,7 +73,7 @@ async fn main() -> Result<()> {
         };
         let alpn = connecting.alpn().await?;
         let conn = connecting.await.e()?;
-        let endpoint_id = conn.remote_id()?;
+        let endpoint_id = conn.remote_id();
         info!(
             "new (unreliable) connection from {endpoint_id} with ALPN {}",
             String::from_utf8_lossy(&alpn),

iroh/examples/listen.rs

@@ -72,7 +72,7 @@ async fn main() -> n0_snafu::Result<()> {
         };
         let alpn = connecting.alpn().await?;
         let conn = connecting.await.e()?;
-        let endpoint_id = conn.remote_id()?;
+        let endpoint_id = conn.remote_id();
         info!(
             "new connection from {endpoint_id} with ALPN {}",
             String::from_utf8_lossy(&alpn),

iroh/examples/screening-connection.rs

@@ -125,7 +125,7 @@ impl ProtocolHandler for ScreenedEcho {
     /// the connection lasts.
     async fn accept(&self, connection: Connection) -> Result<(), AcceptError> {
         // We can get the remote's endpoint id from the connection.
-        let endpoint_id = connection.remote_id()?;
+        let endpoint_id = connection.remote_id();
         println!("accepted connection from {endpoint_id}");
 
         // Our protocol is a simple request-response protocol, so we expect the

iroh/examples/search.rs

@@ -128,7 +128,7 @@ impl ProtocolHandler for BlobSearch {
     /// the connection lasts.
     async fn accept(&self, connection: Connection) -> Result<(), AcceptError> {
         // We can get the remote's endpoint id from the connection.
-        let endpoint_id = connection.remote_id()?;
+        let endpoint_id = connection.remote_id();
         println!("accepted connection from {endpoint_id}");
 
         // Our protocol is a simple request-response protocol, so we expect the

iroh/examples/transfer.rs

@@ -329,7 +329,7 @@ async fn provide(endpoint: Endpoint, size: u64) -> Result<()> {
         let endpoint_clone = endpoint.clone();
         tokio::spawn(async move {
             let conn = connecting.await.e()?;
-            let endpoint_id = conn.remote_id()?;
+            let endpoint_id = conn.remote_id();
             info!(
                 "new connection from {endpoint_id} with ALPN {}",
                 String::from_utf8_lossy(TRANSFER_ALPN),