Struct HttpCache 

pub struct HttpCache<T>
where
    T: CacheManager,
{
    pub mode: CacheMode,
    pub manager: T,
    pub options: HttpCacheOptions,
}

Caches requests according to http spec.

Fields

mode: CacheMode

Determines the manager behavior.

manager: T

Manager instance that implements the CacheManager trait. By default, a manager implementation with cacache as the backend has been provided, see CACacheManager.

options: HttpCacheOptions

Override the default cache options.

Implementations

impl<T> HttpCache<T>

where T: CacheManager,

pub fn can_cache_request( &self, middleware: &impl Middleware, ) -> Result<bool, Box<dyn Error + Sync + Send>>

Determines if the request should be cached

pub async fn run_no_cache( &self, middleware: &mut impl Middleware, ) -> Result<(), Box<dyn Error + Sync + Send>>

Runs the actions to preform when the client middleware is running without the cache

pub async fn run( &self, middleware: impl Middleware, ) -> Result<HttpResponse, Box<dyn Error + Sync + Send>>

Attempts to run the passed middleware along with the cache

Trait Implementations

impl<T> Clone for HttpCache<T>

where T: Clone + CacheManager,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for HttpCache<T>

where T: Debug + CacheManager,

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

Formats the value using the given formatter.

impl<T> HttpCacheInterface for HttpCache<T>

where T: CacheManager,

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

Analyze a request to determine cache behavior

async fn lookup_cached_response( &self, key: &str, ) -> Result<Option<(HttpResponse, CachePolicy)>, Box<dyn Error + Sync + Send>>

Look up a cached response for the given cache key

async fn process_response( &self, analysis: CacheAnalysis, response: Response<Vec<u8>>, ) -> Result<Response<Vec<u8>>, Box<dyn Error + Sync + Send>>

Process a fresh response from upstream and potentially cache it

fn prepare_conditional_request( &self, parts: &mut Parts, _cached_response: &HttpResponse, policy: &CachePolicy, ) -> Result<(), Box<dyn Error + Sync + Send>>

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

async fn handle_not_modified( &self, cached_response: HttpResponse, fresh_parts: &Parts, ) -> Result<HttpResponse, Box<dyn Error + Sync + Send>>

Handle a 304 Not Modified response by returning the cached response