Struct LocalResponseCache 

pub struct LocalResponseCache {
    entries: DashMap<String, (CachedResponse, Instant)>,
    capacity: AtomicUsize,
    metrics: Option<Arc<GatewayMetrics>>,
}

Process-local cache. Shared by every policy: local node in the gateway.

Fields

entries: DashMap<String, (CachedResponse, Instant)>

capacity: AtomicUsize

Read on every insert; set once at startup from cache.max_entries.

metrics: Option<Arc<GatewayMetrics>>

Set once at construction (PluginResources::new); None disables recording (unit tests). Used only to count evictions — hits, misses and errors are metered by the proxy-cache plugin, which knows the store label this backend does not have.

Implementations

impl LocalResponseCache

pub fn new(metrics: Option<Arc<GatewayMetrics>>) -> Self

Creates the process-local cache, optionally wired to the metrics registry so make_room can count evictions.

pub fn set_capacity(&self, max_entries: usize)

Sets the entry bound. Called once at startup, before traffic.

fn make_room(&self, capacity: usize)

Makes room for one more entry.

Expired entries go first, since they are already worthless. If that is not enough, the entries expiring soonest go next — deliberately not an LRU (no LRU crate is in the dependency tree, and adding one for this is not worth the supply-chain surface). For a cache whose entries all carry TTLs this discards what was about to become useless anyway; the cost is that a hot short-TTL entry loses to a cold long-TTL one.

The live-entry eviction reclaims down to a low-water mark (capacity - capacity / RECLAIM_FRACTION) in one sorted pass, rather than removing exactly one entry via a fresh per-entry min_by_key scan. Once the cache is saturated, a per-entry scan would make every put pay an O(n) cost for the life of the process; amortising the sort over a batch of evictions means most inserts, most of the time, find room already waiting and skip straight to the insert.

Trait Implementations

impl Default for LocalResponseCache

fn default() -> Self

Returns the “default value” for a type.

impl ResponseCache for LocalResponseCache

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<CachedResponse>, CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn put<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, entry: &'life2 CachedResponse, ttl: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn purge<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<u64, CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Removes every entry belonging to the pair id and returns how many.