Enum Error 

pub enum Error {
    Auth(AuthError),
    Store(StoreError),
    Password(PasswordError),
    Task(JoinError),
}

Available on crate feature server only.

The error of an Auth operation: either an AuthError to answer the request with, or an internal failure.

Classify one with auth_error. Once it has passed through ? into an app’s own error, such as an anyhow::Error, use find_auth_error on that error rather than downcasting it to AuthError, which misses a refusal wrapped as Error::Auth and so answers a Forbidden as an internal failure.

An internal failure’s message carries its cause, such as storage failed: database is locked, so logging it with {error} says what went wrong. Its source continues below that cause, so a chain printer such as anyhow’s {:#} does not repeat it. The message is for logs: answer the client with something generic, as the axum08 integration and the musliweb05 Connection do.

Variants

Auth(AuthError)

The request is refused, as the AuthError says.

Store(StoreError)

The store failed.

Password(PasswordError)

Hashing a password failed.

Task(JoinError)

A blocking task, such as hashing, panicked or was cancelled.

Implementations

impl Error

pub fn auth_error(&self) -> Option<&AuthError>

The AuthError to answer with, or None for an internal failure.

This is how to tell a refusal, which the client should see, from an internal failure, which it should not.

pub fn find_auth_error<'a>( error: &'a (dyn StdError + 'static), ) -> Option<&'a AuthError>

The AuthError somewhere in error’s chain of sources, whether bare or as an Error::Auth, or None when the chain holds no refusal.

For an app’s own error that a watchword Error reached through ?. With anyhow, pass &*error; an app error type that wraps Error has to name it as its source.

use watchword::AuthError;
use watchword::core::Error;

#[derive(Debug)]
struct AppError(Error);

impl std::fmt::Display for AppError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("the request failed")
    }
}

impl std::error::Error for AppError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(&self.0)
    }
}

let error = AppError(Error::from(AuthError::Forbidden));
assert_eq!(Error::find_auth_error(&error), Some(&AuthError::Forbidden));

let error = AppError(Error::from(watchword::store::StoreError::new("disk full")));
assert_eq!(Error::find_auth_error(&error), None);

Trait Implementations

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn StdError + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<AuthError> for Error

fn from(error: AuthError) -> Self

Converts to this type from the input type.

impl From<Error> for RequestError

Available on crate feature musliweb05 only.

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<JoinError> for Error

fn from(error: JoinError) -> Self

Converts to this type from the input type.

impl From<PasswordError> for Error

fn from(error: PasswordError) -> Self

Converts to this type from the input type.

impl From<StoreError> for Error

fn from(error: StoreError) -> Self

Converts to this type from the input type.

impl IntoResponse for Error

Available on crate feature axum08 only.

Answers an AuthError as that error does (watchword-core implements IntoResponse for it). Any other failure is logged and answered with a bare 500, so internals never reach the client.

fn into_response(self) -> Response

Create a response.