Unify error handling to have IpcError and TryRecvError be the main error

types.
These types will give the Bincode error, Io errors (which are converted
from platform errors) and Disconnect.
Additionally we now use the thiserror crate which removes some of the
code.

Signed-off-by: Narfinger <[email protected]>

Author: Narfinger

Cargo.toml

@@ -38,6 +38,7 @@ futures-channel = { version = "0.3.31", optional = true }
 futures-core = { version = "0.3.31", optional = true }
 libc = "0.2.162"
 serde = { version = "1.0", features = ["rc"] }
+thiserror = "2.0.12"
 uuid = { version = "1", features = ["v4"] }
 
 [target.'cfg(any(target_os = "linux", target_os = "openbsd", target_os = "freebsd", target_os = "illumos"))'.dependencies]

src/error.rs

@@ -0,0 +1,21 @@
+use std::io;
+
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum IpcError {
+    #[error("Error in decoding or encoding: {0}")]
+    Bincode(#[from] bincode::Error),
+    #[error("Error in IO: {0}")]
+    Io(#[from] io::Error),
+    #[error("Ipc Disconnected")]
+    Disconnected,
+}
+
+#[derive(Debug, Error)]
+pub enum TryRecvError {
+    #[error("IPC error")]
+    IpcError(#[from] IpcError),
+    #[error("Channel empty")]
+    Empty,
+}

src/ipc.rs

@@ -11,12 +11,12 @@ use crate::platform::{self, OsIpcChannel, OsIpcReceiver, OsIpcReceiverSet, OsIpc
 use crate::platform::{
     OsIpcOneShotServer, OsIpcSelectionResult, OsIpcSharedMemory, OsOpaqueIpcChannel,
 };
+use crate::{IpcError, TryRecvError};
 
 use bincode;
 use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
 use std::cell::RefCell;
 use std::cmp::min;
-use std::error::Error as StdError;
 use std::fmt::{self, Debug, Formatter};
 use std::io;
 use std::marker::PhantomData;
@@ -37,57 +37,6 @@ thread_local! {
         const { RefCell::new(Vec::new()) }
 }
 
-#[derive(Debug)]
-pub enum IpcError {
-    Bincode(bincode::Error),
-    Io(io::Error),
-    Disconnected,
-}
-
-impl fmt::Display for IpcError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            IpcError::Bincode(ref err) => write!(fmt, "bincode error: {err}"),
-            IpcError::Io(ref err) => write!(fmt, "io error: {err}"),
-            IpcError::Disconnected => write!(fmt, "disconnected"),
-        }
-    }
-}
-
-impl StdError for IpcError {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        match *self {
-            IpcError::Bincode(ref err) => Some(err),
-            IpcError::Io(ref err) => Some(err),
-            IpcError::Disconnected => None,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum TryRecvError {
-    IpcError(IpcError),
-    Empty,
-}
-
-impl fmt::Display for TryRecvError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            TryRecvError::IpcError(ref err) => write!(fmt, "ipc error: {err}"),
-            TryRecvError::Empty => write!(fmt, "empty"),
-        }
-    }
-}
-
-impl StdError for TryRecvError {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        match *self {
-            TryRecvError::IpcError(ref err) => Some(err),
-            TryRecvError::Empty => None,
-        }
-    }
-}
-
 /// Create a connected [IpcSender] and [IpcReceiver] that
 /// transfer messages of a given type provided by type `T`
 /// or inferred by the types of messages sent by the sender.
@@ -248,16 +197,12 @@ where
 {
     /// Blocking receive.
     pub fn recv(&self) -> Result<T, IpcError> {
-        self.os_receiver.recv()?.to().map_err(IpcError::Bincode)
+        self.os_receiver.recv()?.to()
     }
 
     /// Non-blocking receive
     pub fn try_recv(&self) -> Result<T, TryRecvError> {
-        self.os_receiver
-            .try_recv()?
-            .to()
-            .map_err(IpcError::Bincode)
-            .map_err(TryRecvError::IpcError)
+        self.os_receiver.try_recv()?.to().map_err(|e| e.into())
     }
 
     /// Blocks for up to the specified duration attempting to receive a message.
@@ -270,8 +215,7 @@ where
         self.os_receiver
             .try_recv_timeout(duration)?
             .to()
-            .map_err(IpcError::Bincode)
-            .map_err(TryRecvError::IpcError)
+            .map_err(|e| e.into())
     }
 
     /// Erase the type of the channel.
@@ -364,7 +308,7 @@ where
     }
 
     /// Send data across the channel to the receiver.
