feat: snafu error with better stack trace

Cargo.toml

@@ -5,6 +5,8 @@ members = [
     "clash",
     "clash_lib",
     "clash_doc",
+    "crates/stack-error-macro",
+    "crates/stack-error",
     "clash_ffi",
 ]
 

clash_lib/Cargo.toml

@@ -17,6 +17,11 @@ zero_copy = []
 tokio-console = ["tokio/tracing"]
 
 [dependencies]
+
+stack-error-macro = { path = "../crates/stack-error-macro" }
+stack-error =  { path = "../crates/stack-error" }
+snafu = "0.8"
+
 # Async
 tokio = { version = "1", features = ["full"] }
 tokio-util = { version = "0.7", features = ["net", "codec", "io", "compat"] }

clash_lib/src/app/dns/config.rs

@@ -149,7 +149,7 @@ impl Config {
 
     pub fn parse_fallback_ip_cidr(
         ipcidr: &[String],
-    ) -> anyhow::Result<Vec<ipnet::IpNet>> {
+    ) -> std::result::Result<Vec<ipnet::IpNet>, crate::Error> {
         let mut output = vec![];
 
         for ip in ipcidr.iter() {
@@ -164,15 +164,15 @@ impl Config {
 
     pub fn parse_hosts(
         hosts_mapping: &HashMap<String, String>,
-    ) -> anyhow::Result<trie::StringTrie<IpAddr>> {
+    ) -> std::result::Result<trie::StringTrie<IpAddr>, crate::Error> {
         let mut tree = trie::StringTrie::new();
         tree.insert(
             "localhost",
             Arc::new("127.0.0.1".parse::<IpAddr>().unwrap()),
         );
 
         for (host, ip_str) in hosts_mapping.iter() {
-            let ip = ip_str.parse::<IpAddr>()?;
+            let ip = ip_str.parse::<IpAddr>().map_err(Error::StdNet)?;
             tree.insert(host.as_str(), Arc::new(ip));
         }
 

clash_lib/src/app/dns/dhcp.rs

@@ -3,12 +3,14 @@ use crate::{
         dns_client::DNSNetMode, helper::make_clients, Client, EnhancedResolver,
         ThreadSafeDNSClient,
     },
+    error::dns::{ClientTimeoutSnafu, IoSnafu},
     proxy::utils::{new_udp_socket, Interface},
 };
 use async_trait::async_trait;
 use dhcproto::{Decodable, Encodable};
 use futures::FutureExt;
 use network_interface::{Addr, NetworkInterfaceConfig};
+use snafu::ResultExt;
 use std::{
     env,
     fmt::{Debug, Formatter},
@@ -56,8 +58,8 @@ impl Client for DhcpClient {
         format!("dhcp#{}", self.iface)
     }
 
-    async fn exchange(&self, msg: &Message) -> anyhow::Result<Message> {
-        let clients = self.resolve().await?;
+    async fn exchange(&self, msg: &Message) -> crate::error::DnsResult<Message> {
+        let clients = self.resolve().await.context(IoSnafu)?;
         let mut dbg_str = vec![];
         for c in &clients {
             dbg_str.push(format!("{:?}", c));
@@ -67,7 +69,8 @@ impl Client for DhcpClient {
             DHCP_TIMEOUT,
             EnhancedResolver::batch_exchange(&clients, msg),
         )
-        .await?
+        .await
+        .context(ClientTimeoutSnafu)?
     }
 }
 

clash_lib/src/app/dns/dns_client.rs

@@ -16,12 +16,14 @@ use hickory_proto::{
     udp::UdpClientStream, ProtoError,
 };
 use rustls::ClientConfig;
+use snafu::ResultExt;
 use tokio::{sync::RwLock, task::JoinHandle};
 use tracing::{info, warn};
 
 use crate::{
     common::tls::{self, GLOBAL_ROOT_STORE},
     dns::{dhcp::DhcpClient, ThreadSafeDNSClient},
+    error::dns::ProtoSnafu,
     proxy::utils::new_tcp_stream,
 };
 use hickory_proto::{
@@ -277,7 +279,7 @@ impl Client for DnsClient {
         format!("{}#{}:{}", &self.net, &self.host, &self.port)
     }
 
-    async fn exchange(&self, msg: &Message) -> anyhow::Result<Message> {
+    async fn exchange(&self, msg: &Message) -> crate::error::DnsResult<Message> {
         let mut inner = self.inner.write().await;
 
         if let Some(bg) = &inner.bg_handle {
@@ -309,14 +311,14 @@ impl Client for DnsClient {
             .send(req)
             .first_answer()
             .await
-            .map_err(|x| Error::DNSError(x.to_string()).into())
+            .context(ProtoSnafu)
             .map(|x| x.into())
     }
 }
 
 async fn dns_stream_builder(
     cfg: &DnsConfig,
-) -> Result<(client::Client, JoinHandle<Result<(), ProtoError>>), Error> {
+) -> crate::error::DnsResult<(client::Client, JoinHandle<Result<(), ProtoError>>)> {
     match cfg {
         DnsConfig::Udp(addr, iface) => {
             let stream = UdpClientStream::builder(
@@ -329,7 +331,7 @@ async fn dns_stream_builder(
             client::Client::connect(stream)
                 .await
                 .map(|(x, y)| (x, tokio::spawn(y)))
-                .map_err(|x| Error::DNSError(x.to_string()))
+                .context(ProtoSnafu)
         }
         DnsConfig::Tcp(addr, iface) => {
             let (stream, sender) = TcpClientStream::new(
@@ -342,7 +344,7 @@ async fn dns_stream_builder(
             client::Client::new(stream, sender, None)
                 .await
                 .map(|(x, y)| (x, tokio::spawn(y)))
-                .map_err(|x| Error::DNSError(x.to_string()))
+                .context(ProtoSnafu)
         }
         DnsConfig::Tls(addr, host, iface) => {
             let mut tls_config = ClientConfig::builder()
@@ -379,7 +381,7 @@ async fn dns_stream_builder(
             )
             .await
             .map(|(x, y)| (x, tokio::spawn(y)))
-            .map_err(|x| Error::DNSError(x.to_string()))
+            .context(ProtoSnafu)
         }
         DnsConfig::Https(addr, host, iface) => {
             let mut tls_config = ClientConfig::builder()
@@ -402,7 +404,7 @@ async fn dns_stream_builder(
             client::Client::connect(stream)
                 .await
                 .map(|(x, y)| (x, tokio::spawn(y)))
-                .map_err(|x| Error::DNSError(x.to_string()))
+                .context(ProtoSnafu)
         }
     }
 }

clash_lib/src/app/dns/mod.rs

@@ -28,7 +28,10 @@ pub use server::get_dns_listener;
 pub trait Client: Sync + Send + Debug {
     /// used to identify the client for logging
     fn id(&self) -> String;
-    async fn exchange(&self, msg: &op::Message) -> anyhow::Result<op::Message>;
+    async fn exchange(
+        &self,
+        msg: &op::Message,
+    ) -> crate::error::DnsResult<op::Message>;
 }
 
 type ThreadSafeDNSClient = Arc<dyn Client>;
@@ -51,22 +54,25 @@ pub trait ClashResolver: Sync + Send {
         &self,
         host: &str,
         enhanced: bool,
-    ) -> anyhow::Result<Option<std::net::IpAddr>>;
+    ) -> std::result::Result<Option<std::net::IpAddr>, crate::error::DnsError>;
     async fn resolve_v4(
         &self,
         host: &str,
         enhanced: bool,
-    ) -> anyhow::Result<Option<std::net::Ipv4Addr>>;
+    ) -> std::result::Result<Option<std::net::Ipv4Addr>, crate::error::DnsError>;
     async fn resolve_v6(
         &self,
         host: &str,
         enhanced: bool,
-    ) -> anyhow::Result<Option<std::net::Ipv6Addr>>;
+    ) -> std::result::Result<Option<std::net::Ipv6Addr>, crate::error::DnsError>;
 
     async fn cached_for(&self, ip: std::net::IpAddr) -> Option<String>;
 
     /// Used for DNS Server
-    async fn exchange(&self, message: &op::Message) -> anyhow::Result<op::Message>;
+    async fn exchange(
+        &self,
+        message: &op::Message,
+    ) -> std::result::Result<op::Message, crate::error::DnsError>;
 
     /// Only used for look up fake IP
     async fn reverse_lookup(&self, ip: std::net::IpAddr) -> Option<String>;