Struct CacheLayer 

pub struct CacheLayer { /* private fields */ }

Tower Layer that produces CacheService instances sharing the same cache state and CacheHandle.

Because CacheService::new() returns a (CacheService, CacheHandle) tuple, a standard Layer cannot propagate the side-channel handle. CacheLayer solves this by creating the shared cache state up-front and handing out an Arc-cloned handle to the caller while cloning the same Arc into every service produced by Layer::layer.

Example

use mcp_proxy::cache::{CacheLayer, CacheHandle};
use mcp_proxy::config::{BackendCacheConfig, CacheBackendConfig};

let cfg = BackendCacheConfig {
    resource_ttl_seconds: 300,
    tool_ttl_seconds: 60,
    max_entries: 1000,
};
let backend_cfg = CacheBackendConfig::default();

let (layer, handle) = CacheLayer::new(
    vec![("api/".to_string(), &cfg)],
    &backend_cfg,
);

// `layer` implements `tower::Layer<S>` and can be used in a middleware stack.
// `handle` can be used to query stats or clear the cache.

Implementations

impl CacheLayer

pub fn new( configs: Vec<(String, &BackendCacheConfig)>, backend_config: &CacheBackendConfig, ) -> (Self, CacheHandle)

Create a new cache layer and return it with a shareable CacheHandle.

The handle provides CacheHandle::stats() and CacheHandle::clear() over the same underlying cache state used by every service the layer produces.

Trait Implementations

impl Clone for CacheLayer

fn clone(&self) -> CacheLayer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Layer<S> for CacheLayer

type Service = CacheService<S>

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.