Struct HttpsRedirectMiddleware 

pub struct HttpsRedirectMiddleware { /* private fields */ }

Middleware to redirect HTTP requests to HTTPS

Implementations

impl HttpsRedirectMiddleware

pub fn new(config: HttpsRedirectConfig) -> Self

Create a new HttpsRedirectMiddleware with the given configuration

Arguments

• config - HTTPS redirect configuration

Examples

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

struct TestHandler;

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

let mut config = HttpsRedirectConfig::default();
config.enabled = true;
config.exempt_paths = vec!["/health".to_string()];
config.status_code = StatusCode::MOVED_PERMANENTLY;
config.allowed_hosts = vec!["example.com".to_string()];

let middleware = HttpsRedirectMiddleware::new(config);
let handler = Arc::new(TestHandler);

let mut headers = HeaderMap::new();
headers.insert(hyper::header::HOST, "example.com".parse().unwrap());

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

let response = middleware.process(request, handler).await.unwrap();
assert_eq!(response.status, StatusCode::MOVED_PERMANENTLY);
assert_eq!(response.headers.get("Location").unwrap(), "https://example.com/api/data");

pub fn default_config() -> Self

Create with default configuration

Default configuration enables HTTPS redirect with 301 status code and no exempt paths.

Examples

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

struct TestHandler;

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

let mut config = HttpsRedirectConfig::default();
config.allowed_hosts = vec!["api.example.com".to_string()];
let middleware = HttpsRedirectMiddleware::new(config);
let handler = Arc::new(TestHandler);

let mut headers = HeaderMap::new();
headers.insert(hyper::header::HOST, "api.example.com".parse().unwrap());

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

let response = middleware.process(request, handler).await.unwrap();
assert_eq!(response.status, StatusCode::MOVED_PERMANENTLY);
assert_eq!(response.headers.get("Location").unwrap(), "https://api.example.com/users?page=1");

Trait Implementations

impl Middleware for HttpsRedirectMiddleware

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.

fn di_registrations(&self) -> Vec<(TypeId, Arc<dyn Any + Send + Sync>)>

Returns DI singleton registrations contributed by this middleware.