more fix fix fix

Author: Frando

examples/compression.rs

@@ -5,7 +5,6 @@
 mod common;
 use std::{fmt::Debug, path::PathBuf};
 
-use n0_error::Result;
 use clap::Parser;
 use common::setup_logging;
 use iroh::protocol::ProtocolHandler;
@@ -20,6 +19,7 @@ use iroh_blobs::{
     store::mem::MemStore,
     ticket::BlobTicket,
 };
+use n0_error::{Result, StdResultExt};
 use tracing::debug;
 
 use crate::common::get_or_generate_secret_key;
@@ -200,15 +200,15 @@ async fn main() -> Result<()> {
             println!("Node is running. Press Ctrl-C to exit.");
             tokio::signal::ctrl_c().await?;
             println!("Shutting down.");
-            router.shutdown().await?;
+            router.shutdown().await.anyerr()?;
         }
         Args::Get { ticket, target } => {
             let store = MemStore::new();
             let conn = endpoint
                 .connect(ticket.addr().clone(), lz4::Compression::ALPN)
                 .await?;
             let connection_id = conn.stable_id() as u64;
-            let (send, recv) = conn.open_bi().await?;
+            let (send, recv) = conn.open_bi().await.anyerr()?;
             let send = compression.send_stream(send);
             let recv = compression.recv_stream(recv);
             let sp = StreamPair::new(connection_id, recv, send);

examples/custom-protocol.rs

@@ -40,7 +40,6 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use n0_error::Result;
 use clap::Parser;
 use iroh::{
     discovery::pkarr::PkarrResolver,
@@ -49,6 +48,7 @@ use iroh::{
     Endpoint, EndpointId,
 };
 use iroh_blobs::{api::Store, store::mem::MemStore, BlobsProtocol, Hash};
+use n0_error::{anyerr, Result, StdResultExt};
 mod common;
 use common::{get_or_generate_secret_key, setup_logging};
 
@@ -110,7 +110,7 @@ async fn listen(text: Vec<String>) -> Result<()> {
 
     // Wait for Ctrl-C to be pressed.
     tokio::signal::ctrl_c().await?;
-    node.shutdown().await?;
+    node.shutdown().await.anyerr()?;
     Ok(())
 }
 
@@ -275,14 +275,14 @@ pub async fn query_remote(
     let blobs_conn = endpoint.connect(endpoint_id, iroh_blobs::ALPN).await?;
 
     // Open a bi-directional in our connection.
-    let (mut send, mut recv) = conn.open_bi().await?;
+    let (mut send, mut recv) = conn.open_bi().await.anyerr()?;
 
     // Send our query.
-    send.write_all(query.as_bytes()).await?;
+    send.write_all(query.as_bytes()).await.anyerr()?;
 
     // Finish the send stream, signalling that no further data will be sent.
     // This makes the `read_to_end` call on the accepting side terminate.
-    send.finish()?;
+    send.finish().anyerr()?;
 
     // In this example, we simply collect all results into a vector.
     // For real protocols, you'd usually want to return a stream of results instead.
@@ -298,7 +298,7 @@ pub async fn query_remote(
             // so in this case we break our loop.
             Err(iroh::endpoint::ReadExactError::FinishedEarly(_)) => break,
             // Other errors are connection errors, so we bail.
-            Err(err) => return Err(err.into()),
+            Err(err) => return Err(anyerr!(err)),
             Ok(_) => {}
         };
         // Upcast the raw bytes to the `Hash` type.
@@ -315,7 +315,7 @@ pub async fn query_remote(
 /// Read a blob from the local blob store and print it to STDOUT.
 async fn read_and_print(store: &Store, hash: Hash) -> Result<()> {
     let content = store.get_bytes(hash).await?;
-    let message = String::from_utf8(content.to_vec())?;
+    let message = String::from_utf8(content.to_vec()).anyerr()?;
     println!("{}: {message}", hash.fmt_short());
     Ok(())
 }

examples/get-blob.rs

@@ -5,6 +5,7 @@ use clap::Parser;
 use common::setup_logging;
 use iroh::discovery::pkarr::PkarrResolver;
 use iroh_blobs::{get::request::GetBlobItem, ticket::BlobTicket, BlobFormat};
+use n0_error::bail_any;
 use n0_future::StreamExt;
 use tokio::io::AsyncWriteExt;
 
@@ -54,10 +55,10 @@ async fn main() -> n0_error::Result<()> {
                     break stats;
                 }
                 Some(GetBlobItem::Error(err)) => {
-                    n0_error::bail!("Error while streaming blob: {err}");
+                    bail_any!(err, "Error while streaming blob");
                 }
                 None => {
-                    n0_error::bail!("Stream ended unexpectedly.");
+                    bail_any!("Stream ended unexpectedly.");
                 }
             }
         }

examples/limit.rs

@@ -18,7 +18,6 @@ use std::{
     },
 };
 
-use n0_error::Result;
 use clap::Parser;
 use common::setup_logging;
 use iroh::{protocol::Router, EndpointAddr, EndpointId, SecretKey};
@@ -31,6 +30,7 @@ use iroh_blobs::{
     ticket::BlobTicket,
     BlobFormat, BlobsProtocol, Hash,
 };
+use n0_error::{Result, StdResultExt};
 use rand::rng;
 
 use crate::common::get_or_generate_secret_key;
@@ -276,7 +276,7 @@ async fn main() -> Result<()> {
             }
 
             tokio::signal::ctrl_c().await?;
-            router.shutdown().await?;
+            router.shutdown().await.anyerr()?;
         }
         Args::ByHash { paths } => {
             let store = MemStore::new();
@@ -304,7 +304,7 @@ async fn main() -> Result<()> {
                 println!("{}: {ticket} ({permitted})", path.display());
             }
             tokio::signal::ctrl_c().await?;
-            router.shutdown().await?;
+            router.shutdown().await.anyerr()?;
         }
         Args::Throttle { paths, delay_ms } => {
             let store = MemStore::new();
@@ -316,7 +316,7 @@ async fn main() -> Result<()> {
                 println!("{}: {ticket}", path.display());
             }
             tokio::signal::ctrl_c().await?;
-            router.shutdown().await?;
+            router.shutdown().await.anyerr()?;
         }
         Args::MaxConnections {
             paths,
@@ -331,7 +331,7 @@ async fn main() -> Result<()> {
                 println!("{}: {ticket}", path.display());
             }
             tokio::signal::ctrl_c().await?;
-            router.shutdown().await?;
+            router.shutdown().await.anyerr()?;
         }
     }
     Ok(())

