refactor: use thiserror & anyhow as error struct (#20)

Fix #18

Author: jjeffcaii

examples/proxy.rs

@@ -4,10 +4,11 @@ extern crate log;
 use futures::executor::block_on;
 use rsocket_rust::prelude::*;
 use rsocket_rust_transport_tcp::*;
-use std::error::Error;
+
+type Result<T> = rsocket_rust::Result<T>;
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
+async fn main() -> Result<()> {
     env_logger::builder().format_timestamp_millis().init();
 
     RSocketFactory::receive()

justfile

@@ -2,12 +2,14 @@ alias b := bench
 alias e := echo
 
 build:
-        @cargo build
+    @cargo build
 test:
-	@cargo test -- --nocapture
+    @cargo test -- --nocapture
 lint:
-	@cargo clippy
+    @cargo clippy
+fmt:
+    @cargo fmt
 echo:
-	@RUST_LOG=release cargo run --release --example echo -- serve tcp://127.0.0.1:7878
+    @RUST_LOG=release cargo run --release --example echo -- serve tcp://127.0.0.1:7878
 bench:
     @RUST_LOG=info cargo run --release --example qps -- -c 1000000 -s 1024 tcp://127.0.0.1:7878

rsocket-messaging/src/misc.rs

@@ -1,13 +1,13 @@
+use rsocket_rust::Result;
 use serde::{de::DeserializeOwned, Serialize};
-use std::error::Error;
 
 pub trait SerDe {
-    fn marshal<T>(&self, data: &T) -> Result<Vec<u8>, Box<dyn Error + Send + Sync>>
+    fn marshal<T>(&self, data: &T) -> Result<Vec<u8>>
     where
         Self: Sized,
         T: Sized + Serialize;
 
-    fn unmarshal<T>(&self, raw: &[u8]) -> Result<T, Box<dyn Error + Send + Sync>>
+    fn unmarshal<T>(&self, raw: &[u8]) -> Result<T>
     where
         Self: Sized,
         T: Sized + DeserializeOwned;
@@ -17,14 +17,14 @@ pub trait SerDe {
 struct JsonSerDe {}
 
 impl SerDe for JsonSerDe {
-    fn marshal<T>(&self, data: &T) -> Result<Vec<u8>, Box<dyn Error + Send + Sync>>
+    fn marshal<T>(&self, data: &T) -> Result<Vec<u8>>
     where
         T: Sized + Serialize,
     {
         Ok(serde_json::to_vec(data)?)
     }
 
-    fn unmarshal<T>(&self, raw: &[u8]) -> Result<T, Box<dyn Error + Send + Sync>>
+    fn unmarshal<T>(&self, raw: &[u8]) -> Result<T>
     where
         T: Sized + DeserializeOwned,
     {
@@ -43,29 +43,29 @@ pub fn cbor() -> impl SerDe {
 struct CborSerDe {}
 
 impl SerDe for CborSerDe {
-    fn marshal<T>(&self, data: &T) -> Result<Vec<u8>, Box<dyn Error + Send + Sync>>
+    fn marshal<T>(&self, data: &T) -> Result<Vec<u8>>
     where
         T: Sized + Serialize,
     {
         Ok(serde_cbor::to_vec(data)?)
     }
 
-    fn unmarshal<T>(&self, raw: &[u8]) -> Result<T, Box<dyn Error + Send + Sync>>
+    fn unmarshal<T>(&self, raw: &[u8]) -> Result<T>
     where
         T: Sized + DeserializeOwned,
     {
         Ok(serde_cbor::from_slice(raw)?)
     }
 }
 
-pub(crate) fn marshal<T>(ser: impl SerDe, data: &T) -> Result<Vec<u8>, Box<dyn Error + Send + Sync>>
+pub(crate) fn marshal<T>(ser: impl SerDe, data: &T) -> Result<Vec<u8>>
 where
     T: Sized + Serialize,
 {
     ser.marshal(data)
 }
 
-pub(crate) fn unmarshal<T>(de: impl SerDe, raw: &[u8]) -> Result<T, Box<dyn Error + Send + Sync>>
+pub(crate) fn unmarshal<T>(de: impl SerDe, raw: &[u8]) -> Result<T>
 where
     T: Sized + DeserializeOwned,
 {

rsocket-messaging/src/requester.rs

@@ -3,7 +3,7 @@ use bytes::{Bytes, BytesMut};
 use rsocket_rust::extension::{CompositeMetadata, MimeType, RoutingMetadata};
 use rsocket_rust::prelude::*;
 use rsocket_rust::utils::Writeable;
-use rsocket_rust::Result;
+use rsocket_rust::{error::RSocketError, Result};
 use rsocket_rust_transport_tcp::TcpClientTransport;
 use rsocket_rust_transport_websocket::WebsocketClientTransport;
 use serde::{de::DeserializeOwned, Serialize};
@@ -176,7 +176,7 @@ impl RequesterBuilder {
                 let requester = Requester::from(rsocket);
                 Ok(requester)
             }
-            None => Err("Missing transport!".into()),
+            None => Err(RSocketError::WithDescription("Missing transport!".into()).into()),
         }
     }
 }
@@ -368,7 +368,7 @@ where
     match *mime_type {
         MimeType::APPLICATION_JSON => Ok(Some(unmarshal(misc::json(), &raw.as_ref())?)),
         MimeType::APPLICATION_CBOR => Ok(Some(unmarshal(misc::cbor(), &raw.as_ref())?)),
-        _ => Err("unsupported mime type!".into()),
+        _ => Err(RSocketError::WithDescription("unsupported mime type!".into()).into()),
     }
 }
 
@@ -380,6 +380,6 @@ where
     match *mime_type {
         MimeType::APPLICATION_JSON => marshal(misc::json(), data),
         MimeType::APPLICATION_CBOR => marshal(misc::cbor(), data),
-        _ => Err("unsupported mime type!".into()),
+        _ => Err(RSocketError::WithDescription("unsupported mime type!".into()).into()),
     }
 }

rsocket-transport-tcp/src/client/tcp.rs

@@ -1,6 +1,6 @@
 use crate::{connection::TcpConnection, misc::parse_tcp_addr};
 use async_trait::async_trait;
-use rsocket_rust::{transport::Transport, Result};
+use rsocket_rust::{error::RSocketError, transport::Transport, Result};
 use std::net::SocketAddr;
 use tokio::net::TcpStream;
 
@@ -24,7 +24,7 @@ impl Transport for TcpClientTransport {
             Connector::Direct(socket) => Ok(TcpConnection::from(socket)),
             Connector::Lazy(addr) => match TcpStream::connect(addr).await {
                 Ok(stream) => Ok(TcpConnection::from(stream)),
-                Err(e) => Err(Box::new(e)),
+                Err(e) => Err(RSocketError::IO(e).into()),
             },
         }
     }

rsocket-transport-tcp/src/client/uds.rs

@@ -1,7 +1,7 @@
 use crate::connection::UnixConnection;
 use crate::misc::parse_uds_addr;
 use async_trait::async_trait;
-use rsocket_rust::{transport::Transport, Result};
+use rsocket_rust::{error::RSocketError, transport::Transport, Result};
 use tokio::net::UnixStream;
 
 #[derive(Debug)]
@@ -24,7 +24,7 @@ impl Transport for UnixClientTransport {
             Connector::Direct(socket) => Ok(UnixConnection::from(socket)),
             Connector::Lazy(addr) => match UnixStream::connect(addr).await {
                 Ok(stream) => Ok(UnixConnection::from(stream)),
-                Err(e) => Err(Box::new(e)),
+                Err(e) => Err(RSocketError::IO(e).into()),
             },
         }
     }

rsocket-transport-tcp/src/connection/tcp.rs

@@ -4,7 +4,7 @@ use futures::stream::{SplitSink, SplitStream};
 use futures::{SinkExt, StreamExt};
 use rsocket_rust::frame::Frame;
 use rsocket_rust::transport::{Connection, Reader, Writer};
-use rsocket_rust::Result;
+use rsocket_rust::{error::RSocketError, Result};
 use tokio::net::TcpStream;
 use tokio_util::codec::Framed;
 
@@ -26,7 +26,7 @@ impl Writer for InnerWriter {
     async fn write(&mut self, frame: Frame) -> Result<()> {
         match self.sink.send(frame).await {
             Ok(()) => Ok(()),
-            Err(e) => Err(Box::new(e)),
+            Err(e) => Err(RSocketError::IO(e).into()),
         }
     }
 }
@@ -36,7 +36,7 @@ impl Reader for InnerReader {
     async fn read(&mut self) -> Option<Result<Frame>> {
         match self.stream.next().await {
             Some(Ok(frame)) => Some(Ok(frame)),
-            Some(Err(e)) => Some(Err(Box::new(e))),
+            Some(Err(e)) => Some(Err(RSocketError::IO(e).into())),
             None => None,
         }
     }

rsocket-transport-tcp/src/connection/uds.rs

@@ -4,7 +4,7 @@ use futures::stream::{SplitSink, SplitStream};
 use futures::{SinkExt, StreamExt};
 use rsocket_rust::frame::Frame;
 use rsocket_rust::transport::{Connection, Reader, Writer};
-use rsocket_rust::Result;
+use rsocket_rust::{error::RSocketError, Result};
 use tokio::net::UnixStream;
 use tokio_util::codec::Framed;
 
@@ -41,7 +41,7 @@ impl Writer for InnerWriter {
     async fn write(&mut self, frame: Frame) -> Result<()> {
         match self.sink.send(frame).await {
             Ok(()) => Ok(()),
-            Err(e) => Err(Box::new(e)),
+            Err(e) => Err(RSocketError::IO(e).into()),
         }
     }
 }
@@ -51,7 +51,7 @@ impl Reader for InnerReader {
     async fn read(&mut self) -> Option<Result<Frame>> {
         match self.stream.next().await {
             Some(Ok(frame)) => Some(Ok(frame)),
-            Some(Err(e)) => Some(Err(Box::new(e))),
+            Some(Err(e)) => Some(Err(RSocketError::IO(e).into())),
             None => None,
         }
     }

rsocket-transport-tcp/src/server/tcp.rs

@@ -1,6 +1,6 @@
 use crate::{client::TcpClientTransport, misc::parse_tcp_addr};
 use async_trait::async_trait;
-use rsocket_rust::{transport::ServerTransport, Result};
+use rsocket_rust::{error::RSocketError, transport::ServerTransport, Result};
 use std::net::SocketAddr;
 use tokio::net::TcpListener;
 
@@ -33,7 +33,7 @@ impl ServerTransport for TcpServerTransport {
                 debug!("listening on: {}", &self.addr);
                 Ok(())
             }
-            Err(e) => Err(Box::new(e)),
+            Err(e) => Err(RSocketError::IO(e).into()),
         }
     }
 
@@ -44,9 +44,9 @@ impl ServerTransport for TcpServerTransport {
                     let tp = TcpClientTransport::from(socket);
                     Some(Ok(tp))
                 }
-                Err(e) => Some(Err(Box::new(e))),
+                Err(e) => Some(Err(RSocketError::IO(e).into())),
             },
-            None => Some(Err("err".into())),
+            None => None,
         }
     }
 }

rsocket-transport-tcp/src/server/uds.rs

@@ -1,7 +1,7 @@
 use crate::client::UnixClientTransport;
 use crate::misc::parse_uds_addr;
 use async_trait::async_trait;
-use rsocket_rust::{transport::ServerTransport, Result};
+use rsocket_rust::{error::RSocketError, transport::ServerTransport, Result};
 use tokio::net::UnixListener;
 
 #[derive(Debug)]
@@ -33,15 +33,15 @@ impl ServerTransport for UnixServerTransport {
                 debug!("listening on: {}", &self.addr);
                 Ok(())
             }
-            Err(e) => Err(Box::new(e)),
+            Err(e) => Err(RSocketError::IO(e).into()),
         }
     }
 
     async fn next(&mut self) -> Option<Result<Self::Item>> {
         match self.listener.as_mut() {
             Some(listener) => match listener.accept().await {
                 Ok((socket, _)) => Some(Ok(UnixClientTransport::from(socket))),
-                Err(e) => Some(Err(Box::new(e))),
+                Err(e) => Some(Err(RSocketError::IO(e).into())),
             },
             None => None,
         }