Struct CacheMiddleware 

pub struct CacheMiddleware { /* private fields */ }

Available on crate feature middleware and non-WebAssembly only.

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) -> CacheMiddleware

Available on crate features standard or middleware only.

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() -> CacheMiddleware

Available on crate features standard or middleware only.

Create with default configuration

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

Available on crate features standard or middleware only.

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

Available on crate features standard or middleware only.

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>

Available on crate features standard or middleware only.

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() -> CacheMiddleware

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, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, CacheMiddleware: '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.