examples/mdns-discovery.rs

@@ -13,12 +13,12 @@
 //! Run that command on another machine in the same local network, replacing [FILE_PATH] to the path on which you want to save the transferred content.
 use std::path::{Path, PathBuf};
 
-use n0_error::{ensure, Result};
 use clap::{Parser, Subcommand};
 use iroh::{
     discovery::mdns::MdnsDiscovery, protocol::Router, Endpoint, PublicKey, RelayMode, SecretKey,
 };
 use iroh_blobs::{store::mem::MemStore, BlobsProtocol, Hash};
+use n0_error::{ensure, Result, StdResultExt};
 
 mod common;
 use common::{get_or_generate_secret_key, setup_logging};
@@ -74,15 +74,15 @@ async fn accept(path: &Path) -> Result<()> {
 
     if !path.is_file() {
         println!("Content must be a file.");
-        node.shutdown().await?;
+        node.shutdown().await.anyerr()?;
         return Ok(());
     }
     let absolute = path.canonicalize()?;
     println!("Adding {} as {}...", path.display(), absolute.display());
     let tag = store.add_path(absolute).await?;
     println!("To fetch the blob:\n\tcargo run --example mdns-discovery --features examples -- connect {} {} -o [FILE_PATH]", node.endpoint().id(), tag.hash);
     tokio::signal::ctrl_c().await?;
-    node.shutdown().await?;
+    node.shutdown().await.anyerr()?;
     Ok(())
 }
 

examples/random_store.rs

@@ -1,6 +1,5 @@
 use std::{env, path::PathBuf, str::FromStr};
 
