Struct ConditionalGetMiddleware 

pub struct ConditionalGetMiddleware { /* private fields */ }

Conditional GET middleware

Implements HTTP conditional requests using ETags and Last-Modified headers.

• Supports If-None-Match (ETag-based)
• Supports If-Modified-Since (Last-Modified-based)
• Supports If-Match and If-Unmodified-Since for safe methods

Implementations

impl ConditionalGetMiddleware

pub fn new() -> Self

Create a new ConditionalGetMiddleware

By default, automatic ETag generation is enabled for responses.

Examples

use std::sync::Arc;
use reinhardt_middleware::ConditionalGetMiddleware;
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).with_body(Bytes::from("content")))
    }
}

let middleware = ConditionalGetMiddleware::new();
let handler = Arc::new(TestHandler);

let request = Request::builder()
    .method(Method::GET)
    .uri("/api/resource")
    .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::OK);
assert!(response.headers.contains_key(hyper::header::ETAG));

pub fn without_etag() -> Self

Create middleware without automatic ETag generation

Use this when you want to handle ETags manually or rely only on Last-Modified headers.

Examples

use std::sync::Arc;
use reinhardt_middleware::ConditionalGetMiddleware;
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> {
        let mut response = Response::new(StatusCode::OK).with_body(Bytes::from("content"));
        response.headers.insert(
            hyper::header::LAST_MODIFIED,
            "Wed, 21 Oct 2015 07:28:00 GMT".parse().unwrap()
        );
        Ok(response)
    }
}

let middleware = ConditionalGetMiddleware::without_etag();
let handler = Arc::new(TestHandler);

let request = Request::builder()
    .method(Method::GET)
    .uri("/api/resource")
    .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::OK);
assert!(!response.headers.contains_key(hyper::header::ETAG));
assert!(response.headers.contains_key(hyper::header::LAST_MODIFIED));

Trait Implementations

impl Default for ConditionalGetMiddleware

fn default() -> Self

Returns the “default value” for a type.

impl Middleware for ConditionalGetMiddleware

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.