Struct SharedCacheLayer 

pub struct SharedCacheLayer<Req, K, Resp> { /* private fields */ }

A Tower Layer that applies response caching with a shared store.

Unlike CacheLayer, this layer shares a single cache store across all services created via layer(). This is useful when multiple service instances (e.g., per-session or per-request services) need to share the same cache.

Type Parameters

• Req: The request type
• K: The cache key type (extracted from requests)
• Resp: The response type that will be cached

Examples

use tower_resilience_cache::SharedCacheLayer;
use tower::ServiceBuilder;
use std::time::Duration;

// Create a shared cache layer
let cache_layer: SharedCacheLayer<String, String, String> = SharedCacheLayer::builder()
    .max_size(100)
    .ttl(Duration::from_secs(60))
    .key_extractor(|req: &String| req.clone())
    .build();

// Both services share the same cache
let service1 = ServiceBuilder::new()
    .layer(cache_layer.clone())
    .service(my_service());

let service2 = ServiceBuilder::new()
    .layer(cache_layer)
    .service(my_service());

Creating from CacheLayer

You can also convert an existing CacheLayer configuration:

use tower_resilience_cache::CacheLayer;
use std::time::Duration;

let shared_cache = CacheLayer::builder()
    .max_size(100)
    .ttl(Duration::from_secs(60))
    .key_extractor(|req: &String| req.clone())
    .build()
    .shared::<String>();  // Specify the response type

Implementations

impl<Req, K, Resp> SharedCacheLayer<Req, K, Resp>

where K: Hash + Eq + Clone + Send + 'static, Resp: Clone + Send + 'static,

pub fn new(config: CacheConfig<Req, K>) -> Self

Creates a new SharedCacheLayer with the given configuration.

pub fn builder() -> SharedCacheConfigBuilder<Req, K, Resp>

Creates a new builder for configuring a shared cache layer.

Examples

use tower_resilience_cache::SharedCacheLayer;
use std::time::Duration;

let layer: SharedCacheLayer<String, String, String> = SharedCacheLayer::builder()
    .max_size(100)
    .ttl(Duration::from_secs(60))
    .key_extractor(|req: &String| req.clone())
    .build();

Trait Implementations

impl<Req: Clone, K: Clone, Resp: Clone> Clone for SharedCacheLayer<Req, K, Resp>

fn clone(&self) -> SharedCacheLayer<Req, K, Resp>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, Req, K, Resp> Layer<S> for SharedCacheLayer<Req, K, Resp>

where K: Hash + Eq + Clone + Send + 'static, S: Service<Req, Response = Resp>, Resp: Clone + Send + 'static,

type Service = Cache<S, Req, K, Resp>

The wrapped service

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

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