Struct pingora_core::Error

source ·

pub struct Error {
    pub etype: ErrorType,
    pub esource: ErrorSource,
    pub retry: RetryType,
    pub cause: Option<Box<dyn Error + Sync + Send>>,
    pub context: Option<ImmutStr>,
}

Expand description

The struct that represents an error

Fields§

§etype: ErrorType

the type of error

§esource: ErrorSource

the source of error: from upstream, downstream or internal

§retry: RetryType

if the error is retry-able

§cause: Option<Box<dyn Error + Sync + Send>>

chain to the cause of this error

§context: Option<ImmutStr>

an arbitrary string that explains the context when the error happens

Implementations§

source §

impl Error

source

pub fn create( etype: ErrorType, esource: ErrorSource, context: Option<ImmutStr>, cause: Option<Box<dyn Error + Sync + Send>> ) -> Box<Error>

Simply create the error. See other functions that provide less verbose interfaces.

source

pub fn new(e: ErrorType) -> Box<Error>

Create an error with the given type

source

pub fn because<S, E>(e: ErrorType, context: S, cause: E) -> Box<Error>
where S: Into<ImmutStr>, E: Into<Box<dyn Error + Sync + Send>>,

Create an error with the given type, a context string and the causing error. This method is usually used when there the error is caused by another error.

use pingora_error::{Error, ErrorType, Result};

fn b() -> Result<()> {
    // ...
    Ok(())
}
fn do_something() -> Result<()> {
    // a()?;
    b().map_err(|e| Error::because(ErrorType::InternalError, "b failed after a", e))
}

Choose carefully between simply surfacing the causing error versus Because() here. Only use Because() when there is extra context that is not capture by the causing error itself.

source

pub fn e_because<T, S, E>( e: ErrorType, context: S, cause: E ) -> Result<T, Box<Error>>
where S: Into<ImmutStr>, E: Into<Box<dyn Error + Sync + Send>>,

Short for Err(Self::because)

source

pub fn explain<S>(e: ErrorType, context: S) -> Box<Error>
where S: Into<ImmutStr>,

Create an error with context but no direct causing error

source

pub fn e_explain<T, S>(e: ErrorType, context: S) -> Result<T, Box<Error>>
where S: Into<ImmutStr>,

Short for Err(Self::explain)

source

pub fn new_up(e: ErrorType) -> Box<Error>

The new_{up, down, in} functions are to create new errors with source {upstream, downstream, internal}

source

pub fn new_down(e: ErrorType) -> Box<Error>

source

pub fn new_in(e: ErrorType) -> Box<Error>

source

pub fn new_str(s: &'static str) -> Box<Error>

Create a new custom error with the static string

source

pub fn as_up(&mut self)

The as_{up, down, in} functions are to change the current errors with source {upstream, downstream, internal}

source

pub fn as_down(&mut self)

source

pub fn as_in(&mut self)

source

pub fn into_up(self: Box<Error>) -> Box<Error>

The into_{up, down, in} are the same as as_* but takes self and also return self

source

pub fn into_down(self: Box<Error>) -> Box<Error>

source

pub fn into_in(self: Box<Error>) -> Box<Error>

source

pub fn into_err<T>(self: Box<Error>) -> Result<T, Box<Error>>

source

pub fn set_cause<C>(&mut self, cause: C)
where C: Into<Box<dyn Error + Sync + Send>>,

source

pub fn set_context<T>(&mut self, context: T)
where T: Into<ImmutStr>,

source

pub fn more_context<T>(self: Box<Error>, context: T) -> Box<Error>
where T: Into<ImmutStr>,

Create a new error from self, with the same type and source and put self as the cause

use pingora_error::Result;

 fn b() -> Result<()> {
    // ...
    Ok(())
}

fn do_something() -> Result<()> {
    // a()?;
    b().map_err(|e| e.more_context("b failed after a"))
}

This function is less verbose than Because. But it only work for Error while Because works for all types of errors who implement std::error::Error trait.

source