98 lines
2.6 KiB
Rust
98 lines
2.6 KiB
Rust
// Copyright 2015-2020 Benjamin Fry <benjaminfry@me.com>
|
|
//
|
|
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
|
|
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
|
|
// http://opensource.org/licenses/MIT>, at your option. This file may not be
|
|
// copied, modified, or distributed except according to those terms.
|
|
|
|
use std::fmt;
|
|
|
|
use proto::error::*;
|
|
use thiserror::Error;
|
|
|
|
use crate::proto::{trace, ExtBacktrace};
|
|
|
|
/// An alias for results returned by functions of this crate
|
|
pub type Result<T> = ::std::result::Result<T, Error>;
|
|
|
|
/// The error kind for errors that get returned in the crate
|
|
#[derive(Debug, Error)]
|
|
pub enum ErrorKind {
|
|
/// An error that occurred when recovering from journal
|
|
#[error("error recovering from journal: {}", _0)]
|
|
Recovery(&'static str),
|
|
|
|
/// The number of inserted records didn't match the expected amount
|
|
#[error("wrong insert count: {} expect: {}", got, expect)]
|
|
WrongInsertCount {
|
|
/// The number of inserted records
|
|
got: usize,
|
|
/// The number of records expected to be inserted
|
|
expect: usize,
|
|
},
|
|
|
|
// foreign
|
|
/// An error got returned by the trust-dns-proto crate
|
|
#[error("proto error: {0}")]
|
|
Proto(#[from] ProtoError),
|
|
|
|
/// An error got returned from the rusqlite crate
|
|
#[cfg(feature = "sqlite")]
|
|
#[error("sqlite error: {0}")]
|
|
Sqlite(#[from] rusqlite::Error),
|
|
|
|
/// A request timed out
|
|
#[error("request timed out")]
|
|
Timeout,
|
|
}
|
|
|
|
/// The error type for errors that get returned in the crate
|
|
#[derive(Debug, Error)]
|
|
pub struct Error {
|
|
kind: ErrorKind,
|
|
backtrack: Option<ExtBacktrace>,
|
|
}
|
|
|
|
impl Error {
|
|
/// Get the kind of the error
|
|
pub fn kind(&self) -> &ErrorKind {
|
|
&self.kind
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Error {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
if let Some(ref backtrace) = self.backtrack {
|
|
fmt::Display::fmt(&self.kind, f)?;
|
|
fmt::Debug::fmt(backtrace, f)
|
|
} else {
|
|
fmt::Display::fmt(&self.kind, f)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<ErrorKind> for Error {
|
|
fn from(kind: ErrorKind) -> Error {
|
|
Error {
|
|
kind,
|
|
backtrack: trace!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<ProtoError> for Error {
|
|
fn from(e: ProtoError) -> Error {
|
|
match *e.kind() {
|
|
ProtoErrorKind::Timeout => ErrorKind::Timeout.into(),
|
|
_ => ErrorKind::from(e).into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "sqlite")]
|
|
impl From<rusqlite::Error> for Error {
|
|
fn from(e: rusqlite::Error) -> Error {
|
|
ErrorKind::from(e).into()
|
|
}
|
|
}
|