Refactor out use of anyhow

Cargo.toml

@@ -27,8 +27,7 @@ ipnet = "2.3.1"
 log = "0.4.14"
 rand = "0.8.4"
 bytes = "1.1.0"
-thiserror = "1.0.29"
-anyhow = "1.0.44"
+thiserror = "1.0"
 
 [target.'cfg(not(windows))'.dependencies]
 nix = "0.23"

src/buffer/buffer_test.rs

@@ -1,5 +1,5 @@
-use super::error::Error;
 use super::*;
+use crate::error::Error;
 
 use tokio::time::{sleep, Duration};
 use tokio_test::assert_ok;
@@ -21,7 +21,7 @@ async fn test_buffer() {
     // Read deadline
     let result = buffer.read(&mut packet, Some(Duration::new(0, 1))).await;
     assert!(result.is_err());
-    assert!(Error::ErrTimeout.equal(&result.unwrap_err()));
+    assert_eq!(Error::ErrTimeout, result.unwrap_err());
 
     // Write twice
     let n = assert_ok!(buffer.write(&[2, 3, 4]).await);
@@ -58,7 +58,7 @@ async fn test_buffer() {
     // Until EOF
     let result = buffer.read(&mut packet, None).await;
     assert!(result.is_err());
-    assert!(Error::ErrBufferClosed.equal(&result.unwrap_err()));
+    assert_eq!(Error::ErrBufferClosed, result.unwrap_err());
 }
 
 async fn test_wraparound(grow: bool) {
@@ -138,7 +138,7 @@ async fn test_buffer_async() {
 
         let result = buffer2.read(&mut packet, None).await;
         assert!(result.is_err());
-        assert!(Error::ErrBufferClosed.equal(&result.unwrap_err()));
+        assert_eq!(Error::ErrBufferClosed, result.unwrap_err());
 
         drop(done_tx);
     });
@@ -178,7 +178,7 @@ async fn test_buffer_limit_count() {
     let result = buffer.write(&[4, 5]).await;
     assert!(result.is_err());
     if let Err(err) = result {
-        assert!(Error::ErrBufferFull.equal(&err));
+        assert_eq!(Error::ErrBufferFull, err);
     }
     assert_eq!(2, buffer.count().await);
 
@@ -198,7 +198,7 @@ async fn test_buffer_limit_count() {
     let result = buffer.write(&[8, 9]).await;
     assert!(result.is_err());
     if let Err(err) = result {
-        assert!(Error::ErrBufferFull.equal(&err));
+        assert_eq!(Error::ErrBufferFull, err);
     }
     assert_eq!(2, buffer.count().await);
 
@@ -236,7 +236,7 @@ async fn test_buffer_limit_size() {
     let result = buffer.write(&[4, 5]).await;
     assert!(result.is_err());
     if let Err(err) = result {
-        assert!(Error::ErrBufferFull.equal(&err));
+        assert_eq!(Error::ErrBufferFull, err);
     }
     assert_eq!(8, buffer.size().await);
 
@@ -261,7 +261,7 @@ async fn test_buffer_limit_size() {
     let result = buffer.write(&[9, 10]).await;
     assert!(result.is_err());
     if let Err(err) = result {
-        assert!(Error::ErrBufferFull.equal(&err));
+        assert_eq!(Error::ErrBufferFull, err);
     }
     assert_eq!(11, buffer.size().await);
 
@@ -320,7 +320,7 @@ async fn test_buffer_limit_sizes() {
         // Next write is expected to be errored.
         let result = buffer.write(&pkt).await;
         assert!(result.is_err(), "{}", name);
-        assert!(Error::ErrBufferFull.equal(&result.unwrap_err()), "{}", name);
+        assert_eq!(Error::ErrBufferFull, result.unwrap_err(), "{}", name);
 
         let mut packet = vec![0; size];
         for _ in 0..n_packets {
@@ -343,7 +343,7 @@ async fn test_buffer_misc() {
     let result = buffer.read(&mut packet, None).await;
     assert!(result.is_err());
     if let Err(err) = result {
-        assert!(Error::ErrBufferShort.equal(&err));
+        assert_eq!(Error::ErrBufferShort, err);
     }
 
     // Close

src/buffer/mod.rs

@@ -1,11 +1,8 @@
 #[cfg(test)]
 mod buffer_test;
 
-pub mod error;
+use crate::error::{Error, Result};
 
-use error::Error;
-
-use anyhow::Result;
 use std::sync::Arc;
 use tokio::sync::{mpsc, Mutex};
 use tokio::time::{timeout, Duration};

src/conn/conn_udp_listener.rs

@@ -1,8 +1,7 @@
-use super::error::Error;
 use super::*;
-
+use crate::error::Error;
 use crate::Buffer;
-use anyhow::Result;
+
 use core::sync::atomic::Ordering;
 use std::collections::HashMap;
 use std::future::Future;
@@ -239,7 +238,7 @@ impl Conn for UdpConn {
     }
 
     async fn recv(&self, buf: &mut [u8]) -> Result<usize> {
-        self.buffer.read(buf, None).await
+        Ok(self.buffer.read(buf, None).await?)
     }
 
     async fn recv_from(&self, buf: &mut [u8]) -> Result<(usize, SocketAddr)> {

src/conn/conn_udp_listener_test.rs

@@ -1,6 +1,6 @@
 use super::conn_udp_listener::*;
-use super::error::Error;
 use super::*;
+use crate::error::{Error, Result};
 
 use std::future::Future;
 use std::pin::Pin;
@@ -41,7 +41,7 @@ async fn pipe() -> Result<(
 
     let result = String::from_utf8(buf[..n].to_vec())?;
     if handshake != result {
-        Err(Error::new(format!("errHandshakeFailed: {} != {}", handshake, result)).into())
+        Err(Error::Other(format!("errHandshakeFailed: {} != {}", handshake, result)).into())
     } else {
         Ok((listener, l_conn, d_conn))
     }
@@ -118,7 +118,7 @@ async fn test_listener_accept_filter() -> Result<()> {
             let (c, _raddr) = match listener2.accept().await {
                 Ok((c, raddr)) => (c, raddr),
                 Err(err) => {
-                    assert!(Error::ErrClosedListener.equal(&err));
+                    assert_eq!(Error::ErrClosedListener, err);
                     return Result::<()>::Ok(());
                 }
             };
@@ -198,10 +198,7 @@ async fn test_listener_concurrent() -> Result<()> {
                 conn.close().await?;
             }
             Err(err) => {
-                assert!(
-                    Error::ErrClosedListener.equal(&err)
-                        || Error::ErrClosedListenerAcceptCh.equal(&err)
-                );
+                assert!(Error::ErrClosedListener == err || Error::ErrClosedListenerAcceptCh == err);
             }
         }
 

src/conn/mod.rs

@@ -3,7 +3,6 @@ pub mod conn_disconnected_packet;
 pub mod conn_pipe;
 pub mod conn_udp;
 pub mod conn_udp_listener;
-pub mod error;
 
 #[cfg(test)]
 mod conn_bridge_test;
@@ -17,12 +16,13 @@ mod conn_test;
 #[cfg(test)]
 mod conn_udp_listener_test;
 
-use anyhow::Result;
 use async_trait::async_trait;
 use std::net::SocketAddr;
 use std::sync::Arc;
 use tokio::net::ToSocketAddrs;
 
+use crate::error::Result;
+
 #[async_trait]
 pub trait Conn {
     async fn connect(&self, addr: SocketAddr) -> Result<()>;

src/vnet/error.rs → src/error.rs

@@ -1,7 +1,32 @@
+#![allow(dead_code)]
+
+use std::io;
+use std::net;
+use std::num::ParseIntError;
+use std::string::FromUtf8Error;
 use thiserror::Error;
 
+pub type Result<T> = std::result::Result<T, Error>;
+
 #[derive(Error, Debug, PartialEq)]
+#[non_exhaustive]
 pub enum Error {
+    #[error("buffer: full")]
+    ErrBufferFull,
+    #[error("buffer: closed")]
+    ErrBufferClosed,
+    #[error("buffer: short")]
+    ErrBufferShort,
+    #[error("packet too big")]
+    ErrPacketTooBig,
+    #[error("i/o timeout")]
+    ErrTimeout,
+    #[error("udp: listener closed")]
+    ErrClosedListener,
+    #[error("udp: listen queue exceeded")]
+    ErrListenQueueExceeded,
+    #[error("udp: listener accept ch closed")]
+    ErrClosedListenerAcceptCh,
     #[error("obs cannot be nil")]
     ErrObsCannotBeNil,
     #[error("se of closed network connection")]
@@ -80,14 +105,70 @@ pub enum Error {
     ErrNoIpaddrEth0,
     #[error("Invalid mask")]
     ErrInvalidMask,
-
-    #[allow(non_camel_case_types)]
+    #[error("parse ipnet: {0}")]
+    ParseIpnet(#[from] ipnet::AddrParseError),
+    #[error("parse ip: {0}")]
+    ParseIp(#[from] net::AddrParseError),
+    #[error("parse int: {0}")]
+    ParseInt(#[from] ParseIntError),
+    #[error("{0}")]
+    Io(#[source] IoError),
+    #[error("utf8: {0}")]
+    Utf8(#[from] FromUtf8Error),
+    #[error("{0}")]
+    Std(#[source] StdError),
     #[error("{0}")]
-    new(String),
+    Other(String),
 }
 
 impl Error {
-    pub fn equal(&self, err: &anyhow::Error) -> bool {
-        err.downcast_ref::<Self>().map_or(false, |e| e == self)
+    pub fn from_std<T>(error: T) -> Self
+    where
+        T: std::error::Error + Send + Sync + 'static,
+    {
+        Error::Std(StdError(Box::new(error)))
+    }
+
+    pub fn downcast_ref<T: std::error::Error + 'static>(&self) -> Option<&T> {
+        if let Error::Std(s) = self {
+            return s.0.downcast_ref();
+        }
+
+        None
+    }
+}
+
+#[derive(Debug, Error)]
+#[error("io error: {0}")]
+pub struct IoError(#[from] pub io::Error);
+
+// Workaround for wanting PartialEq for io::Error.
+impl PartialEq for IoError {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.kind() == other.0.kind()
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self {
+        Error::Io(IoError(e))
+    }
+}
+
+/// An escape hatch to preserve stack traces when we don't know the error.
+///
+/// This crate exports some traits such as `Conn` and `Listener`. The trait functions
+/// produce the local error `util::Error`. However when used in crates higher up the stack,
+/// we are forced to handle errors that are local to that crate. For example we use
+/// `Listener` the `dtls` crate and it needs to handle `dtls::Error`.
+///
+/// By using `util::Error::from_std` we can preserve the underlying error (and stack trace!).
+#[derive(Debug, Error)]
+#[error("{0}")]
+pub struct StdError(pub Box<dyn std::error::Error + Send + Sync>);
+
+impl PartialEq for StdError {
+    fn eq(&self, _: &Self) -> bool {
+        false
     }
 }