-use n0_error::{Context, Result};
 use clap::{Parser, Subcommand};
 use iroh::{discovery::static_provider::StaticProvider, SecretKey};
 use iroh_blobs::{
@@ -12,6 +11,7 @@ use iroh_blobs::{
 };
 use iroh_tickets::endpoint::EndpointTicket;
 use irpc::RpcMessage;
+use n0_error::{Result, StackResultExt, StdResultExt};
 use n0_future::StreamExt;
 use rand::{rngs::StdRng, Rng, SeedableRng};
 use tokio::signal::ctrl_c;
@@ -247,7 +247,7 @@ async fn provide(args: ProvideArgs) -> n0_error::Result<()> {
     println!("Node address: {addr:?}");
     println!("ticket:\n{ticket}");
     ctrl_c().await?;
-    router.shutdown().await?;
+    router.shutdown().await.anyerr()?;
     dump_task.abort();
     Ok(())
 }

examples/transfer-collection.rs

@@ -7,7 +7,6 @@
 //!  $ cargo run --example transfer-collection
 use std::collections::HashMap;
 
-use n0_error::{Context, Result};
 use iroh::{
     discovery::static_provider::StaticProvider, protocol::Router, Endpoint, EndpointAddr, RelayMode,
 };
@@ -17,6 +16,7 @@ use iroh_blobs::{
     store::mem::MemStore,
     BlobsProtocol, Hash, HashAndFormat,
 };
+use n0_error::{Result, StackResultExt};
 
 /// Node is something you'd define in your application. It can contain whatever
 /// shared state you'd want to couple with network operations.

examples/transfer.rs

@@ -2,6 +2,7 @@ use std::path::PathBuf;
 
 use iroh::{protocol::Router, Endpoint};
 use iroh_blobs::{store::mem::MemStore, ticket::BlobTicket, BlobsProtocol};
+use n0_error::StdResultExt;
 
 #[tokio::main]
 async fn main() -> n0_error::Result<()> {
@@ -21,7 +22,7 @@ async fn main() -> n0_error::Result<()> {
 
     match arg_refs.as_slice() {
         ["send", filename] => {
-            let filename: PathBuf = filename.parse()?;
+            let filename: PathBuf = filename.parse().anyerr()?;
             let abs_path = std::path::absolute(&filename)?;
 
             println!("Hashing file.");
@@ -49,12 +50,12 @@ async fn main() -> n0_error::Result<()> {
 
             // Gracefully shut down the node
             println!("Shutting down.");
-            router.shutdown().await?;
+            router.shutdown().await.anyerr()?;
         }
         ["receive", ticket, filename] => {
-            let filename: PathBuf = filename.parse()?;
+            let filename: PathBuf = filename.parse().anyerr()?;
             let abs_path = std::path::absolute(filename)?;
-            let ticket: BlobTicket = ticket.parse()?;
+            let ticket: BlobTicket = ticket.parse().anyerr()?;
 
             // For receiving files, we create a "downloader" that allows us to fetch files
             // from other nodes via iroh connections

src/util/connection_pool.rs

@@ -553,8 +553,8 @@ mod tests {
         protocol::{AcceptError, ProtocolHandler, Router},
         Endpoint, EndpointAddr, EndpointId, RelayMode, SecretKey, TransportAddr, Watcher,
     };
+    use n0_error::{AnyError, Result, StdResultExt};
     use n0_future::{io, stream, BufferedStreamExt, StreamExt};
-    use n0_snafu::ResultExt;
     use testresult::TestResult;
     use tracing::trace;
 
@@ -588,14 +588,14 @@ mod tests {
         }
     }
 
-    async fn echo_client(conn: &Connection, text: &[u8]) -> n0_snafu::Result<Vec<u8>> {
+    async fn echo_client(conn: &Connection, text: &[u8]) -> Result<Vec<u8>> {
         let conn_id = conn.stable_id();
-        let id = conn.remote_id().e()?;
+        let id = conn.remote_id().anyerr()?;
         trace!(%id, %conn_id, "Sending echo request");
-        let (mut send, mut recv) = conn.open_bi().await.e()?;
-        send.write_all(text).await.e()?;
-        send.finish().e()?;
-        let response = recv.read_to_end(1000).await.e()?;
+        let (mut send, mut recv) = conn.open_bi().await.anyerr()?;
+        send.write_all(text).await.anyerr()?;
+        send.finish().anyerr()?;
+        let response = recv.read_to_end(1000).await.anyerr()?;
         trace!(%id, %conn_id, "Received echo response");
         Ok(response)
     }
@@ -653,7 +653,7 @@ mod tests {
             &self,
             id: EndpointId,
             text: Vec<u8>,
-        ) -> Result<Result<(usize, Vec<u8>), n0_snafu::Error>, PoolConnectError> {
+        ) -> Result<Result<(usize, Vec<u8>), AnyError>, PoolConnectError> {
             let conn = self.pool.get_or_connect(id).await?;
             let id = conn.stable_id();
             match echo_client(&conn, &text).await {