-    pub fn send(&self, data: T) -> Result<(), bincode::Error> {
+    pub fn send(&self, data: T) -> Result<(), IpcError> {
         let mut bytes = Vec::with_capacity(4096);
         OS_IPC_CHANNELS_FOR_SERIALIZATION.with(|os_ipc_channels_for_serialization| {
             OS_IPC_SHARED_MEMORY_REGIONS_FOR_SERIALIZATION.with(
@@ -726,7 +670,7 @@ impl IpcMessage {
     }
 
     /// Deserialize the raw data in the contained message into the inferred type.
-    pub fn to<T>(mut self) -> Result<T, bincode::Error>
+    pub fn to<T>(mut self) -> Result<T, IpcError>
     where
         T: for<'de> Deserialize<'de> + Serialize,
     {
@@ -744,7 +688,7 @@ impl IpcMessage {
                             .map(Some)
                             .collect(),
                     );
-                    let result = bincode::deserialize(&self.data[..]);
+                    let result = bincode::deserialize(&self.data[..]).map_err(|e| e.into());
                     *os_ipc_shared_memory_regions_for_deserialization.borrow_mut() =
                         old_ipc_shared_memory_regions_for_deserialization;
                     mem::swap(
@@ -886,7 +830,7 @@ where
         ))
     }
 
-    pub fn accept(self) -> Result<(IpcReceiver<T>, T), bincode::Error> {
+    pub fn accept(self) -> Result<(IpcReceiver<T>, T), IpcError> {
         let (os_receiver, ipc_message) = self.os_server.accept()?;
         Ok((
             IpcReceiver {

src/lib.rs

@@ -32,11 +32,12 @@ pub mod asynch;
 #[cfg(all(not(feature = "force-inprocess"), target_os = "windows"))]
 extern crate windows;
 
+mod error;
 pub mod ipc;
 pub mod platform;
 pub mod router;
 
 #[cfg(test)]
 mod test;
 
-pub use bincode::{Error, ErrorKind};
+pub use error::{IpcError, TryRecvError};

src/platform/inprocess/mod.rs

@@ -7,20 +7,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use crate::ipc::{self, IpcMessage};
-use bincode;
+use crate::ipc::IpcMessage;
 use crossbeam_channel::{self, Receiver, RecvTimeoutError, Select, Sender, TryRecvError};
 use std::cell::{Ref, RefCell};
 use std::cmp::PartialEq;
 use std::collections::hash_map::HashMap;
-use std::error::Error as StdError;
 use std::fmt::{self, Debug, Formatter};
 use std::io;
 use std::ops::{Deref, RangeFrom};
 use std::slice;
 use std::sync::{Arc, LazyLock, Mutex};
 use std::time::Duration;
 use std::usize;
+use thiserror::Error;
 use uuid::Uuid;
 
 #[derive(Clone)]
@@ -387,11 +386,15 @@ impl OsIpcSharedMemory {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Error)]
 pub enum ChannelError {
+    #[error("Channel Closed")]
     ChannelClosedError,
+    #[error("Broken Pipe")]
     BrokenPipeError,
+    #[error("Channel Empty")]
     ChannelEmpty,
+    #[error("Unknown Error")]
     UnknownError,
 }
 
@@ -402,42 +405,23 @@ impl ChannelError {
     }
 }
 
-impl fmt::Display for ChannelError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ChannelError::ChannelClosedError => write!(fmt, "channel closed"),
-            ChannelError::BrokenPipeError => write!(fmt, "broken pipe"),
-            ChannelError::ChannelEmpty => write!(fmt, "channel empty"),
-            ChannelError::UnknownError => write!(fmt, "unknown error"),
-        }
-    }
-}
-
-impl StdError for ChannelError {}
-
-impl From<ChannelError> for bincode::Error {
-    fn from(crossbeam_error: ChannelError) -> Self {
-        io::Error::from(crossbeam_error).into()
-    }
-}
-
-impl From<ChannelError> for ipc::IpcError {
+impl From<ChannelError> for crate::IpcError {
     fn from(error: ChannelError) -> Self {
         match error {
-            ChannelError::ChannelClosedError => ipc::IpcError::Disconnected,
-            e => ipc::IpcError::Bincode(io::Error::from(e).into()),
+            ChannelError::ChannelClosedError => crate::IpcError::Disconnected,
+            e => crate::IpcError::Io(io::Error::from(e).into()),
         }
     }
 }
 
-impl From<ChannelError> for ipc::TryRecvError {
+impl From<ChannelError> for crate::TryRecvError {
     fn from(error: ChannelError) -> Self {
         match error {
             ChannelError::ChannelClosedError => {
-                ipc::TryRecvError::IpcError(ipc::IpcError::Disconnected)
+                crate::TryRecvError::IpcError(crate::IpcError::Disconnected)
             },
-            ChannelError::ChannelEmpty => ipc::TryRecvError::Empty,
-            e => ipc::TryRecvError::IpcError(ipc::IpcError::Bincode(io::Error::from(e).into())),
+            ChannelError::ChannelEmpty => crate::TryRecvError::Empty,
+            e => crate::TryRecvError::IpcError(crate::IpcError::Io(io::Error::from(e).into())),
         }
     }
 }