refactor!: convert from snafu to n0-error

Cargo.toml

@@ -40,3 +40,7 @@ unexpected_cfgs = { level = "warn", check-cfg = ["cfg(iroh_docsrs)", "cfg(iroh_l
 
 [workspace.lints.clippy]
 unused-async = "warn"
+
+[patch.crates-io]
+netwatch = { git = "https://github.com/n0-computer/net-tools", branch = "Frando/n0-snafu" }
+portmapper = { git = "https://github.com/n0-computer/net-tools", branch = "Frando/n0-snafu" }

iroh-base/Cargo.toml

@@ -22,9 +22,7 @@ derive_more = { version = "2.0.1", features = ["display"], optional = true }
 url = { version = "2.5.3", features = ["serde"], optional = true }
 rand_core = { version = "0.9.3", optional = true }
 serde = { version = "1", features = ["derive", "rc"] }
-snafu = { version = "0.8.5", features = ["rust_1_81"], optional = true }
-n0-snafu = "0.2.2"
-nested_enum_utils = "0.2.0"
+n0-error = "0.1.0"
 zeroize = { version = "1.8.2", optional = true, features = ["derive"] }
 zeroize_derive = { version = "1.4.2", optional = true } # needed for minimal versions
 
@@ -44,7 +42,6 @@ key = [
   "dep:ed25519-dalek",
   "dep:url",
   "dep:derive_more",
-  "dep:snafu",
   "dep:data-encoding",
   "dep:rand_core",
   "dep:zeroize",
@@ -54,7 +51,6 @@ key = [
 relay = [
   "dep:url",
   "dep:derive_more",
-  "dep:snafu",
 ]
 
 [package.metadata.docs.rs]

iroh-base/src/key.rs

@@ -11,10 +11,9 @@ use std::{
 
 use curve25519_dalek::edwards::CompressedEdwardsY;
 use ed25519_dalek::{SigningKey, VerifyingKey};
-use nested_enum_utils::common_fields;
+use n0_error::{ensure, stack_error};
 use rand_core::CryptoRng;
 use serde::{Deserialize, Serialize, de, ser};
-use snafu::{Backtrace, Snafu};
 
 /// A public key.
 ///
@@ -128,7 +127,7 @@ impl PublicKey {
     pub fn verify(&self, message: &[u8], signature: &Signature) -> Result<(), SignatureError> {
         self.as_verifying_key()
             .verify_strict(message, &signature.0)
-            .map_err(|_| SignatureSnafu.build())
+            .map_err(|_| SignatureError::new())
     }
 
     /// Convert to a hex string limited to the first 5 bytes for a friendly string
@@ -204,26 +203,18 @@ impl Display for PublicKey {
 }
 
 /// Error when deserialising a [`PublicKey`] or a [`SecretKey`].
-#[common_fields({
-    backtrace: Option<Backtrace>,
-    #[snafu(implicit)]
-    span_trace: n0_snafu::SpanTrace,
-})]
-#[derive(Snafu, Debug)]
+#[stack_error(derive, add_meta, from_sources, std_sources)]
 #[allow(missing_docs)]
-#[snafu(visibility(pub(crate)))]
 pub enum KeyParsingError {
     /// Error when decoding.
-    #[snafu(transparent)]
-    Decode { source: data_encoding::DecodeError },
+    #[error(transparent)]
+    Decode(data_encoding::DecodeError),
     /// Error when decoding the public key.
-    #[snafu(transparent)]
-    Key {
-        source: ed25519_dalek::SignatureError,
-    },
+    #[error(transparent)]
+    Key(ed25519_dalek::SignatureError),
     /// The encoded information had the wrong length.
-    #[snafu(display("invalid length"))]
-    DecodeInvalidLength {},
+    #[error("invalid length")]
+    DecodeInvalidLength,
 }
 
 /// Deserialises the [`PublicKey`] from it's base32 encoding.
@@ -420,9 +411,9 @@ impl Signature {
 }
 
 /// Verification of a signature failed.
-#[derive(Debug, Snafu)]
-#[snafu(display("Invalid signature"))]
-pub struct SignatureError;
+#[stack_error(derive, add_meta)]
+#[error("Invalid signature")]
+pub struct SignatureError {}
 
 fn decode_base32_hex(s: &str) -> Result<[u8; 32], KeyParsingError> {
     let mut bytes = [0u8; 32];
@@ -433,16 +424,18 @@ fn decode_base32_hex(s: &str) -> Result<[u8; 32], KeyParsingError> {
     } else {
         let input = s.to_ascii_uppercase();
         let input = input.as_bytes();
-        if data_encoding::BASE32_NOPAD.decode_len(input.len())? != bytes.len() {
-            return Err(DecodeInvalidLengthSnafu.build());
-        }
+        ensure!(
+            data_encoding::BASE32_NOPAD.decode_len(input.len())? == bytes.len(),
+            KeyParsingError::DecodeInvalidLength
+        );
         data_encoding::BASE32_NOPAD.decode_mut(input, &mut bytes)
     };
     match res {
         Ok(len) => {
-            if len != PublicKey::LENGTH {
-                return Err(DecodeInvalidLengthSnafu.build());
-            }
+            ensure!(
+                len == PublicKey::LENGTH,
+                KeyParsingError::DecodeInvalidLength
+            );
         }
         Err(partial) => return Err(partial.error.into()),
     }

iroh-base/src/relay_url.rs

@@ -1,7 +1,7 @@
 use std::{fmt, ops::Deref, str::FromStr, sync::Arc};
 
+use n0_error::stack_error;
 use serde::{Deserialize, Serialize};
-use snafu::{Backtrace, ResultExt, Snafu};
 use url::Url;
 
 /// A URL identifying a relay server.
@@ -39,12 +39,9 @@ impl From<Url> for RelayUrl {
 }
 
 /// Can occur when parsing a string into a [`RelayUrl`].
-#[derive(Debug, Snafu)]
-#[snafu(display("Failed to parse"))]
-pub struct RelayUrlParseError {
-    source: url::ParseError,
-    backtrace: Option<Backtrace>,
-}
+#[stack_error(derive, add_meta)]
+#[error("Failed to parse relay URL")]
+pub struct RelayUrlParseError(#[error(std_err)] url::ParseError);
 
 /// Support for parsing strings directly.
 ///
@@ -54,7 +51,7 @@ impl FromStr for RelayUrl {
     type Err = RelayUrlParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let inner = Url::from_str(s).context(RelayUrlParseSnafu)?;
+        let inner = Url::from_str(s).map_err(|err| RelayUrlParseError::new(err))?;
         Ok(RelayUrl::from(inner))
     }
 }

iroh-dns-server/Cargo.toml

@@ -28,10 +28,9 @@ hickory-server = { version = "0.25.1", features = ["https-ring"] }
 http = "1.0.0"
 humantime = "2.2.0"
 humantime-serde = "1.1.1"
-iroh-metrics = { version = "0.36", features = ["service"] }
+iroh-metrics = { version = "0.37", features = ["service"] }
 lru = "0.16"
 n0-future = "0.3.0"
-n0-snafu = "0.2.2"
 pkarr = { version = "5", features = ["relays", "dht"], default-features = false }
 rcgen = "0.14"
 redb = "3.1.0"
@@ -40,7 +39,7 @@ rustls = { version = "0.23.33", default-features = false, features = ["ring"] }
 rustls-pemfile = { version = "2.1" }
 serde = { version = "1", features = ["derive"] }
 struct_iterable = "0.1.1"
-snafu = { version = "0.8.5", features = ["rust_1_81"] }
+n0-error = "0.1.0"
 strum = { version = "0.27", features = ["derive"] }
 tokio = { version = "1", features = ["full"] }
 tokio-rustls = { version = "0.26", default-features = false, features = [

iroh-dns-server/benches/write.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
 use iroh::{SecretKey, discovery::pkarr::PkarrRelayClient, endpoint_info::EndpointInfo};
 use iroh_dns_server::{ZoneStore, config::Config, metrics::Metrics, server::Server};
-use n0_snafu::Result;
+use n0_error::Result;
 use rand_chacha::rand_core::SeedableRng;
 use tokio::runtime::Runtime;
 

iroh-dns-server/examples/convert.rs

@@ -2,7 +2,7 @@ use std::str::FromStr;
 
 use clap::Parser;
 use iroh::EndpointId;
-use n0_snafu::{Result, ResultExt};
+use n0_error::{Result, StdResultExt};
 
 #[derive(Debug, Parser)]
 struct Cli {
@@ -21,12 +21,12 @@ fn main() -> Result<()> {
     match args.command {
         Command::EndpointToPkarr { endpoint_id } => {
             let endpoint_id = EndpointId::from_str(&endpoint_id)?;
-            let public_key = pkarr::PublicKey::try_from(endpoint_id.as_bytes()).e()?;
+            let public_key = pkarr::PublicKey::try_from(endpoint_id.as_bytes()).anyerr()?;
             println!("{}", public_key.to_z32())
         }
         Command::PkarrToEndpoint { z32_pubkey } => {
-            let public_key = pkarr::PublicKey::try_from(z32_pubkey.as_str()).e()?;
-            let endpoint_id = EndpointId::from_bytes(public_key.as_bytes()).e()?;
+            let public_key = pkarr::PublicKey::try_from(z32_pubkey.as_str()).anyerr()?;
+            let endpoint_id = EndpointId::from_bytes(public_key.as_bytes())?;
             println!("{endpoint_id}")
         }
     }

iroh-dns-server/examples/publish.rs

@@ -10,7 +10,7 @@ use iroh::{
     },
     endpoint_info::{EndpointIdExt, EndpointInfo, IROH_TXT_NAME},
 };
-use n0_snafu::{Result, ResultExt};
+use n0_error::{Result, StackResultExt};
 use url::Url;
 
 const DEV_PKARR_RELAY_URL: &str = "http://localhost:8080/pkarr";

iroh-dns-server/examples/resolve.rs

@@ -4,7 +4,7 @@ use iroh::{
     discovery::dns::{N0_DNS_ENDPOINT_ORIGIN_PROD, N0_DNS_ENDPOINT_ORIGIN_STAGING},
     dns::DnsResolver,
 };
-use n0_snafu::{Result, ResultExt};
+use n0_error::{Result, StackResultExt, StdResultExt};
 
 const DEV_DNS_SERVER: &str = "127.0.0.1:5300";
 const DEV_DNS_ORIGIN_DOMAIN: &str = "irohdns.example";
@@ -49,7 +49,7 @@ async fn main() -> Result<()> {
     let resolver = if let Some(host) = args.dns_server {
         let addr = tokio::net::lookup_host(host)
             .await
-            .e()?
+            .anyerr()?
             .next()
             .context("failed to resolve DNS server address")?;
         DnsResolver::with_nameserver(addr)

iroh-dns-server/src/config.rs

@@ -7,7 +7,7 @@ use std::{
     time::Duration,
 };
 
-use n0_snafu::{Result, ResultExt};
+use n0_error::{Result, StdResultExt};
 use serde::{Deserialize, Serialize};
 use tracing::info;
 
@@ -162,8 +162,8 @@ impl Config {
         );
         let s = tokio::fs::read_to_string(path.as_ref())
             .await
-            .with_context(|| format!("failed to read {}", path.as_ref().to_string_lossy()))?;
-        let config: Config = toml::from_str(&s).e()?;
+            .with_std_context(|_| format!("failed to read {}", path.as_ref().to_string_lossy()))?;
+        let config: Config = toml::from_str(&s).anyerr()?;
         Ok(config)
     }
 
@@ -173,7 +173,7 @@ impl Config {
             PathBuf::from(val)
         } else {
             let path = dirs_next::data_dir()
-                .context("operating environment provides no directory for application data")?;
+                .std_context("operating environment provides no directory for application data")?;
 
             path.join("iroh-dns")
         };

iroh-dns-server/src/dns.rs

@@ -25,7 +25,7 @@ use hickory_server::{
     server::{Request, RequestHandler, ResponseHandler, ResponseInfo},
     store::in_memory::InMemoryAuthority,
 };
-use n0_snafu::{Result, ResultExt, format_err};
+use n0_error::{Result, StdResultExt, anyerr};
 use serde::{Deserialize, Serialize};
 use tokio::{
     net::{TcpListener, UdpSocket},
@@ -82,12 +82,12 @@ impl DnsServer {
             config.port,
         );
 
-        let socket = UdpSocket::bind(bind_addr).await.e()?;
+        let socket = UdpSocket::bind(bind_addr).await.anyerr()?;
 
-        let socket_addr = socket.local_addr().e()?;
+        let socket_addr = socket.local_addr().anyerr()?;
 
         server.register_socket(socket);
-        server.register_listener(TcpListener::bind(bind_addr).await.e()?, TCP_TIMEOUT);
+        server.register_listener(TcpListener::bind(bind_addr).await.anyerr()?, TCP_TIMEOUT);
         info!("DNS server listening on {}", bind_addr);
 
         Ok(Self {
@@ -103,15 +103,15 @@ impl DnsServer {
 
     /// Shutdown the server an wait for all tasks to complete.
     pub async fn shutdown(mut self) -> Result<()> {
-        self.server.shutdown_gracefully().await.e()?;
+        self.server.shutdown_gracefully().await.anyerr()?;
         Ok(())
     }
 
     /// Wait for all tasks to complete.
     ///
     /// Runs forever unless tasks fail.
     pub async fn run_until_done(mut self) -> Result<()> {
-        self.server.block_until_done().await.e()?;
+        self.server.block_until_done().await.anyerr()?;
         Ok(())
     }
 }
@@ -133,7 +133,7 @@ impl DnsHandler {
             .iter()
             .map(Name::from_utf8)
             .collect::<Result<Vec<_>, _>>()
-            .e()?;
+            .anyerr()?;
 
         let (static_authority, serial) = create_static_authority(&origins, config)?;
         let authority = Arc::new(NodeAuthority::new(
@@ -159,7 +159,7 @@ impl DnsHandler {
         let (tx, mut rx) = broadcast::channel(1);
         let response_handle = Handle(tx);
         self.handle_request(&request, response_handle).await;
-        rx.recv().await.e()
+        rx.recv().await.anyerr()
     }
 }
 
@@ -234,9 +234,9 @@ fn create_static_authority(
         config.default_soa.split_ascii_whitespace(),
         None,
     )
-    .e()?
+    .anyerr()?
     .into_soa()
-    .map_err(|_| format_err!("Couldn't parse SOA: {}", config.default_soa))?;
+    .map_err(|_| anyerr!("Couldn't parse SOA: {}", config.default_soa))?;
     let serial = soa.serial();
     let mut records = BTreeMap::new();
     for name in origins {
@@ -260,7 +260,7 @@ fn create_static_authority(
             );
         }
         if let Some(ns) = &config.rr_ns {
-            let ns = Name::parse(ns, Some(&Name::root())).e()?;
+            let ns = Name::parse(ns, Some(&Name::root())).anyerr()?;
             push_record(
                 &mut records,
                 serial,
@@ -270,7 +270,7 @@ fn create_static_authority(
     }
 
     let static_authority = InMemoryAuthority::new(Name::root(), records, ZoneType::Primary, false)
-        .map_err(|e| format_err!("new authority: {e}"))?;
+        .map_err(|e| anyerr!("new authority: {e}"))?;
 
     Ok((static_authority, serial))
 }