Struct ProxyCachePlugin 

pub struct ProxyCachePlugin {
    role: Role,
    id: String,
    cache_key: Vec<String>,
    cache_ttl: Duration,
    cache_statuses: Vec<u16>,
    cache_methods: Vec<String>,
    hide_cache_headers: bool,
    resources: Arc<PluginResources>,
}

One node of a proxy-cache lookup/store pair.

Holds a handle to the process-wide crate::traffic::CacheRegistry; the key is derived per request from cache_key, namespaced by id.

Fields

role: Role

id: String

Shared cache namespace — links the lookup and store nodes.

cache_key: Vec<String>

Cache-key components, each interpolated and joined per request.

cache_ttl: Duration

Freshness lifetime for stored entries.

cache_statuses: Vec<u16>

Response statuses eligible for caching.

cache_methods: Vec<String>

HTTP methods eligible for caching (uppercase).

hide_cache_headers: bool

When set, hides upstream cache headers from served cache hits.

resources: Arc<PluginResources>

Implementations

impl ProxyCachePlugin

pub fn from_config( config: &HashMap<String, Value>, resources: &Arc<PluginResources>, ) -> Result<Self, String>

Builds one node of the pair from node config.

Accepted keys:

• phase / role (string, required): lookup (before upstream) or store (after upstream).
• id (string, required): shared cache namespace; the lookup and store nodes of one pair must use the same id.
• cache_key (array of string templates or a single string, default ["$request_method", "$host", "$uri"]): components interpolated (see crate::vars::interpolate) and joined to form the key. Both nodes must configure it identically.
• cache_ttl (integer seconds, default 300): freshness lifetime.
• cache_http_statuses (array, default [200, 301, 404]): statuses eligible for caching. (cache_http_status, APISIX’s singular spelling, is also accepted.)
• cache_method (array, default ["GET", "HEAD"]): cacheable methods.
• hide_cache_headers (bool, default false): strip cache-control / expires from served cache hits.

# before upstream
type: proxy-cache
config:
  phase: lookup
  id: catalog
  cache_key: ["$request_method", "$host", "$uri"]
  cache_ttl: 300
---
# after upstream
type: proxy-cache
config:
  phase: store
  id: catalog
  cache_key: ["$request_method", "$host", "$uri"]
  cache_ttl: 300
  cache_http_statuses: [200, 301, 404]

fn method_cacheable(&self, ctx: &Context) -> bool

Whether this request’s method is cacheable.

fn derive_key(&self, ctx: &Context) -> String

Derives the cache key: id namespace + interpolated cache_key components joined by a control-char separator (outside the character set of any header/method/path, so components can’t collide).

Trait Implementations

impl Plugin for ProxyCachePlugin

fn plugin_type(&self) -> &str

Unique identifier for the plugin type (e.g., “proxy-rewrite”, “upstream”).

fn execute<'life0, 'life1, 'async_trait>( &'life0 self, ctx: Context, _named_inputs: &'life1 HashMap<String, Value>, ) -> Pin<Box<dyn Future<Output = Result<PluginOutput, PluginExecutionError>> + Send + 'async_trait>>

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

Executes the plugin logic against the request/response context.