Skip to main content

CacheableHttpRequest

Struct CacheableHttpRequest

pub struct CacheableHttpRequest<ReqBody>where
    ReqBody: Body,
{ /* private fields */ }

Expand description

Wraps an HTTP request for cache policy evaluation.

This type holds the request metadata (Parts) and a BufferedBody that allows predicates and extractors to inspect the request without fully consuming the body stream.

§Type Parameters

ReqBody - The HTTP request body type. Must implement hyper::body::Body with Send bounds. Common concrete types:
- Empty<Bytes> - No body (GET requests)
- Full<Bytes> - Complete body in memory
- BoxBody<Bytes, E> - Type-erased body for dynamic dispatch

§Examples

use bytes::Bytes;
use http::Request;
use http_body_util::Empty;
use hitbox_http::{BufferedBody, CacheableHttpRequest};

let request = Request::builder()
    .method("GET")
    .uri("/users/42")
    .header("Authorization", "Bearer token")
    .body(BufferedBody::Passthrough(Empty::<Bytes>::new()))
    .unwrap();

let cacheable = CacheableHttpRequest::from_request(request);

§Extracting Cache Keys

Use with extractors to generate cache key parts:

use hitbox::Extractor;
use hitbox_http::CacheableHttpRequest;
use hitbox_http::extractors::{Method, path::PathExtractor};

async fn example(cacheable: CacheableHttpRequest<Empty<Bytes>>) {
    let extractor = Method::new().path("/users/{user_id}");
    let key_parts = extractor.get(cacheable).await;
}

Implementations§

impl<ReqBody> CacheableHttpRequest<ReqBody>
where ReqBody: Body,

pub fn from_request( request: Request<BufferedBody<ReqBody>>, ) -> CacheableHttpRequest<ReqBody>

Creates a cacheable request from an HTTP request with a buffered body.

The request body must already be wrapped in a BufferedBody. Use BufferedBody::Passthrough for requests that haven’t been inspected yet.

pub fn into_request(self) -> Request<BufferedBody<ReqBody>>

Converts back into a standard HTTP request.

Use this after cache policy evaluation to continue processing the request.

pub fn parts(&self) -> &Parts

Returns a reference to the request metadata.

The Parts contain the method, URI, version, headers, and extensions.

pub fn into_parts(self) -> (Parts, BufferedBody<ReqBody>)

Decomposes into metadata and body.

This is equivalent to CacheableSubject::into_parts.

Trait Implementations§

impl<ReqBody> CacheableRequest for CacheableHttpRequest<ReqBody>
where ReqBody: Body + Send + 'static, <ReqBody as Body>::Error: Send,

async fn cache_policy<P, E>( self, predicates: P, extractors: E, ) -> CachePolicy<CacheablePolicyData<CacheableHttpRequest<ReqBody>>, CacheableHttpRequest<ReqBody>>
where P: Predicate<Subject = CacheableHttpRequest<ReqBody>> + Send + Sync, E: Extractor<Subject = CacheableHttpRequest<ReqBody>> + Send + Sync,

Determine if this request should be cached and extract its key. Read more

impl<ReqBody> CacheableSubject for CacheableHttpRequest<ReqBody>
where ReqBody: Body,

type Body = ReqBody

The HTTP body type.

type Parts = Parts

The metadata type (e.g., http::request::Parts or http::response::Parts).

fn into_parts( self, ) -> (<CacheableHttpRequest<ReqBody> as CacheableSubject>::Parts, BufferedBody<<CacheableHttpRequest<ReqBody> as CacheableSubject>::Body>)

Decomposes this subject into metadata and body. Read more

fn from_parts( parts: <CacheableHttpRequest<ReqBody> as CacheableSubject>::Parts, body: BufferedBody<<CacheableHttpRequest<ReqBody> as CacheableSubject>::Body>, ) -> CacheableHttpRequest<ReqBody>

Reconstructs a subject from metadata and body. Read more

impl<ReqBody> Debug for CacheableHttpRequest<ReqBody>
where ReqBody: Debug + Body,

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

Formats the value using the given formatter. Read more

impl<ReqBody> HasHeaders for CacheableHttpRequest<ReqBody>
where ReqBody: Body,

fn headers(&self) -> &HeaderMap

Returns a reference to the HTTP headers.

impl<ReqBody> HasVersion for CacheableHttpRequest<ReqBody>
where ReqBody: Body,

fn http_version(&self) -> Version

Returns the HTTP protocol version.

impl<'a> Upstream<CacheableHttpRequest<Body>> for ReqwestUpstream<'a>

Implementation of Upstream for reqwest-middleware integration.

This allows the hitbox cache FSM to treat the remaining middleware chain as an upstream service that can be called on cache misses.

type Response = Result<CacheableHttpResponse<Body>, Error>

The response type returned by the upstream service

type Future = Pin<Box<dyn Future<Output = <ReqwestUpstream<'a> as Upstream<CacheableHttpRequest<Body>>>::Response> + Send + 'a>>

The future that resolves to the response

fn call(&mut self, req: CacheableHttpRequest<Body>) -> Self::Future

Call the upstream service with the given request

Auto Trait Implementations§

impl<ReqBody> !Freeze for CacheableHttpRequest<ReqBody>

impl<ReqBody> !RefUnwindSafe for CacheableHttpRequest<ReqBody>

impl<ReqBody> Send for CacheableHttpRequest<ReqBody>
where ReqBody: Send, <ReqBody as Body>::Error: Send,

impl<ReqBody> Sync for CacheableHttpRequest<ReqBody>
where ReqBody: Sync, <ReqBody as Body>::Error: Sync,

impl<ReqBody> Unpin for CacheableHttpRequest<ReqBody>
where ReqBody: Unpin,

impl<ReqBody> !UnwindSafe for CacheableHttpRequest<ReqBody>

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Pointable for T

const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> PolicyExt for T
where T: ?Sized,

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more

impl<T> Same for T

type Output = T

Should always be Self

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

impl<A, B, T> HttpServerConnExec<A, B> for T
where B: Body,