WIP convert final error from thiserror to snafu and drop thiserror dep

No backtraces yet!

Author: rklaehn

Cargo.lock

@@ -38,7 +38,6 @@ irpc = { version = "0.4.0", features = ["rpc", "quinn_endpoint_setup", "message_
 iroh-metrics = { version = "0.32.0" }
 hashlink = "0.10.0"
 futures-buffered = "0.2.11"
-thiserror = "2.0.12"
 
 [dev-dependencies]
 clap = { version = "4.5.31", features = ["derive"] }

Cargo.toml

@@ -94,9 +94,9 @@ impl GetProgress {
 
     pub async fn complete(self) -> GetResult<Stats> {
         just_result(self.stream()).await.unwrap_or_else(|| {
-            Err(GetError::LocalFailure(anyhow::anyhow!(
-                "stream closed without result"
-            )))
+            Err(GetError::LocalFailure {
+                source: anyhow::anyhow!("stream closed without result"),
+            })
         })
     }
 }
@@ -502,12 +502,18 @@ impl Remote {
         progress: impl Sink<u64, Error = io::Error>,
     ) -> GetResult<Stats> {
         let content = content.into();
-        let local = self.local(content).await.map_err(GetError::LocalFailure)?;
+        let local = self
+            .local(content)
+            .await
+            .map_err(|source| GetError::LocalFailure { source })?;
         if local.is_complete() {
             return Ok(Default::default());
         }
         let request = local.missing();
-        let conn = conn.connection().await.map_err(GetError::LocalFailure)?;
+        let conn = conn
+            .connection()
+            .await
+            .map_err(|source| GetError::LocalFailure { source })?;
         let stats = self.execute_get_sink(conn, request, progress).await?;
         Ok(stats)
     }
@@ -676,9 +682,9 @@ impl Remote {
                     store
                         .get_bytes(root)
                         .await
-                        .map_err(|e| GetError::LocalFailure(e.into()))?,
+                        .map_err(|e| GetError::LocalFailure { source: e.into() })?,
                 )
-                .map_err(GetError::BadRequest)?;
+                .map_err(|source| GetError::BadRequest { source })?;
                 // let mut hash_seq = LazyHashSeq::new(store.blobs().clone(), root);
                 loop {
                     let at_start_child = match next_child {
@@ -883,7 +889,7 @@ async fn get_blob_ranges_impl(
     let handle = store
         .import_bao(hash, size, buffer_size)
         .await
-        .map_err(|e| GetError::LocalFailure(e.into()))?;
+        .map_err(|e| GetError::LocalFailure { source: e.into() })?;
     let write = async move {
         GetResult::Ok(loop {
             match content.next().await {
@@ -892,7 +898,7 @@ async fn get_blob_ranges_impl(
                     progress
                         .send(next.stats().payload_bytes_read)
                         .await
-                        .map_err(|e| GetError::LocalFailure(e.into()))?;
+                        .map_err(|e| GetError::LocalFailure { source: e.into() })?;
                     handle.tx.send(item).await?;
                     content = next;
                 }
@@ -904,8 +910,8 @@ async fn get_blob_ranges_impl(
         })
     };
     let complete = async move {
-        handle.rx.await.map_err(|e| {
-            GetError::LocalFailure(anyhow::anyhow!("error reading from import stream: {e}"))
+        handle.rx.await.map_err(|e| GetError::LocalFailure {
+            source: anyhow::anyhow!("error reading from import stream: {e}"),
         })
     };
     let (_, end) = tokio::try_join!(complete, write)?;

src/api/remote.rs

@@ -129,7 +129,9 @@ pub mod fsm {
         let (mut writer, reader) = connection.open_bi().await?;
         let request = Request::GetMany(request);
         let request_bytes =
-            postcard::to_stdvec(&request).map_err(|e| GetError::BadRequest(e.into()))?;
+            postcard::to_stdvec(&request).map_err(|source| GetError::BadRequest {
+                source: source.into(),
+            })?;
         writer.write_all(&request_bytes).await?;
         writer.finish()?;
         let Request::GetMany(request) = request else {

src/get.rs

@@ -1,43 +1,60 @@
 //! Error returned from get operations
 
 use iroh::endpoint::{self, ClosedStream};
+use n0_snafu::SpanTrace;
+use nested_enum_utils::common_fields;
+use snafu::{Backtrace, Snafu};
+
+#[common_fields({
+    backtrace: Option<Backtrace>,
+    #[snafu(implicit)]
+    span_trace: SpanTrace,
+})]
+#[derive(Debug, Snafu)]
+pub enum GetNotFoundError {
+    AtBlobHeader {},
+}
 
 /// Failures for a get operation
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, Snafu)]
 pub enum GetError {
     /// Hash not found, or a requested chunk for the hash not found.
-    #[error("Data for hash not found")]
-    NotFound(#[source] anyhow::Error),
+    #[snafu(display("Data for hash not found"))]
+    NotFound { source: GetNotFoundError },
     /// Remote has reset the connection.
-    #[error("Remote has reset the connection")]
-    RemoteReset(#[source] anyhow::Error),
+    #[snafu(display("Remote has reset the connection"))]
+    RemoteReset { source: anyhow::Error },
     /// Remote behaved in a non-compliant way.
-    #[error("Remote behaved in a non-compliant way")]
-    NoncompliantNode(#[source] anyhow::Error),
+    #[snafu(display("Remote behaved in a non-compliant way"))]
+    NoncompliantNode { source: anyhow::Error },
 
     /// Network or IO operation failed.
-    #[error("A network or IO operation failed")]
-    Io(#[source] anyhow::Error),
+    #[snafu(display("A network or IO operation failed"))]
+    Io { source: anyhow::Error },
 
     /// Our download request is invalid.
-    #[error("Our download request is invalid")]
-    BadRequest(#[source] anyhow::Error),
+    #[snafu(display("Our download request is invalid"))]
+    BadRequest { source: anyhow::Error },
     /// Operation failed on the local node.
-    #[error("Operation failed on the local node")]
-    LocalFailure(#[source] anyhow::Error),
+    #[snafu(display("Operation failed on the local node"))]
+    LocalFailure { source: anyhow::Error },
 }
 
 pub type GetResult<T> = std::result::Result<T, GetError>;
 
 impl From<irpc::channel::SendError> for GetError {
     fn from(value: irpc::channel::SendError) -> Self {
-        Self::LocalFailure(value.into())
+        Self::LocalFailure {
+            source: value.into(),
+        }
     }
 }
 
 impl<T: Send + Sync + 'static> From<tokio::sync::mpsc::error::SendError<T>> for GetError {
     fn from(value: tokio::sync::mpsc::error::SendError<T>) -> Self {
-        Self::LocalFailure(value.into())
+        Self::LocalFailure {
+            source: value.into(),
+        }
     }
 }
 
@@ -49,40 +66,40 @@ impl From<endpoint::ConnectionError> for GetError {
             e @ ConnectionError::VersionMismatch => {
                 // > The peer doesn't implement any supported version
                 // unsupported version is likely a long time error, so this peer is not usable
-                GetError::NoncompliantNode(e.into())
+                GetError::NoncompliantNode { source: e.into() }
             }
             e @ ConnectionError::TransportError(_) => {
                 // > The peer violated the QUIC specification as understood by this implementation
                 // bad peer we don't want to keep around
-                GetError::NoncompliantNode(e.into())
+                GetError::NoncompliantNode { source: e.into() }
             }
             e @ ConnectionError::ConnectionClosed(_) => {
                 // > The peer's QUIC stack aborted the connection automatically
                 // peer might be disconnecting or otherwise unavailable, drop it
-                GetError::Io(e.into())
+                GetError::Io { source: e.into() }
             }
             e @ ConnectionError::ApplicationClosed(_) => {
                 // > The peer closed the connection
                 // peer might be disconnecting or otherwise unavailable, drop it
-                GetError::Io(e.into())
+                GetError::Io { source: e.into() }
             }
             e @ ConnectionError::Reset => {
                 // > The peer is unable to continue processing this connection, usually due to having restarted
-                GetError::RemoteReset(e.into())
+                GetError::RemoteReset { source: e.into() }
             }
             e @ ConnectionError::TimedOut => {
                 // > Communication with the peer has lapsed for longer than the negotiated idle timeout
-                GetError::Io(e.into())
+                GetError::Io { source: e.into() }
             }
             e @ ConnectionError::LocallyClosed => {
                 // > The local application closed the connection
                 // TODO(@divma): don't see how this is reachable but let's just not use the peer
-                GetError::Io(e.into())
+                GetError::Io { source: e.into() }
             }
             e @ ConnectionError::CidsExhausted => {
                 // > The connection could not be created because not enough of the CID space
                 // > is available
-                GetError::Io(e.into())
+                GetError::Io { source: e.into() }
             }
         }
     }
@@ -92,32 +109,38 @@ impl From<endpoint::ReadError> for GetError {
     fn from(value: endpoint::ReadError) -> Self {
         use endpoint::ReadError;
         match value {
-            e @ ReadError::Reset(_) => GetError::RemoteReset(e.into()),
+            e @ ReadError::Reset(_) => GetError::RemoteReset { source: e.into() },
             ReadError::ConnectionLost(conn_error) => conn_error.into(),
             ReadError::ClosedStream
             | ReadError::IllegalOrderedRead
             | ReadError::ZeroRttRejected => {
                 // all these errors indicate the peer is not usable at this moment
-                GetError::Io(value.into())
+                GetError::Io {
+                    source: value.into(),
+                }
             }
         }
     }
 }
 impl From<ClosedStream> for GetError {
     fn from(value: ClosedStream) -> Self {
-        GetError::Io(value.into())
+        GetError::Io {
+            source: value.into(),
+        }
     }
 }
 
 impl From<quinn::WriteError> for GetError {
     fn from(value: quinn::WriteError) -> Self {
         use quinn::WriteError;
         match value {
-            e @ WriteError::Stopped(_) => GetError::RemoteReset(e.into()),
+            e @ WriteError::Stopped(_) => GetError::RemoteReset { source: e.into() },
             WriteError::ConnectionLost(conn_error) => conn_error.into(),
             WriteError::ClosedStream | WriteError::ZeroRttRejected => {
                 // all these errors indicate the peer is not usable at this moment
-                GetError::Io(value.into())
+                GetError::Io {
+                    source: value.into(),
+                }
             }
         }
     }
@@ -129,17 +152,17 @@ impl From<crate::get::fsm::ConnectedNextError> for GetError {
         match value {
             e @ PostcardSer { .. } => {
                 // serialization errors indicate something wrong with the request itself
-                GetError::BadRequest(e.into())
+                GetError::BadRequest { source: e.into() }
             }
             e @ RequestTooBig { .. } => {
                 // request will never be sent, drop it
-                GetError::BadRequest(e.into())
+                GetError::BadRequest { source: e.into() }
             }
             Write { source, .. } => source.into(),
             Closed { source, .. } => source.into(),
             e @ Io { .. } => {
                 // io errors are likely recoverable
-                GetError::Io(e.into())
+                GetError::Io { source: e.into() }
             }
         }
     }
@@ -149,15 +172,23 @@ impl From<crate::get::fsm::AtBlobHeaderNextError> for GetError {
     fn from(value: crate::get::fsm::AtBlobHeaderNextError) -> Self {
         use crate::get::fsm::AtBlobHeaderNextError::*;
         match value {
-            e @ NotFound { .. } => {
+            NotFound {
+                backtrace,
+                span_trace,
+            } => {
                 // > This indicates that the provider does not have the requested data.
                 // peer might have the data later, simply retry it
-                GetError::NotFound(e.into())
+                GetError::NotFound {
+                    source: GetNotFoundError::AtBlobHeader {
+                        backtrace,
+                        span_trace,
+                    },
+                }
             }
             EndpointRead { source, .. } => source.into(),
             e @ Io { .. } => {
                 // io errors are likely recoverable
-                GetError::Io(e.into())
+                GetError::Io { source: e.into() }
             }
         }
     }
@@ -168,18 +199,44 @@ impl From<crate::get::fsm::DecodeError> for GetError {
         use crate::get::fsm::DecodeError::*;
 
         match value {
-            e @ ChunkNotFound { .. } => GetError::NotFound(e.into()),
-            e @ ParentNotFound { .. } => GetError::NotFound(e.into()),
-            e @ LeafNotFound { .. } => GetError::NotFound(e.into()),
+            ChunkNotFound {
+                backtrace,
+                span_trace,
+            } => GetError::NotFound {
+                source: GetNotFoundError::AtBlobHeader {
+                    backtrace,
+                    span_trace,
+                },
+            },
+            ParentNotFound {
+                backtrace,
+                span_trace,
+                ..
+            } => GetError::NotFound {
+                source: GetNotFoundError::AtBlobHeader {
+                    backtrace,
+                    span_trace,
+                },
+            },
+            LeafNotFound {
+                backtrace,
+                span_trace,
+                ..
+            } => GetError::NotFound {
+                source: GetNotFoundError::AtBlobHeader {
+                    backtrace,
+                    span_trace,
+                },
+            },
             e @ ParentHashMismatch { .. } => {
                 // TODO(@divma): did the peer sent wrong data? is it corrupted? did we sent a wrong
                 // request?
-                GetError::NoncompliantNode(e.into())
+                GetError::NoncompliantNode { source: e.into() }
             }
             e @ LeafHashMismatch { .. } => {
                 // TODO(@divma): did the peer sent wrong data? is it corrupted? did we sent a wrong
                 // request?
-                GetError::NoncompliantNode(e.into())
+                GetError::NoncompliantNode { source: e.into() }
             }
             Read { source, .. } => source.into(),
             DecodeIo { source, .. } => source.into(),
@@ -191,6 +248,8 @@ impl From<std::io::Error> for GetError {
     fn from(value: std::io::Error) -> Self {
         // generally consider io errors recoverable
         // we might want to revisit this at some point
-        GetError::Io(value.into())
+        GetError::Io {
+            source: value.into(),
+        }
     }
 }