Struct http_cache_semantics::CachePolicy

pub struct CachePolicy { /* fields omitted */ }

Identifies when responses can be reused from a cache, taking into account HTTP RFC 7234 rules for user agents and shared caches. It’s aware of many tricky details such as the Vary header, proxy revalidation, and authenticated responses.

Implementations

impl CachePolicy

pub fn new<Req: RequestLike, Res: ResponseLike>(req: &Req, res: &Res) -> Self

Cacheability of an HTTP response depends on how it was requested, so both request and response are required to create the policy.

pub fn new_options<Req: RequestLike, Res: ResponseLike>(
    req: &Req,
    res: &Res,
    response_time: SystemTime,
    opts: CacheOptions
) -> Self

Caching with customized behavior. See CacheOptions for details.

response_time is a timestamp when the response has been received, usually SystemTime::now().

pub fn is_storable(&self) -> bool

Returns true if the response can be stored in a cache. If it’s false then you MUST NOT store either the request or the response.

pub fn before_request<Req: RequestLike>(
    &self,
    req: &Req,
    now: SystemTime
) -> BeforeRequest

Returns whether the cached response is still fresh in the context of the new request.

If it returns true, then the given request matches the original response this cache policy has been created with, and the response can be reused without contacting the server.

If it returns false, then the response may not be matching at all (e.g. it’s for a different URL or method), or may require to be refreshed first. Either way, the new request’s headers will have been updated for sending it to the origin server.

pub fn age(&self, now: SystemTime) -> Duration

Tells how long the response has been sitting in cache(s).

Value of the Age header, updated for the current time.

pub fn time_to_live(&self, now: SystemTime) -> Duration

Returns approximate time in milliseconds until the response becomes stale (i.e. not fresh).

After that time (when time_to_live() <= 0) the response might not be usable without revalidation. However, there are exceptions, e.g. a client can explicitly allow stale responses, so always check with before_request().

pub fn is_stale(&self, now: SystemTime) -> bool

Stale responses shouldn’t be used without contacting the server (revalidation)

pub fn after_response<Req: RequestLike, Res: ResponseLike>(
    &self,
    request: &Req,
    response: &Res,
    response_time: SystemTime
) -> AfterResponse

Creates CachePolicy with information combined from the previews response, and the new revalidation response.

Returns {policy, modified} where modified is a boolean indicating whether the response body has been modified, and old cached body can’t be used.

Trait Implementations

impl Debug for CachePolicy

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CachePolicy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for CachePolicy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.