Struct CacheMiddleware 

pub struct CacheMiddleware { /* private fields */ }

Cache Middleware

Examples

use std::sync::Arc;
use std::time::Duration;
use reinhardt_middleware::cache::{CacheMiddleware, CacheConfig, CacheKeyStrategy};
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("OK")))
    }
}

let config = CacheConfig::new(Duration::from_secs(60), CacheKeyStrategy::UrlOnly);
let middleware = CacheMiddleware::new(config);
let handler = Arc::new(TestHandler);

let request = Request::builder()
    .method(Method::GET)
    .uri("/api/data")
    .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);

Implementations

impl CacheMiddleware

pub fn new(config: CacheConfig) -> Self

Create a new cache middleware

Examples

use std::time::Duration;
use reinhardt_middleware::cache::{CacheMiddleware, CacheConfig, CacheKeyStrategy};

let config = CacheConfig::new(Duration::from_secs(300), CacheKeyStrategy::UrlOnly);
let middleware = CacheMiddleware::new(config);

pub fn with_defaults() -> Self

Create with default configuration

pub fn from_arc(config: CacheConfig, store: Arc<CacheStore>) -> Self

Create from an existing Arc-wrapped cache store

This is provided for cases where you already have an Arc<CacheStore>. In most cases, you should use new() instead, which creates the store internally.

pub fn store(&self) -> &CacheStore

Get a reference to the cache store

Examples

use std::time::Duration;
use reinhardt_middleware::cache::{CacheMiddleware, CacheConfig, CacheKeyStrategy};

let middleware = CacheMiddleware::new(
    CacheConfig::new(Duration::from_secs(300), CacheKeyStrategy::UrlOnly)
);

// Access the store
let store = middleware.store();
assert_eq!(store.len(), 0);

pub fn store_arc(&self) -> Arc<CacheStore>

Get a cloned Arc of the store (for cases where you need ownership)

In most cases, you should use store() instead to get a reference.

Trait Implementations

impl Default for CacheMiddleware

fn default() -> Self

Returns the “default value” for a type.

impl Middleware for CacheMiddleware

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.