feat(netwatch): Attempt to switch to snafu

Author: matheus23

Cargo.lock

@@ -19,7 +19,9 @@ workspace = true
 atomic-waker = "1.1.2"
 bytes = "1.7"
 n0-future = "0.1.1"
-thiserror = "2"
+n0-snafu = { git = "https://github.com/n0-computer/n0-snafu", branch = "matheus23/clone" }
+nested_enum_utils = "0.2.0"
+snafu = "0.8.5"
 time = "0.3.20"
 tokio = { version = "1", features = [
     "io-util",

netwatch/Cargo.toml

@@ -8,6 +8,9 @@ use std::{
     sync::LazyLock,
 };
 
+use nested_enum_utils::common_fields;
+use snafu::{Backtrace, IntoError, Snafu};
+
 use libc::{c_int, uintptr_t, AF_INET, AF_INET6, AF_LINK, AF_ROUTE, AF_UNSPEC, CTL_NET};
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 use libc::{
@@ -627,20 +630,29 @@ pub struct InterfaceAnnounceMessage {
 /// Represents a type of routing information base.
 type RIBType = i32;
 
-#[derive(Debug, thiserror::Error)]
+#[common_fields({
+    backtrace: Option<Backtrace>,
+    #[snafu(implicit)]
+    span_trace: n0_snafu::SpanTrace,
+})]
+#[derive(Debug, Snafu)]
+#[non_exhaustive]
 pub enum RouteError {
-    #[error("message mismatch")]
-    MessageMismatch,
-    #[error("message too short")]
-    MessageTooShort,
-    #[error("invalid message")]
-    InvalidMessage,
-    #[error("invalid address")]
-    InvalidAddress,
-    #[error("invalid rib type: {0}")]
-    InvalidRibType(RIBType),
-    #[error("io error calling: '{0}': {1:?}")]
-    Io(&'static str, std::io::Error),
+    #[snafu(display("message mismatch"))]
+    MessageMismatch {},
+    #[snafu(display("message too short"))]
+    MessageTooShort {},
+    #[snafu(display("invalid message"))]
+    InvalidMessage {},
+    #[snafu(display("invalid address"))]
+    InvalidAddress {},
+    #[snafu(display("invalid rib type {rib_type}"))]
+    InvalidRibType { rib_type: RIBType },
+    #[snafu(display("io error calling '{name}'"))]
+    Io {
+        source: std::io::Error,
+        name: &'static str,
+    },
 }
 
 /// FetchRIB fetches a routing information base from the operating system.
@@ -670,7 +682,7 @@ fn fetch_rib(af: i32, typ: RIBType, arg: i32) -> Result<Vec<u8>, RouteError> {
             )
         };
         if err != 0 {
-            return Err(RouteError::Io("sysctl", std::io::Error::last_os_error()));
+            return Err(std::io::Error::last_os_error().into_error(IoSnafu { name: "sysctl" }));
         }
         if n == 0 {
             // nothing available
@@ -696,7 +708,7 @@ fn fetch_rib(af: i32, typ: RIBType, arg: i32) -> Result<Vec<u8>, RouteError> {
             if io_err.raw_os_error().unwrap_or_default() == libc::ENOMEM && round < MAX_TRIES {
                 continue;
             }
-            return Err(RouteError::Io("sysctl", io_err));
+            return Err(io_err.into_error(IoSnafu { name: "sysctl" }));
         }
         // Truncate b, to the new length
         b.truncate(n);

netwatch/src/interfaces/bsd.rs

@@ -2,32 +2,40 @@
 
 #[cfg(not(target_os = "android"))]
 use n0_future::TryStreamExt;
+use nested_enum_utils::common_fields;
+use snafu::{Backtrace, ResultExt, Snafu};
 use tokio::{
     fs::File,
     io::{AsyncBufReadExt, BufReader},
 };
 
 use super::DefaultRouteDetails;
 
-#[derive(Debug, thiserror::Error)]
+#[common_fields({
+    backtrace: Option<Backtrace>,
+    #[snafu(implicit)]
+    span_trace: n0_snafu::SpanTrace,
+})]
+#[derive(Debug, Snafu)]
+#[non_exhaustive]
 pub enum Error {
-    #[error("IO {0}")]
-    Io(#[from] std::io::Error),
+    #[snafu(display("IO"))]
+    Io { source: std::io::Error },
     #[cfg(not(target_os = "android"))]
-    #[error("no netlink response")]
+    #[snafu(display("no netlink response"))]
     NoResponse,
     #[cfg(not(target_os = "android"))]
-    #[error("interface not found")]
+    #[snafu(display("interface not found"))]
     InterfaceNotFound,
-    #[error("iface field is missing")]
+    #[snafu(display("iface field is missing"))]
     MissingIfaceField,
-    #[error("destination field is missing")]
+    #[snafu(display("destination field is missing"))]
     MissingDestinationField,
-    #[error("mask field is missing")]
+    #[snafu(display("mask field is missing"))]
     MissingMaskField,
     #[cfg(not(target_os = "android"))]
-    #[error("netlink")]
-    Netlink(#[from] rtnetlink::Error),
+    #[snafu(display("netlink"))]
+    Netlink { source: rtnetlink::Error },
 }
 
 pub async fn default_route() -> Option<DefaultRouteDetails> {
@@ -49,7 +57,7 @@ const PROC_NET_ROUTE_PATH: &str = "/proc/net/route";
 
 async fn default_route_proc() -> Result<Option<DefaultRouteDetails>, Error> {
     const ZERO_ADDR: &str = "00000000";
-    let file = File::open(PROC_NET_ROUTE_PATH).await?;
+    let file = File::open(PROC_NET_ROUTE_PATH).await.context(IoSnafu)?;
 
     // Explicitly set capacity, this is min(4096, DEFAULT_BUF_SIZE):
     // https://github.com/google/gvisor/issues/5732
@@ -65,7 +73,7 @@ async fn default_route_proc() -> Result<Option<DefaultRouteDetails>, Error> {
     // read it all in one call.
     let reader = BufReader::with_capacity(8 * 1024, file);
     let mut lines_iter = reader.lines();
-    while let Some(line) = lines_iter.next_line().await? {
+    while let Some(line) = lines_iter.next_line().await.context(IoSnafu)? {
         if !line.contains(ZERO_ADDR) {
             continue;
         }
@@ -127,7 +135,7 @@ fn parse_android_ip_route(stdout: &str) -> Option<&str> {
 async fn default_route_netlink() -> Result<Option<DefaultRouteDetails>, Error> {
     use tracing::{info_span, Instrument};
 
-    let (connection, handle, _receiver) = rtnetlink::new_connection()?;
+    let (connection, handle, _receiver) = rtnetlink::new_connection().context(IoSnafu)?;
     let task = tokio::spawn(connection.instrument(info_span!("rtnetlink.conn")));
 
     let default = default_route_netlink_family(&handle, rtnetlink::IpVersion::V4).await?;
@@ -151,7 +159,7 @@ async fn default_route_netlink_family(
     use netlink_packet_route::route::RouteAttribute;
 
     let mut routes = handle.route().get(family).execute();
-    while let Some(route) = routes.try_next().await? {
+    while let Some(route) = routes.try_next().await.context(NetlinkSnafu)? {
         let route_attrs = route.attributes;
 
         if !route_attrs
@@ -187,9 +195,14 @@ async fn default_route_netlink_family(
 #[cfg(not(target_os = "android"))]
 async fn iface_by_index(handle: &rtnetlink::Handle, index: u32) -> Result<String, Error> {
     use netlink_packet_route::link::LinkAttribute;
+    use snafu::OptionExt;
 
     let mut links = handle.link().get().match_index(index).execute();
-    let msg = links.try_next().await?.ok_or(Error::NoResponse)?;
+    let msg = links
+        .try_next()
+        .await
+        .context(NetlinkSnafu)?
+        .context(NoResponseSnafu)?;
 
     for nla in msg.attributes {
         if let LinkAttribute::IfName(name) = nla {

netwatch/src/interfaces/linux.rs

@@ -1,6 +1,8 @@
 use std::collections::HashMap;
 
+use nested_enum_utils::common_fields;
 use serde::Deserialize;
+use snafu::{Backtrace, OptionExt, ResultExt, Snafu};
 use tracing::warn;
 use wmi::{query::FilterValue, COMLibrary, WMIConnection};
 
@@ -13,26 +15,33 @@ struct Win32_IP4RouteTable {
     Name: String,
 }
 
-#[derive(Debug, thiserror::Error)]
+#[common_fields({
+    backtrace: Option<Backtrace>,
+    #[snafu(implicit)]
+    span_trace: n0_snafu::SpanTrace,
+})]
+#[derive(Debug, Snafu)]
+#[non_exhaustive]
 pub enum Error {
-    #[error("IO {0}")]
-    Io(#[from] std::io::Error),
-    #[error("not route found")]
+    #[snafu(display("IO"))]
+    Io { source: std::io::Error },
+    #[snafu(display("not route found"))]
     NoRoute,
-    #[error("WMI {0}")]
-    Wmi(#[from] wmi::WMIError),
+    #[snafu(display("WMI"))]
+    Wmi { source: wmi::WMIError },
 }
 
 fn get_default_route() -> Result<DefaultRouteDetails, Error> {
-    let com_con = COMLibrary::new()?;
-    let wmi_con = WMIConnection::new(com_con)?;
+    let com_con = COMLibrary::new().context(WmiSnafu)?;
+    let wmi_con = WMIConnection::new(com_con).context(WmiSnafu)?;
 
     let query: HashMap<_, _> = [("Destination".into(), FilterValue::Str("0.0.0.0"))].into();
     let route: Win32_IP4RouteTable = wmi_con
-        .filtered_query(&query)?
+        .filtered_query(&query)
+        .context(WmiSnafu)?
         .drain(..)
         .next()
-        .ok_or(Error::NoRoute)?;
+        .context(NoRouteSnafu)?;
 
     Ok(DefaultRouteDetails {
         interface_name: route.Name,

netwatch/src/interfaces/windows.rs

@@ -4,6 +4,8 @@ use n0_future::{
     boxed::BoxFuture,
     task::{self, AbortOnDropHandle},
 };
+use nested_enum_utils::common_fields;
+use snafu::{Backtrace, ResultExt, Snafu};
 use tokio::sync::{mpsc, oneshot};
 
 mod actor;
@@ -35,30 +37,36 @@ pub struct Monitor {
     actor_tx: mpsc::Sender<ActorMessage>,
 }
 
-#[derive(Debug, thiserror::Error)]
+#[common_fields({
+    backtrace: Option<Backtrace>,
+    #[snafu(implicit)]
+    span_trace: n0_snafu::SpanTrace,
+})]
+#[derive(Debug, Snafu)]
+#[non_exhaustive]
 pub enum Error {
-    #[error("channel closed")]
-    ChannelClosed,
-    #[error("actor {0}")]
-    Actor(#[from] actor::Error),
+    #[snafu(display("channel closed"))]
+    ChannelClosed {},
+    #[snafu(display("actor error"))]
+    Actor { source: actor::Error },
 }
 
 impl<T> From<mpsc::error::SendError<T>> for Error {
     fn from(_value: mpsc::error::SendError<T>) -> Self {
-        Self::ChannelClosed
+        ChannelClosedSnafu.build()
     }
 }
 
 impl From<oneshot::error::RecvError> for Error {
     fn from(_value: oneshot::error::RecvError) -> Self {
-        Self::ChannelClosed
+        ChannelClosedSnafu.build()
     }
 }
 
 impl Monitor {
     /// Create a new monitor.
     pub async fn new() -> Result<Self, Error> {
-        let actor = Actor::new().await?;
+        let actor = Actor::new().await.context(ActorSnafu)?;
         let actor_tx = actor.subscribe();
 
         let handle = task::spawn(async move {

netwatch/src/netmon.rs

@@ -2,10 +2,12 @@ use tokio::sync::mpsc;
 
 use super::actor::NetworkMessage;
 
-#[derive(Debug, thiserror::Error)]
-#[error("error")]
+#[derive(Debug, derive_more::Display)]
+#[display("error")]
 pub struct Error;
 
+impl std::error::Error for Error {}
+
 #[derive(Debug)]
 pub(super) struct RouteMonitor {
     _sender: mpsc::Sender<NetworkMessage>,

netwatch/src/netmon/android.rs

@@ -1,5 +1,6 @@
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 use libc::{RTAX_DST, RTAX_IFP};
+use snafu::{Backtrace, ResultExt, Snafu};
 use tokio::{io::AsyncReadExt, sync::mpsc};
 use tokio_util::task::AbortOnDropHandle;
 use tracing::{trace, warn};
@@ -14,10 +15,16 @@ pub(super) struct RouteMonitor {
     _handle: AbortOnDropHandle<()>,
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, Snafu)]
+#[non_exhaustive]
 pub enum Error {
-    #[error("IO {0}")]
-    Io(#[from] std::io::Error),
+    #[snafu(display("IO"))]
+    Io {
+        source: std::io::Error,
+        backtrace: Option<Backtrace>,
+        #[snafu(implicit)]
+        span_trace: n0_snafu::SpanTrace,
+    },
 }
 
 fn create_socket() -> std::io::Result<tokio::net::UnixStream> {
@@ -33,7 +40,7 @@ fn create_socket() -> std::io::Result<tokio::net::UnixStream> {
 
 impl RouteMonitor {
     pub(super) fn new(sender: mpsc::Sender<NetworkMessage>) -> Result<Self, Error> {
-        let mut socket = create_socket()?;
+        let mut socket = create_socket().context(IoSnafu)?;
         let handle = tokio::task::spawn(async move {
             trace!("AF_ROUTE monitor started");