611 lines
14 KiB
Rust
611 lines
14 KiB
Rust
//! Error handling and reporting.
|
|
|
|
#[macro_export]
|
|
macro_rules! err_dbg_dis {
|
|
($tt:ty, $nn:expr) => {
|
|
impl ::core::fmt::Display for $tt {
|
|
fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
|
write!(fmt, "{}::{:?}", $nn, self)
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
pub use anyhow;
|
|
pub use thiserror;
|
|
pub use thiserror::Error as ThisError;
|
|
// pub use thiserror::UserErrorClass;
|
|
// pub use thiserror::UserErrorContent;
|
|
|
|
pub mod bt {
|
|
pub use backtrace::Backtrace;
|
|
}
|
|
|
|
use serde::Deserialize;
|
|
use serde::Serialize;
|
|
use std::array::TryFromSliceError;
|
|
use std::convert::Infallible;
|
|
use std::fmt;
|
|
use std::net::AddrParseError;
|
|
use std::num::ParseFloatError;
|
|
use std::num::ParseIntError;
|
|
use std::string::FromUtf8Error;
|
|
use std::sync::PoisonError;
|
|
|
|
pub type Res2<T> = anyhow::Result<T>;
|
|
|
|
#[derive(Debug, ThisError)]
|
|
pub enum ErrA {
|
|
#[error("bad-A")]
|
|
Bad,
|
|
}
|
|
|
|
#[derive(Debug, ThisError)]
|
|
pub enum ErrB {
|
|
#[error("worse-B")]
|
|
Worse,
|
|
#[error("FromArrA")]
|
|
ErrA(#[from] ErrA),
|
|
}
|
|
|
|
fn f_a() -> Result<u32, ErrA> {
|
|
Err(ErrA::Bad)
|
|
}
|
|
|
|
fn f_b() -> Result<u32, ErrB> {
|
|
if true {
|
|
let res = f_a()?;
|
|
Ok(res)
|
|
} else {
|
|
Err(ErrB::Worse)
|
|
}
|
|
}
|
|
|
|
#[allow(unused)]
|
|
fn f_c() -> Result<u32, anyhow::Error> {
|
|
return Ok(f_b()?);
|
|
}
|
|
|
|
#[test]
|
|
fn test_fc() {
|
|
assert!(f_c().is_err());
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
pub enum Reason {
|
|
InternalError,
|
|
BadRequest,
|
|
IoError,
|
|
}
|
|
|
|
/// The common error type for this application.
|
|
#[derive(Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct Error {
|
|
msg: String,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
trace_str: Option<String>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
public_msg: Option<Vec<String>>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
reason: Option<Reason>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
parent: Option<Box<Error>>,
|
|
}
|
|
|
|
impl Error {
|
|
pub fn with_msg_no_trace<S: Into<String>>(s: S) -> Self {
|
|
Self {
|
|
msg: s.into(),
|
|
trace_str: None,
|
|
public_msg: None,
|
|
reason: None,
|
|
parent: None,
|
|
}
|
|
}
|
|
|
|
pub fn with_msg<S: Into<String>>(s: S) -> Self {
|
|
Self::with_msg_no_trace(s).add_backtrace()
|
|
}
|
|
|
|
pub fn with_public_msg_no_trace<S: Into<String>>(s: S) -> Self {
|
|
let s = s.into();
|
|
let ret = Self::with_msg_no_trace(&s);
|
|
let ret = ret.add_public_msg(s);
|
|
ret
|
|
}
|
|
|
|
pub fn with_public_msg<S: Into<String>>(s: S) -> Self {
|
|
let s = s.into();
|
|
let ret = Self::with_msg_no_trace(String::new());
|
|
let ret = ret.add_backtrace();
|
|
let ret = ret.add_public_msg(s);
|
|
ret
|
|
}
|
|
|
|
pub fn from_string<E>(e: E) -> Self
|
|
where
|
|
E: ToString,
|
|
{
|
|
Self::with_msg_no_trace(e.to_string())
|
|
}
|
|
|
|
pub fn add_backtrace(mut self) -> Self {
|
|
self.msg.extend(" (add_backtrace DISABLED)".chars());
|
|
// ret.trace_str = Some(fmt_backtrace(&backtrace::Backtrace::new()));
|
|
self
|
|
}
|
|
|
|
pub fn mark_bad_request(mut self) -> Self {
|
|
self.reason = Some(Reason::BadRequest);
|
|
self
|
|
}
|
|
|
|
pub fn mark_io_error(mut self) -> Self {
|
|
self.reason = Some(Reason::IoError);
|
|
self
|
|
}
|
|
|
|
pub fn add_public_msg(mut self, msg: impl Into<String>) -> Self {
|
|
if self.public_msg.is_none() {
|
|
self.public_msg = Some(Vec::new());
|
|
}
|
|
self.public_msg.as_mut().unwrap().push(msg.into());
|
|
self
|
|
}
|
|
|
|
pub fn msg(&self) -> &str {
|
|
&self.msg
|
|
}
|
|
|
|
pub fn public_msg(&self) -> Option<&Vec<String>> {
|
|
self.public_msg.as_ref()
|
|
}
|
|
|
|
pub fn reason(&self) -> Option<Reason> {
|
|
self.reason.clone()
|
|
}
|
|
}
|
|
|
|
#[allow(unused)]
|
|
fn fmt_backtrace(trace: &backtrace::Backtrace) -> String {
|
|
if true {
|
|
return String::from("fmt_backtrace DISABLED");
|
|
}
|
|
use std::io::Write;
|
|
let mut buf = Vec::new();
|
|
let mut c1 = 0;
|
|
'outer: for fr in trace.frames() {
|
|
for sy in fr.symbols() {
|
|
let is_ours = match sy.filename() {
|
|
None => false,
|
|
Some(s) => {
|
|
let s = s.to_str().unwrap();
|
|
s.contains("/dev/daqbuffer/") || s.contains("/build/daqbuffer/")
|
|
}
|
|
};
|
|
let name = match sy.name() {
|
|
Some(k) => k.to_string(),
|
|
_ => "[err]".into(),
|
|
};
|
|
let filename = match sy.filename() {
|
|
Some(k) => match k.to_str() {
|
|
Some(k) => k,
|
|
_ => "[err]",
|
|
},
|
|
_ => "[err]",
|
|
};
|
|
let lineno = match sy.lineno() {
|
|
Some(k) => k,
|
|
_ => 0,
|
|
};
|
|
if is_ours {
|
|
write!(&mut buf, "\n {name}\n {filename} {lineno}").unwrap();
|
|
c1 += 1;
|
|
if c1 >= 10 {
|
|
break 'outer;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
String::from_utf8(buf).unwrap()
|
|
}
|
|
|
|
impl fmt::Debug for Error {
|
|
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
|
let trace_str = if let Some(s) = &self.trace_str {
|
|
s.into()
|
|
} else {
|
|
String::new()
|
|
};
|
|
write!(fmt, "msg: {}", self.msg)?;
|
|
if let Some(msgs) = self.public_msg() {
|
|
for (i, msg) in msgs.iter().enumerate() {
|
|
write!(fmt, "; pub({i}): {msg}")?;
|
|
}
|
|
}
|
|
if !trace_str.is_empty() {
|
|
write!(fmt, "\nTrace:\n{}", trace_str)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Error {
|
|
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
|
fmt::Debug::fmt(self, fmt)
|
|
}
|
|
}
|
|
|
|
impl std::error::Error for Error {}
|
|
|
|
pub trait ErrConv<T> {
|
|
fn err_conv(self) -> Result<T, Error>;
|
|
}
|
|
|
|
impl<T, E> ErrConv<T> for Result<T, E>
|
|
where
|
|
E: Into<Error>,
|
|
{
|
|
fn err_conv(self) -> Result<T, Error> {
|
|
match self {
|
|
Ok(k) => Ok(k),
|
|
Err(e) => Err(e.into()),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait ErrStr<T> {
|
|
fn errstr(self) -> Result<T, Error>;
|
|
}
|
|
|
|
impl<T, E> ErrStr<T> for Result<T, E>
|
|
where
|
|
E: ToString,
|
|
{
|
|
fn errstr(self) -> Result<T, Error> {
|
|
match self {
|
|
Ok(k) => Ok(k),
|
|
Err(e) => Err(Error::with_msg_no_trace(e.to_string())),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait ToErr {
|
|
fn to_err(self) -> Error;
|
|
}
|
|
|
|
impl<T: ToErr> From<T> for Error {
|
|
fn from(k: T) -> Self {
|
|
k.to_err()
|
|
}
|
|
}
|
|
|
|
impl From<PublicError> for Error {
|
|
fn from(k: PublicError) -> Self {
|
|
Self {
|
|
msg: String::new(),
|
|
trace_str: None,
|
|
public_msg: Some(k.msg.clone()),
|
|
reason: k.reason(),
|
|
parent: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ToErr for Infallible {
|
|
fn to_err(self) -> Error {
|
|
Error::with_msg_no_trace(String::new())
|
|
}
|
|
}
|
|
|
|
impl From<String> for Error {
|
|
fn from(k: String) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<&str> for Error {
|
|
fn from(k: &str) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<std::io::Error> for Error {
|
|
fn from(k: std::io::Error) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<AddrParseError> for Error {
|
|
fn from(k: AddrParseError) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<serde_json::Error> for Error {
|
|
fn from(k: serde_json::Error) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl<T> From<async_channel::SendError<T>> for Error {
|
|
fn from(k: async_channel::SendError<T>) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<async_channel::RecvError> for Error {
|
|
fn from(k: async_channel::RecvError) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl<T> From<async_channel_2::SendError<T>> for Error {
|
|
fn from(k: async_channel_2::SendError<T>) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<async_channel_2::RecvError> for Error {
|
|
fn from(k: async_channel_2::RecvError) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<chrono::format::ParseError> for Error {
|
|
fn from(k: chrono::format::ParseError) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<ParseIntError> for Error {
|
|
fn from(k: ParseIntError) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<ParseFloatError> for Error {
|
|
fn from(k: ParseFloatError) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<FromUtf8Error> for Error {
|
|
fn from(k: FromUtf8Error) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<std::str::Utf8Error> for Error {
|
|
fn from(k: std::str::Utf8Error) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<serde_cbor::Error> for Error {
|
|
fn from(k: serde_cbor::Error) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<std::fmt::Error> for Error {
|
|
fn from(k: std::fmt::Error) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<regex::Error> for Error {
|
|
fn from(k: regex::Error) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl<T> From<PoisonError<T>> for Error {
|
|
fn from(_: PoisonError<T>) -> Self {
|
|
Self::from_string("PoisonError")
|
|
}
|
|
}
|
|
|
|
impl From<url::ParseError> for Error {
|
|
fn from(k: url::ParseError) -> Self {
|
|
Self::from_string(format!("{:?}", k))
|
|
}
|
|
}
|
|
|
|
impl From<TryFromSliceError> for Error {
|
|
fn from(k: TryFromSliceError) -> Self {
|
|
Self::from_string(format!("{:?}", k))
|
|
}
|
|
}
|
|
|
|
impl From<rmp_serde::encode::Error> for Error {
|
|
fn from(k: rmp_serde::encode::Error) -> Self {
|
|
Self::from_string(format!("{:?}", k))
|
|
}
|
|
}
|
|
|
|
impl From<rmp_serde::decode::Error> for Error {
|
|
fn from(k: rmp_serde::decode::Error) -> Self {
|
|
Self::from_string(format!("{:?}", k))
|
|
}
|
|
}
|
|
|
|
impl From<anyhow::Error> for Error {
|
|
fn from(k: anyhow::Error) -> Self {
|
|
Self::from_string(format!("{k}"))
|
|
}
|
|
}
|
|
|
|
impl From<http::Error> for Error {
|
|
fn from(k: http::Error) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
impl From<http::uri::InvalidUri> for Error {
|
|
fn from(k: http::uri::InvalidUri) -> Self {
|
|
Self::from_string(k)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct PublicError {
|
|
reason: Option<Reason>,
|
|
msg: Vec<String>,
|
|
}
|
|
|
|
impl PublicError {
|
|
pub fn reason(&self) -> Option<Reason> {
|
|
self.reason.clone()
|
|
}
|
|
|
|
pub fn msg(&self) -> &Vec<String> {
|
|
&self.msg
|
|
}
|
|
}
|
|
|
|
impl From<String> for PublicError {
|
|
fn from(value: String) -> Self {
|
|
Self {
|
|
reason: None,
|
|
msg: vec![value],
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Error> for PublicError {
|
|
fn from(k: Error) -> Self {
|
|
Self {
|
|
reason: k.reason(),
|
|
msg: k.public_msg().map(Clone::clone).unwrap_or(Vec::new()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<&Error> for PublicError {
|
|
fn from(k: &Error) -> Self {
|
|
Self {
|
|
reason: k.reason(),
|
|
msg: vec![k.msg().into()],
|
|
}
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for PublicError {
|
|
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(fmt, "{:?}", self.msg)
|
|
}
|
|
}
|
|
|
|
impl ToPublicError for Error {
|
|
fn to_public_error(&self) -> PublicError {
|
|
PublicError::from(self)
|
|
}
|
|
}
|
|
|
|
pub fn todo() {
|
|
let bt = backtrace::Backtrace::new();
|
|
eprintln!("TODO\n{bt:?}");
|
|
todo!("TODO\n{bt:?}");
|
|
}
|
|
|
|
pub fn todoval<T>() -> T {
|
|
let bt = backtrace::Backtrace::new();
|
|
eprintln!("TODO\n{bt:?}");
|
|
todo!("TODO todoval\n{bt:?}")
|
|
}
|
|
|
|
pub trait ToPublicError: std::error::Error + Send {
|
|
fn to_public_error(&self) -> PublicError;
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
|
|
#[derive(Debug, ThisError, Serialize, Deserialize)]
|
|
#[cstm(name = "SomeErrorEnumA")]
|
|
enum SomeErrorEnumA {
|
|
BadCase,
|
|
WithStringContent(String),
|
|
// #[error("bad: {0}")]
|
|
WithStringContentFmt(String),
|
|
}
|
|
|
|
#[derive(Debug, ThisError, Serialize, Deserialize)]
|
|
#[cstm(name = "SomeErrorEnumB0")]
|
|
enum SomeErrorEnumB0 {
|
|
FromA(#[from] SomeErrorEnumA),
|
|
}
|
|
|
|
#[derive(Debug, ThisError, Serialize, Deserialize)]
|
|
#[cstm(name = "SomeErrorEnumB1")]
|
|
enum SomeErrorEnumB1 {
|
|
FromA(#[from] SomeErrorEnumA),
|
|
#[error("caffe")]
|
|
Caffe(SomeErrorEnumA),
|
|
}
|
|
|
|
fn failing_a_00() -> Result<(), SomeErrorEnumA> {
|
|
Err(SomeErrorEnumA::BadCase)
|
|
}
|
|
|
|
fn failing_b0_00() -> Result<(), SomeErrorEnumB0> {
|
|
let ret = failing_a_00()?;
|
|
Ok(ret)
|
|
}
|
|
|
|
fn failing_b1_00() -> Result<(), SomeErrorEnumB1> {
|
|
let ret = failing_a_00()?;
|
|
Ok(ret)
|
|
}
|
|
|
|
#[test]
|
|
fn error_handle_a_00() {
|
|
assert_eq!(format!("{}", SomeErrorEnumA::BadCase), "SomeErrorEnumA::BadCase");
|
|
}
|
|
|
|
#[test]
|
|
fn error_handle_a_01() {
|
|
assert_eq!(
|
|
SomeErrorEnumA::WithStringContent(format!("inner")).to_string(),
|
|
"SomeErrorEnumA::WithStringContent"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_handle_a_02() {
|
|
assert_eq!(
|
|
SomeErrorEnumA::WithStringContentFmt(format!("inner failure \"quoted\"")).to_string(),
|
|
"bad: inner failure \"quoted\""
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn error_handle_b0_00() {
|
|
let e = failing_b0_00().unwrap_err();
|
|
let s = e.to_string();
|
|
assert_eq!(s, "SomeErrorEnumB0::FromA(SomeErrorEnumA::BadCase)");
|
|
}
|
|
|
|
#[test]
|
|
fn error_handle_b0_user_00() {
|
|
use thiserror::UserErrorClass;
|
|
use thiserror::UserErrorInfo;
|
|
let e = failing_b0_00().unwrap_err();
|
|
let s = e.class();
|
|
if let UserErrorClass::Unspecified = s {
|
|
()
|
|
} else {
|
|
panic!()
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn error_handle_b1_00() {
|
|
let e = failing_b1_00().unwrap_err();
|
|
let s = e.to_string();
|
|
assert_eq!(s, "SomeErrorEnumB1::FromA(SomeErrorEnumA::BadCase)");
|
|
}
|
|
}
|