Struct HttpStreamingCache 

pub struct HttpStreamingCache<T>
where
    T: StreamingCacheManager,
{
    pub mode: CacheMode,
    pub manager: T,
    pub options: HttpCacheOptions,
}

Available on crate feature streaming only.

Streaming version of HTTP cache that supports streaming request/response bodies without buffering them in memory.

Fields

mode: CacheMode

Determines the manager behavior.

manager: T

Manager instance that implements the StreamingCacheManager trait.

options: HttpCacheOptions

Override the default cache options.

Trait Implementations

impl<T> Clone for HttpStreamingCache<T>

where T: Clone + StreamingCacheManager,

fn clone(&self) -> HttpStreamingCache<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for HttpStreamingCache<T>

where T: Debug + StreamingCacheManager,

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

Formats the value using the given formatter.

impl<T> HttpCacheStreamInterface for HttpStreamingCache<T>

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

type Body = <T as StreamingCacheManager>::Body

The body type used by this cache implementation

fn analyze_request( &self, parts: &Parts, mode_override: Option<CacheMode>, ) -> Result<CacheAnalysis, Box<dyn Error + Send + Sync>>

Analyze a request to determine cache behavior

async fn lookup_cached_response( &self, key: &str, ) -> Result<Option<(Response<<HttpStreamingCache<T> as HttpCacheStreamInterface>::Body>, CachePolicy)>, Box<dyn Error + Send + Sync>>

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>, metadata: Option<Vec<u8>>, ) -> Result<Response<<HttpStreamingCache<T> as HttpCacheStreamInterface>::Body>, Box<dyn Error + Send + Sync>>

where B: Body + Send + 'static, <B as Body>::Data: Send, <B as Body>::Error: Into<StreamingError>, <<T as StreamingCacheManager>::Body as Body>::Data: Send, <<T as StreamingCacheManager>::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<<HttpStreamingCache<T> as HttpCacheStreamInterface>::Body>, policy: &CachePolicy, ) -> Result<(), Box<dyn Error + Send + Sync>>

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

async fn handle_not_modified( &self, cached_response: Response<<HttpStreamingCache<T> as HttpCacheStreamInterface>::Body>, fresh_parts: &Parts, ) -> Result<Response<<HttpStreamingCache<T> as HttpCacheStreamInterface>::Body>, Box<dyn Error + Send + Sync>>

Handle a 304 Not Modified response by returning the cached response