Struct CacheLayer 

pub struct CacheLayer<B> { /* private fields */ }

Configurable caching layer for Tower services.

The layer wraps an inner service and caches HTTP responses based on the configured CachePolicy. Create instances via CacheLayer::builder or CacheLayer::new for a sensible default policy.

Cloning a CacheLayer is cheap and shares the underlying backend and in-flight stampede locks.

Implementations

impl CacheLayer<InMemoryBackend>

pub fn new_in_memory(max_capacity: u64) -> Self

Creates a cache layer backed by an in-memory InMemoryBackend.

impl<B> CacheLayer<B>

where B: CacheBackend,

pub fn new(backend: B) -> Self

Builds a cache layer with the default CachePolicy.

pub fn builder(backend: B) -> CacheLayerBuilder<B>

Returns a builder for fine-grained control over the cache policy.

pub fn with_policy(self, policy: CachePolicy) -> Self

pub fn with_ttl(self, ttl: Duration) -> Self

pub fn with_negative_ttl(self, ttl: Duration) -> Self

pub fn with_stale_while_revalidate(self, duration: Duration) -> Self

pub fn with_refresh_before(self, duration: Duration) -> Self

pub fn with_max_body_size(self, size: Option<usize>) -> Self

pub fn with_min_body_size(self, size: Option<usize>) -> Self

pub fn with_allow_streaming_bodies(self, allow: bool) -> Self

pub fn with_compression(self, config: CompressionConfig) -> Self

pub fn with_respect_cache_control(self, enabled: bool) -> Self

pub fn with_cache_statuses( self, statuses: impl IntoIterator<Item = u16>, ) -> Self

pub fn with_method_predicate<F>(self, predicate: F) -> Self

where F: Fn(&Method) -> bool + Send + Sync + 'static,

pub fn with_header_allowlist<I, S>(self, headers: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

pub fn with_key_extractor(self, extractor: KeyExtractor) -> Self

pub async fn init_auto_refresh<S, ResBody>( &self, service: S, ) -> Result<(), String>

where S: Service<Request<()>, Response = Response<ResBody>> + Clone + Send + Sync + 'static, S::Future: Send + 'static, S::Error: Into<BoxError> + Send, ResBody: Body<Data = Bytes> + Send + 'static, ResBody::Error: Into<BoxError> + Send, B: Clone,

Manually initialize the auto-refresh manager with a service instance.

This should be called after constructing the service to start the background refresh task. This is only necessary if auto-refresh is enabled.

Example

let layer = CacheLayer::builder(backend)
    .auto_refresh(config)
    .build();

layer.init_auto_refresh(my_service.clone()).await?;

Trait Implementations

impl<B: Clone> Clone for CacheLayer<B>

fn clone(&self) -> CacheLayer<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B> Drop for CacheLayer<B>

fn drop(&mut self)

Executes the destructor for this type.

impl<S, B> Layer<S> for CacheLayer<B>

where B: CacheBackend,

type Service = CacheService<S, B>

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.