Trait HttpCacheStreamInterface 

pub trait HttpCacheStreamInterface: Send + Sync {
    type Body: Body + Send + 'static;

    // Required methods
    fn analyze_request(
        &self,
        parts: &Parts,
        mode_override: Option<CacheMode>,
    ) -> Result<CacheAnalysis>;
    async fn lookup_cached_response(
        &self,
        key: &str,
    ) -> Result<Option<(Response<Self::Body>, CachePolicy)>>
       where <Self::Body as Body>::Data: Send,
             <Self::Body as Body>::Error: Into<StreamingError> + Send + Sync + 'static;
    async fn process_response<B>(
        &self,
        analysis: CacheAnalysis,
        response: Response<B>,
    ) -> Result<Response<Self::Body>>
       where B: Body + Send + 'static,
             B::Data: Send,
             B::Error: Into<StreamingError>,
             <Self::Body as Body>::Data: Send,
             <Self::Body as Body>::Error: Into<StreamingError> + Send + Sync + 'static;
    fn prepare_conditional_request(
        &self,
        parts: &mut Parts,
        cached_response: &Response<Self::Body>,
        policy: &CachePolicy,
    ) -> Result<()>;
    async fn handle_not_modified(
        &self,
        cached_response: Response<Self::Body>,
        fresh_parts: &Parts,
    ) -> Result<Response<Self::Body>>
       where <Self::Body as Body>::Data: Send,
             <Self::Body as Body>::Error: Into<StreamingError> + Send + Sync + 'static;
}

Streaming version of the HTTP cache interface that supports streaming request/response bodies without buffering them in memory. This is ideal for large responses or when memory usage is a concern.

Required Associated Types

type Body: Body + Send + 'static

The body type used by this cache implementation

Required Methods

fn analyze_request( &self, parts: &Parts, mode_override: Option<CacheMode>, ) -> Result<CacheAnalysis>

Analyze a request to determine cache behavior

async fn lookup_cached_response( &self, key: &str, ) -> Result<Option<(Response<Self::Body>, CachePolicy)>>

where <Self::Body as Body>::Data: Send, <Self::Body as Body>::Error: Into<StreamingError> + Send + Sync + 'static,

Look up a cached response for the given cache key, returning a streaming body

async fn process_response<B>( &self, analysis: CacheAnalysis, response: Response<B>, ) -> Result<Response<Self::Body>>

where B: Body + Send + 'static, B::Data: Send, B::Error: Into<StreamingError>, <Self::Body as Body>::Data: Send, <Self::Body as Body>::Error: Into<StreamingError> + Send + Sync + 'static,

Process a fresh response from upstream and potentially cache it with streaming support

fn prepare_conditional_request( &self, parts: &mut Parts, cached_response: &Response<Self::Body>, policy: &CachePolicy, ) -> Result<()>

Update request headers for conditional requests (e.g., If-None-Match)

async fn handle_not_modified( &self, cached_response: Response<Self::Body>, fresh_parts: &Parts, ) -> Result<Response<Self::Body>>

where <Self::Body as Body>::Data: Send, <Self::Body as Body>::Error: Into<StreamingError> + Send + Sync + 'static,

Handle a 304 Not Modified response by returning the cached response

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T: StreamingCacheManager> HttpCacheStreamInterface for HttpStreamingCache<T>

where <T::Body as Body>::Data: Send, <T::Body as Body>::Error: Into<StreamingError> + Send + Sync + 'static,

type Body = <T as StreamingCacheManager>::Body