Struct RedirectFallbackMiddleware 

pub struct RedirectFallbackMiddleware { /* private fields */ }

Middleware that redirects 404 errors to a fallback URL

Examples

use std::sync::Arc;
use reinhardt_middleware::{RedirectFallbackMiddleware, RedirectResponseConfig};
use reinhardt_http::{Handler, Middleware, Request, Response};
use hyper::{StatusCode, Method, Version, HeaderMap};
use bytes::Bytes;

struct NotFoundHandler;

#[async_trait::async_trait]
impl Handler for NotFoundHandler {
    async fn handle(&self, _request: Request) -> reinhardt_core::exception::Result<Response> {
        Ok(Response::new(StatusCode::NOT_FOUND))
    }
}

let config = RedirectResponseConfig::new("/404".to_string());
let middleware = RedirectFallbackMiddleware::new(config);
let handler = Arc::new(NotFoundHandler);

let request = Request::builder()
    .method(Method::GET)
    .uri("/missing")
    .version(Version::HTTP_11)
    .headers(HeaderMap::new())
    .body(Bytes::new())
    .build()
    .unwrap();

let response = middleware.process(request, handler).await.unwrap();
assert_eq!(response.status, StatusCode::FOUND);
assert_eq!(
    response.headers.get(hyper::header::LOCATION).unwrap(),
    "/404"
);

Implementations

impl RedirectFallbackMiddleware

pub fn new(config: RedirectResponseConfig) -> Self

Create a new RedirectFallbackMiddleware with the given configuration

Examples

use reinhardt_middleware::{RedirectFallbackMiddleware, RedirectResponseConfig};

let config = RedirectResponseConfig::new("/404".to_string());
let middleware = RedirectFallbackMiddleware::new(config);

Trait Implementations

impl Middleware for RedirectFallbackMiddleware

fn process<'life0, 'async_trait>( &'life0 self, request: Request, handler: Arc<dyn Handler>, ) -> Pin<Box<dyn Future<Output = Result<Response>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Processes a request through this middleware.

fn should_continue(&self, _request: &Request) -> bool

Determines whether this middleware should be executed for the given request.