Struct CacheLayer 

pub struct CacheLayer { /* private fields */ }

An in-memory response cache middleware.

Construct with CacheLayer::memory and configure with the builder methods ttl and vary_by_header.

CacheLayer is cheaply Clone-able — clones share the same underlying store, which lets you keep a handle for cache stats and invalidation while the other clone is used as middleware.

Implementations

impl CacheLayer

pub fn memory(capacity: usize) -> Self

Create a new in-memory cache bounded to capacity entries.

Default TTL is 60 seconds. Adjust with .ttl().

pub fn purge_token(self, token: impl Into<String>) -> Self

Accept the HTTP PURGE method on the routes behind this layer, authenticated by Authorization: Bearer <token> (since 18.11.0). PURGE /products/42 removes that target (every Vary variant); PURGE /products/* removes the prefix. The answer is {"purged":<n>}; a missing or wrong token gets 401. Without a token, PURGE passes through to the application as before.

pub fn purge(&self, target: &Purge) -> usize

Remove the entries target names; how many.

pub fn kind(&self) -> &'static str

"memory" or "disk".

pub fn disk(dir: impl Into<PathBuf>, max_bytes: u64) -> Result<Self>

A cache kept in files under dir (created if missing), bounded to max_bytes in total, oldest dropped first (since 18.11.0). Entries survive a restart: the directory is indexed when the layer is built, expired and unreadable files removed. Same rules as memory for what is cached and for how long.

use rust_web_server::cache::CacheLayer;

let layer = CacheLayer::disk("/var/cache/rws/api", 512 * 1024 * 1024)?.ttl(600);

pub fn hits(&self) -> u64

Number of cache hits since the cache was created.

pub fn misses(&self) -> u64

Number of cache misses since the cache was created.

pub fn size(&self) -> usize

Current number of entries in the store (including potentially expired ones that haven’t been purged yet).

pub fn stored_bytes(&self) -> Option<u64>

Bytes held by a disk cache’s files; None for a memory cache.

pub fn clear(&self)

Remove all entries from the cache.

pub fn ttl(self, secs: u64) -> Self

Set the time-to-live for cached entries.

pub fn vary_by_header(self, name: &str) -> Self

Include a request header in the cache key so that different values of that header produce separate cache entries.

Header name matching is case-insensitive. Call multiple times to vary by more than one header.

use rust_web_server::cache::CacheLayer;

let layer = CacheLayer::memory(500)
    .vary_by_header("Accept")
    .vary_by_header("Accept-Language");

Trait Implementations

impl Clone for CacheLayer

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Middleware for CacheLayer

fn accepts_streamed_body( &self, _request: &Request, _connection: &ConnectionInfo, ) -> bool

Headers only: a streamed body passes through untouched.

fn runs_inline(&self, _request: &Request, _connection: &ConnectionInfo) -> bool

In-memory: safe on the event loop. A disk store reads and writes files, so it runs on the blocking pool.

fn handle( &self, request: &Request, connection: &ConnectionInfo, next: &dyn Application, ) -> Result<Response, String>

fn is_passthrough( &self, _request: &Request, _connection: &ConnectionInfo, ) -> bool

true when handle would do nothing for request but call next (e.g. a rate limit that isn’t configured). A WithMiddleware stack offers the inner application’s execute_async only if every layer passes the request through. Default false.

fn answers_streamed_body( &self, _request: &Request, _connection: &ConnectionInfo, ) -> bool

true when this layer answers request itself — it doesn’t call next — and reads its body as a stream (a proxy forwarding it as it arrives). The body is then streamed whatever the layers after it and the application would say. Requires accepts_streamed_body. Since 18.3.0.