Struct HttpCacheLayer 

pub struct HttpCacheLayer<CM>
where
    CM: CacheManager,
{ /* private fields */ }

HTTP cache layer for Tower services.

This layer implements HTTP caching according to RFC 7234, automatically caching GET and HEAD responses based on their cache-control headers and invalidating cache entries when unsafe methods (PUT, POST, DELETE, PATCH) are used.

Example

use http_cache_tower::{HttpCacheLayer, CACacheManager};
use tower::ServiceBuilder;
use tower::service_fn;
use http::{Request, Response};
use http_body_util::Full;
use bytes::Bytes;
use std::convert::Infallible;

let cache_manager = CACacheManager::new("./cache".into(), true);
let cache_layer = HttpCacheLayer::new(cache_manager);

// Use with ServiceBuilder
let service = ServiceBuilder::new()
    .layer(cache_layer)
    .service_fn(|_req: Request<Full<Bytes>>| async {
        Ok::<_, Infallible>(Response::new(Full::new(Bytes::from("Hello"))))
    });

Implementations

impl<CM> HttpCacheLayer<CM>

where CM: CacheManager,

pub fn new(cache_manager: CM) -> Self

Create a new HTTP cache layer with default configuration.

Uses CacheMode::Default and default HttpCacheOptions.

Arguments

• cache_manager - The cache manager to use for storing responses

Example

use http_cache_tower::{HttpCacheLayer, CACacheManager};

let cache_manager = CACacheManager::new("./cache".into(), true);
let layer = HttpCacheLayer::new(cache_manager);

pub fn with_options(cache_manager: CM, options: HttpCacheOptions) -> Self

Create a new HTTP cache layer with custom options.

Uses CacheMode::Default but allows customizing the cache behavior through HttpCacheOptions.

Arguments

• cache_manager - The cache manager to use for storing responses
• options - Custom cache options

Example

use http_cache_tower::{HttpCacheLayer, CACacheManager};
use http_cache::HttpCacheOptions;

let cache_manager = CACacheManager::new("./cache".into(), true);

let options = HttpCacheOptions {
    cache_key: Some(std::sync::Arc::new(|req: &http::request::Parts| {
        format!("custom:{}:{}", req.method, req.uri)
    })),
    ..Default::default()
};

let layer = HttpCacheLayer::with_options(cache_manager, options);

pub fn with_cache(cache: HttpCache<CM>) -> Self

Create a new HTTP cache layer with a pre-configured cache.

This method gives you full control over the cache configuration, including the cache mode.

Arguments

• cache - A fully configured HttpCache instance

Example

use http_cache_tower::{HttpCacheLayer, CACacheManager};
use http_cache::{HttpCache, CacheMode, HttpCacheOptions};

let cache_manager = CACacheManager::new("./cache".into(), true);

let cache = HttpCache {
    mode: CacheMode::ForceCache,
    manager: cache_manager,
    options: HttpCacheOptions::default(),
};

let layer = HttpCacheLayer::with_cache(cache);

Trait Implementations

impl<CM> Clone for HttpCacheLayer<CM>

where CM: CacheManager + Clone,

fn clone(&self) -> HttpCacheLayer<CM>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, CM> Layer<S> for HttpCacheLayer<CM>

where CM: CacheManager,

type Service = HttpCacheService<S, CM>

The wrapped service

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.