use std::fmt;
#[derive(Debug)]
pub enum Error {
Parse(String),
Envelope(String),
Emit(String),
Invalid(Box<crate::request::ValidationFailure>),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Error::Parse(m) => write!(f, "kaivrpc parse: {m}"),
Error::Envelope(m) => write!(f, "kaivrpc envelope: {m}"),
Error::Emit(m) => write!(f, "kaivrpc emit: {m}"),
Error::Invalid(v) => write!(f, "kaivrpc invalid request: {v}"),
}
}
}
impl std::error::Error for Error {}
impl From<kaiv::error::PipelineError> for Error {
fn from(e: kaiv::error::PipelineError) -> Self {
Error::Emit(e.to_string())
}
}
impl From<kaiv::serde::Error> for Error {
fn from(e: kaiv::serde::Error) -> Self {
Error::Envelope(e.to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RpcError {
pub code: i32,
pub name: String,
pub message: String,
}
impl RpcError {
pub fn new(code: i32, name: impl Into<String>, message: impl Into<String>) -> RpcError {
RpcError {
code,
name: name.into(),
message: message.into(),
}
}
pub fn to_line(&self) -> String {
let msg = self.message.replace(['\n', '\r', '\0'], " ");
format!("{} {}: {}", self.code, self.name, msg)
}
pub fn from_line(s: &str) -> RpcError {
let mut parts = s.splitn(2, ": ");
let head = parts.next().unwrap_or("");
let message = parts.next().unwrap_or("").to_string();
let mut head_parts = head.splitn(2, ' ');
let code = head_parts.next().and_then(|c| c.parse().ok());
let name = head_parts.next().unwrap_or("").to_string();
match (code, message.is_empty()) {
(Some(code), false) => RpcError {
code,
name,
message,
},
_ => RpcError {
code: 0,
name: String::new(),
message: s.to_string(),
},
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn error_lines_round_trip_and_stay_flat() {
let e = RpcError::new(602, "InvalidParams", "ids is empty");
assert_eq!(e.to_line(), "602 InvalidParams: ids is empty");
assert_eq!(RpcError::from_line(&e.to_line()), e);
let m = RpcError::new(500, "Internal", "broke\nbadly").to_line();
assert_eq!(m, "500 Internal: broke badly");
let odd = RpcError::from_line("something went wrong");
assert_eq!(odd.code, 0);
assert_eq!(odd.message, "something went wrong");
}
}