experiments with n0-snafu

Author: dignifiedquire

Cargo.lock

@@ -70,6 +70,8 @@ webpki-roots = "0.26"
 data-encoding = "2.6.0"
 lru = "0.12"
 z32 = "1.0.3"
+snafu = { version = "0.8.5", features = ["rust_1_81"] }
+n0-snafu = { path = "../../n0-snafu" }
 
 # server feature
 anyhow = { version = "1", optional = true }
@@ -129,7 +131,7 @@ tracing-test = "0.2.5"
 cfg_aliases = { version = "0.2" }
 
 [features]
-default = ["metrics"]
+default = ["metrics", "server", "test-utils"]
 server = [
     "dep:anyhow",
     "dep:clap",

iroh-relay/Cargo.toml

@@ -15,6 +15,7 @@ use n0_future::{
     split::{split, SplitSink, SplitStream},
     time, Sink, Stream,
 };
+use snafu::{Backtrace, Snafu};
 #[cfg(any(test, feature = "test-utils"))]
 use tracing::warn;
 use tracing::{debug, event, trace, Level};
@@ -38,32 +39,84 @@ mod util;
 
 /// Connection errors
 #[allow(missing_docs)]
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, Snafu)]
 #[non_exhaustive]
 pub enum ConnectError {
-    #[error("Invalid URL for websocket {0}")]
-    InvalidWebsocketUrl(Url),
-    #[error("Invalid relay URL {0}")]
-    InvalidRelayUrl(Url),
-    #[error(transparent)]
-    Websocket(#[from] tokio_tungstenite_wasm::Error),
-    #[error(transparent)]
-    Handshake(#[from] HandshakeError),
-    #[error(transparent)]
-    Dial(#[from] DialError),
-    #[error("Unexpected status during upgrade: {0}")]
-    UnexpectedUpgradeStatus(hyper::StatusCode),
-    #[error("Failed to upgrade response")]
-    Upgrade(#[source] hyper::Error),
-    #[error("Invalid TLS servername")]
-    InvalidTlsServername,
-    #[error("No local address available")]
-    NoLocalAddr,
-    #[error("tls connection failed")]
-    Tls(#[source] std::io::Error),
+    #[snafu(display("Invalid URL for websocket: {url}"))]
+    InvalidWebsocketUrl {
+        url: Url,
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
+    #[snafu(display("Invalid relay URL: {url}"))]
+    InvalidRelayUrl {
+        url: Url,
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
+    #[snafu(transparent)]
+    Websocket {
+        source: tokio_tungstenite_wasm::Error,
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
+    #[snafu(transparent)]
+    Handshake {
+        source: HandshakeError,
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
+    #[snafu(transparent)]
+    Dial {
+        source: DialError,
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
+    #[snafu(display("Unexpected status during upgrade: {code}"))]
+    UnexpectedUpgradeStatus {
+        code: hyper::StatusCode,
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
+    #[snafu(display("Failed to upgrade response"))]
+    Upgrade {
+        source: hyper::Error,
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
+    #[snafu(display("Invalid TLS servername"))]
+    InvalidTlsServername {
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
+    #[snafu(display("No local address available"))]
+    NoLocalAddr {
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
+    #[snafu(display("tls connection failed"))]
+    Tls {
+        source: std::io::Error,
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
     #[cfg(wasm_browser)]
-    #[error("The relay protocol is not available in browsers")]
-    RelayProtoNotAvailable,
+    #[snafu(display("The relay protocol is not available in browsers"))]
+    RelayProtoNotAvailable {
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
 }
 
 /// Dialing errors
@@ -229,7 +282,12 @@ impl ClientBuilder {
         // We need to use the ws:// or wss:// schemes when connecting with websockets, though.
         dial_url
             .set_scheme(if self.use_tls() { "wss" } else { "ws" })
-            .map_err(|_| ConnectError::InvalidWebsocketUrl(dial_url.clone()))?;
+            .map_err(|_| {
+                InvalidWebsocketUrlSnafu {
+                    url: dial_url.clone(),
+                }
+                .build()
+            })?;
 
         debug!(%dial_url, "Dialing relay by websocket");
 

iroh-relay/src/client.rs

@@ -24,6 +24,7 @@ use hyper::{
 };
 use n0_future::{task, time};
 use rustls::client::Resumption;
+use snafu::ResultExt;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tracing::{error, info_span, Instrument};
 
@@ -64,21 +65,21 @@ impl ClientBuilder {
 
         let local_addr = tcp_stream
             .local_addr()
-            .map_err(|_| ConnectError::NoLocalAddr)?;
+            .map_err(|_| NoLocalAddrSnafu.build())?;
 
         debug!(server_addr = ?tcp_stream.peer_addr(), %local_addr, "TCP stream connected");
 
         let response = if self.use_tls() {
             debug!("Starting TLS handshake");
             let hostname = self
                 .tls_servername()
-                .ok_or(ConnectError::InvalidTlsServername)?;
+                .ok_or_else(|| InvalidTlsServernameSnafu.build())?;
 
             let hostname = hostname.to_owned();
             let tls_stream = tls_connector
                 .connect(hostname, tcp_stream)
                 .await
-                .map_err(ConnectError::Tls)?;
+                .context(TlsSnafu)?;
             debug!("tls_connector connect success");
             Self::start_upgrade(tls_stream, url).await?
         } else {
@@ -87,13 +88,18 @@ impl ClientBuilder {
         };
 
         if response.status() != hyper::StatusCode::SWITCHING_PROTOCOLS {
-            return Err(ConnectError::UnexpectedUpgradeStatus(response.status()));
+            UnexpectedUpgradeStatusSnafu {
+                code: response.status(),
+            }
+            .fail()?;
         }
+        let err = std::io::Error::new(std::io::ErrorKind::Other, "other".to_string());
+
+        Err(err).context(TlsSnafu)?;
+        // NoLocalAddrSnafu.fail()?;
 
         debug!("starting upgrade");
-        let upgraded = hyper::upgrade::on(response)
-            .await
-            .map_err(ConnectError::Upgrade)?;
+        let upgraded = hyper::upgrade::on(response).await.context(UpgradeSnafu)?;
 
         debug!("connection upgraded");
         let conn = downcast_upgrade(upgraded).expect("must use TcpStream or client::TlsStream");
@@ -112,14 +118,18 @@ impl ClientBuilder {
         T: AsyncRead + AsyncWrite + Send + Unpin + 'static,
     {
         use hyper_util::rt::TokioIo;
-        let host_header_value = host_header_value(relay_url.clone())
-            .ok_or_else(|| ConnectError::InvalidRelayUrl(relay_url.into()))?;
+        let host_header_value = host_header_value(relay_url.clone()).ok_or_else(|| {
+            InvalidRelayUrlSnafu {
+                url: Url::from(relay_url),
+            }
+            .build()
+        })?;
 
         let io = TokioIo::new(io);
         let (mut request_sender, connection) = hyper::client::conn::http1::Builder::new()
             .handshake(io)
             .await
-            .map_err(ConnectError::Upgrade)?;
+            .context(UpgradeSnafu)?;
         task::spawn(
             // This task drives the HTTP exchange, completes once connection is upgraded.
             async move {
@@ -141,10 +151,7 @@ impl ClientBuilder {
             .header(HOST, host_header_value)
             .body(http_body_util::Empty::<hyper::body::Bytes>::new())
             .expect("fixed config");
-        request_sender
-            .send_request(req)
-            .await
-            .map_err(ConnectError::Upgrade)
+        request_sender.send_request(req).await.context(UpgradeSnafu)
     }
 
     fn tls_servername(&self) -> Option<rustls::pki_types::ServerName> {