improve openraft error mapping in lite implementation

CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## [0.1.17] - 2024-04-06
+better openraft error mapping in lite implementation
+
 ## [0.1.16] - 2024-04-04
 Bug fixes and code refactoring in clients
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rxqlite"
-version = "0.1.16"
+version = "0.1.17"
 readme = "README.md"
 edition = "2021"
 authors = [

ROADMAP.md

@@ -1,6 +1,6 @@
 # Roadmap
 
-## [0.1.17]
+## [0.1.18]
 Client authorization
 
 ## [0.1.12]

crates/rxqlite-lite-common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rxqlite-lite-common"
-version = "0.1.3"
+version = "0.1.4"
 
 
 edition = "2021"
@@ -17,6 +17,7 @@ repository = "https://github.com/HaHa421/rxqlite"
 
 [dependencies]
 anyhow = "1.0"
+anyerror = "0.1.12"
 derive_more = "0.99.9"
 futures-util= "0.3"
 rustls = {version = "0.22" }

crates/rxqlite-lite-common/src/lib.rs

@@ -10,6 +10,7 @@ use std::error::Error;
 use std::fmt;
 use rxqlite_common::MessageResponse;
 use serde::{Serialize, Deserialize};
+pub use anyerror::AnyError;
 
 use std::collections::{
   btree_map::BTreeMap,
@@ -96,22 +97,99 @@ impl<T: Error> RemoteError<T> {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[derive(serde::Deserialize, serde::Serialize)]
+#[error("Unreachable node: {source}")]
+pub struct Unreachable {
+    #[from]
+    pub source: AnyError,
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct PayloadTooLarge {
+    pub action: RPCTypes,
+
+    /// An optional hint indicating the anticipated number of entries.
+    /// Used only for append-entries replication.
+    pub entries_hint: u64,
+
+    /// An optional hint indicating the anticipated size in bytes.
+    /// Used for snapshot replication.
+    pub bytes_hint: u64,
+
+    #[source]
+    pub source: Option<AnyError>,
+}
+
+impl fmt::Display for PayloadTooLarge {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "RPC",)?;
+        write!(f, "({})", self.action)?;
+        write!(f, " payload too large:",)?;
+
+        write!(f, " hint:(")?;
+        match self.action {
+            RPCTypes::Vote => {
+                unreachable!("vote rpc should not have payload")
+            }
+            RPCTypes::AppendEntries => {
+                write!(f, "entries:{}", self.entries_hint)?;
+            }
+            RPCTypes::InstallSnapshot => {
+                write!(f, "bytes:{}", self.bytes_hint)?;
+            }
+        }
+        write!(f, ")")?;
+
+        if let Some(s) = &self.source {
+            write!(f, ", source: {}", s)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[derive(serde::Deserialize, serde::Serialize)]
+#[error("NetworkError: {source}")]
+pub struct NetworkError {
+    #[from]
+    pub source: AnyError,
+}
+
+impl NetworkError {
+    pub fn new<E: Error + 'static>(e: &E) -> Self {
+        Self {
+            source: AnyError::new(e),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(bound(serialize = "E: serde::Serialize"))]
 #[serde(bound(deserialize = "E: for <'d> serde::Deserialize<'d>"))]
 pub enum RPCError<E: Error> {
-    Timeout(#[from]  Timeout),
-    Unreachable,
-    PayloadTooLarge,
+    #[error(transparent)]
+    Timeout(#[from] Timeout),
+
+    #[error(transparent)]
+    Unreachable(#[from] Unreachable),
+
+    #[error(transparent)]
+    PayloadTooLarge(#[from] PayloadTooLarge),
 
     /// Failed to send the RPC request and should retry immediately.
-    Network,
+    #[error(transparent)]
+    Network(#[from] NetworkError),
 
     #[error(transparent)]
     RemoteError(#[from] RemoteError<E>),
 }
-
+/*
 impl<E: Error> Display for RPCError<E> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -124,7 +202,7 @@ impl<E: Error> Display for RPCError<E> {
         
     }
 }
-
+*/
 
 impl<E> RPCError<RaftError<E>>
 where
@@ -135,9 +213,9 @@ where
     where E: TryAsRef<ForwardToLeader> {
         match self {
             RPCError::Timeout(_) => None,
-            RPCError::Unreachable => None,
-            RPCError::PayloadTooLarge => None,
-            RPCError::Network => None,
+            RPCError::Unreachable(_) => None,
+            RPCError::PayloadTooLarge(_) => None,
+            RPCError::Network(_) => None,
             RPCError::RemoteError(remote_err) => remote_err.source.forward_to_leader(),
         }
     }

src/convert.rs

@@ -98,6 +98,36 @@ impl RXQliteInto<Timeout> for openraft::error::Timeout<NodeId>
   }
 }
 
+impl RXQliteInto<Unreachable> for openraft::error::Unreachable 
+{
+  fn into_lite(self) -> Unreachable {
+    Unreachable {
+      source : AnyError::new(&self),
+    }
+  }
+}
+
+impl RXQliteInto<NetworkError> for openraft::error::NetworkError
+{
+  fn into_lite(self) -> NetworkError {
+    NetworkError {
+      source : AnyError::new(&self),
+    }
+  }
+}
+impl RXQliteInto<PayloadTooLarge > for openraft::error::PayloadTooLarge 
+{
+  fn into_lite(self) -> PayloadTooLarge  {
+    PayloadTooLarge  {
+      action: self.action().into_lite(),
+      entries_hint: self.entries_hint(),
+      bytes_hint: 0,
+      //or we might loose information:
+      source : Some(AnyError::new(&self)),
+    }
+  }
+}
+
 impl<T,U> RXQliteInto<RemoteError<U>> for openraft::error::RemoteError<NodeId,Node,T> 
 where  T: Error + RXQliteInto<U>,
        U: Error
@@ -117,9 +147,9 @@ impl<Err: Error,FromErr> RXQliteInto<RPCError<Err>> for openraft::error::RPCErro
   fn into_lite(self) -> RPCError<Err> {
     match self {
       Self::Timeout(to)=>RPCError::Timeout(to.into_lite()),
-      Self::Unreachable(_)=>RPCError::Unreachable,
-      Self::PayloadTooLarge(_)=>RPCError::PayloadTooLarge,
-      Self::Network(_)=>RPCError::Network,
+      Self::Unreachable(u)=>RPCError::Unreachable(u.into_lite()),
+      Self::PayloadTooLarge(p)=>RPCError::PayloadTooLarge(p.into_lite()),
+      Self::Network(n)=>RPCError::Network(n.into_lite()),
       Self::RemoteError(re)=>RPCError::RemoteError(re.into_lite()),
     }
   }