Struct RouteCache 

pub struct RouteCache {
    pub ttl_secs: u64,
    pub stale_while_revalidate_secs: Option<u64>,
    pub max_body_bytes: u64,
    pub vary: Vec<String>,
    pub coalescing: Option<RouteCacheCoalescing>,
}

Route-scoped response caching policy (DW-037). Absent (the default): the route’s responses are never cached, buffered, or stamped with cache headers — bytes flow exactly as before. Presence opts the route’s GET traffic into the local response cache behind the CacheStore extension seam (extensions domain).

Semantics (frozen; enforcement lives in dataplane::response_cache):

• Only PROXY-action routes cache. The key folds in the route name, the consumer, the inbound path + query, and the effective vary set’s request header values — two consumers (or two vary dimensions) never share an entry.
• Freshness is the configured ttl_secs, full stop: upstream freshness directives other than the storage vetoes (no-store/private/no-cache) are deliberately ignored — the OPERATOR, not the origin, owns how long the gateway holds an entry. Within stale_while_revalidate_secs after expiry the entry is served stale while a single background revalidation refreshes it; past that window the next request revalidates synchronously (conditional on the stored validator).
• ETag round-trips: a stored entry’s ETag backs client If-None-Match 304s from the cache and upstream revalidation (If-None-Match on the forwarded fetch; a 304 refreshes the entry without re-sending the body).

Fields

ttl_secs: u64

Freshness lifetime, in seconds. Required: a cache entry without a lifetime is an unbounded staleness bug, so there is no default. Validation rejects 0 and values above 24 hours.

stale_while_revalidate_secs: Option<u64>

How long past expiry the entry may be served stale while a background revalidation runs (DW-037 stale-while-revalidate). Absent/0: no stale serving — an expired entry revalidates synchronously. Validation bounds the value to 24 hours.

max_body_bytes: u64

Per-entry body cap in bytes: responses at or under the cap are buffered and stored; larger responses pass through unstored and unbuffered (the zero-buffering principle — the cap is the buffering opt-in’s hard edge). Absent: 1 MiB. Validation bounds the range [1, 16 MiB].

vary: Vec<String>

Extra request header names folded into the cache key (the configured half of the variance model — see the module docs). The policy-derived halves (Accept for match.accept routes, Origin for CORS routes) are added at snapshot compile and need not (but may) be listed. Validation rejects duplicates, hop-by-hop/framing names, Authorization/Cookie (requests carrying them are never cacheable, so varying on them is dead configuration), and X-Consumer-* (consumer identity is already a key component).

coalescing: Option<RouteCacheCoalescing>

Request coalescing (DW-038): collapse concurrent identical cacheable GETs on this route into ONE upstream call — the first miss (the leader) fetches while the rest (followers) wait, bounded, and replay the leader’s stored outcome. Absent (the default): every miss fetches independently, exactly as before. Presence enables; see RouteCacheCoalescing.

Trait Implementations

impl Clone for RouteCache

fn clone(&self) -> RouteCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RouteCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RouteCache

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for RouteCache

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for RouteCache

fn eq(&self, other: &RouteCache) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RouteCache

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RouteCache