Struct CacheService 

pub struct CacheService<S, B, C, CM, O = DisabledOffload> { /* private fields */ }

Tower Service that wraps an upstream service with caching.

CacheService intercepts HTTP requests, checks the cache, and either returns cached responses or forwards requests to the upstream service. It adds a cache status header (HIT/MISS/STALE) to every response.

When You’ll Encounter This

You typically don’t create this directly. It’s produced when you apply a Cache layer to a service via tower::ServiceBuilder.

Type Parameters

• S - The upstream Tower service being wrapped
• B - Cache backend (e.g., MokaBackend)
• C - Configuration with predicates, extractors, and policy
• CM - Concurrency manager for dogpile prevention
• O - Offload strategy for background revalidation

Implementations

impl<S, B, C, CM, O> CacheService<S, B, C, CM, O>

pub fn new( upstream: S, backend: Arc<B>, configuration: C, offload: O, concurrency_manager: CM, cache_status_header: HeaderName, ) -> Self

Creates a new cache service wrapping the given upstream.

Prefer using Cache::builder() and tower::ServiceBuilder instead of constructing this directly.

Trait Implementations

impl<S, B, C, CM, O> Clone for CacheService<S, B, C, CM, O>

where S: Clone, B: Clone, C: Clone, CM: Clone, O: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, B, C, CM, O, ReqBody, ResBody> Service<Request<ReqBody>> for CacheService<S, B, C, CM, O>

where S: Service<Request<BufferedBody<ReqBody>>, Response = Response<ResBody>> + Clone + Send + 'static, B: CacheBackend + Clone + Send + Sync + 'static, S::Future: Send, C: CacheConfig<CacheableHttpRequest<ReqBody>, CacheableHttpResponse<ResBody>>, CM: ConcurrencyManager<Result<CacheableHttpResponse<ResBody>, S::Error>> + Clone + 'static, O: Offload<'static> + Clone, ReqBody: HttpBody + Send + 'static, ReqBody::Error: Send, ResBody: HttpBody + Send + 'static, ResBody::Error: Send, ResBody::Data: Send, S::Error: Send,

type Response = Response<BufferedBody<ResBody>>

Responses given by the service.

type Error = <S as Service<Request<BufferedBody<ReqBody>>>>::Error

Errors produced by the service.

type Future = CacheServiceFuture<CacheFuture<'static, B, CacheableHttpRequest<ReqBody>, Result<CacheableHttpResponse<ResBody>, <S as Service<Request<BufferedBody<ReqBody>>>>::Error>, TowerUpstream<S, ReqBody, ResBody>, <C as CacheConfig<CacheableHttpRequest<ReqBody>, CacheableHttpResponse<ResBody>>>::RequestPredicate, <C as CacheConfig<CacheableHttpRequest<ReqBody>, CacheableHttpResponse<ResBody>>>::ResponsePredicate, <C as CacheConfig<CacheableHttpRequest<ReqBody>, CacheableHttpResponse<ResBody>>>::Extractor, CM, O>, ResBody, <S as Service<Request<BufferedBody<ReqBody>>>>::Error>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request<ReqBody>) -> Self::Future

Process the request and return the response asynchronously.