Enum ServerError

pub enum ServerError {
    Io(Error),
    InvalidRequest(String),
    NotFound(String),
    Forbidden(String),
    Custom(String),
}

Represents the different types of errors that can occur in the server.

This enum defines various errors that can be encountered during the server’s operation, such as I/O errors, invalid requests, file not found, and forbidden access.

Examples

Creating an I/O error:

use std::io::{Error, ErrorKind};
use http_handle::ServerError;

let io_error = Error::new(ErrorKind::NotFound, "file not found");
let server_error = ServerError::from(io_error);
assert!(matches!(server_error, ServerError::Io(_)));

Creating an invalid request error:

use http_handle::ServerError;

let invalid_request = ServerError::InvalidRequest("Missing HTTP method".to_string());
assert!(matches!(invalid_request, ServerError::InvalidRequest(_)));

Variants

Io(Error)

An I/O error occurred.

InvalidRequest(String)

The request received by the server was invalid or malformed.

NotFound(String)

The requested file was not found on the server.

Forbidden(String)

Access to the requested resource is forbidden.

Custom(String)

A custom error type for unexpected scenarios.

Implementations

impl ServerError

pub fn invalid_request<T: Into<String>>(message: T) -> Self

Creates a new InvalidRequest error with the given message.

Arguments

• message - A string slice that holds the error message.

Returns

A ServerError::InvalidRequest variant.

Examples

use http_handle::ServerError;

let error = ServerError::invalid_request("Missing HTTP version");
assert!(matches!(error, ServerError::InvalidRequest(_)));

pub fn not_found<T: Into<String>>(path: T) -> Self

Creates a new NotFound error with the given path.

Arguments

• path - A string slice that holds the path of the not found resource.

Returns

A ServerError::NotFound variant.

Examples

use http_handle::ServerError;

let error = ServerError::not_found("/nonexistent.html");
assert!(matches!(error, ServerError::NotFound(_)));

pub fn forbidden<T: Into<String>>(message: T) -> Self

Creates a new Forbidden error with the given message.

Arguments

• message - A string slice that holds the error message.

Returns

A ServerError::Forbidden variant.

Examples

use http_handle::ServerError;

let error = ServerError::forbidden("Access denied to sensitive file");
assert!(matches!(error, ServerError::Forbidden(_)));

Trait Implementations

impl Debug for ServerError

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

Formats the value using the given formatter.

impl Display for ServerError

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

Formats the value using the given formatter.

impl Error for ServerError

fn source(&self) -> Option<&(dyn Error + '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<&str> for ServerError

fn from(error: &str) -> Self

Converts a string slice into a ServerError::Custom variant.

This implementation allows for easy creation of custom errors from string literals.

Arguments

• error - A string slice that holds the error message.

Returns

A ServerError::Custom variant.

Examples

use http_handle::ServerError;

let error: ServerError = "Unexpected error".into();
assert!(matches!(error, ServerError::Custom(_)));

impl From<Error> for ServerError

fn from(source: Error) -> Self

Converts to this type from the input type.