Struct Context 

pub struct Context {
    pub req: Request,
    /* private fields */
}

Context holds request data and provides response building methods

Fields

req: Request

Implementations

impl Context

pub async fn new(req: HyperRequest<Incoming>, params: Params) -> Result<Self>

Create a new context from a request and params

pub async fn set(&self, key: impl Into<String>, value: impl Into<String>)

Set a value in the context state (shared between middleware)

pub async fn get(&self, key: &str) -> Option<String>

Get a value from the context state

pub fn cookie(&self, name: &str) -> Option<String>

Read a request cookie by name.

pub fn cookies(&self) -> HashMap<String, String>

All request cookies.

pub async fn set_cookie(&self, cookie: Cookie) -> Result<()>

Queue a Set-Cookie for the response. Errors if the cookie is invalid.

pub async fn remove_cookie(&self, name: &str) -> Result<()>

Queue a deletion of the named cookie (Max-Age=0).

pub fn peer_addr(&self) -> Option<SocketAddr>

The peer address of the underlying connection, if known. This is the direct socket peer — for the originating client behind a proxy, use client_ip.

pub fn client_ip(&self) -> Option<IpAddr>

Best-effort originating client IP.

When proxy trust is enabled (app.trust_proxy(true)) this honors the left-most X-Forwarded-For entry, then Forwarded: for=…; otherwise (or if no such header) it falls back to the connection peer. Only enable proxy trust when the app is actually behind a trusted proxy — these headers are client-spoofable.

pub async fn status(&self, code: u16)

Set the response status code

pub async fn header(&self, name: impl Into<String>, value: impl Into<String>)

Add a response header

pub async fn json<T: Serialize>(&self, value: T) -> Result<Response>

Return a JSON response

pub async fn text(&self, text: impl Into<String>) -> Result<Response>

Return a text response

pub async fn html(&self, html: impl Into<String>) -> Result<Response>

Return an HTML response

pub async fn stream<S>(&self, body: S) -> Result<Response>

where S: Stream<Item = Result<Bytes, BoxError>> + Send + 'static,

Return a streaming response body.

Each Ok(bytes) item is sent as a chunk; the response is chunked (no Content-Length). Any queued header/status set on the context is applied, except Content-Length/Transfer-Encoding (which would conflict with the chunked framing and are dropped). If no Content-Type was set, it defaults to application/octet-stream. An Err(_) item aborts the connection.

let chunks: Vec<std::result::Result<Bytes, BoxError>> = vec![Ok(Bytes::from("hi"))];
ctx.stream(futures_util::stream::iter(chunks)).await

pub async fn sse<S>(&self, events: S) -> Result<Response>

where S: Stream<Item = SseEvent> + Send + 'static,

Return a Server-Sent Events response streaming typed events.

Sets Content-Type: text/event-stream, Cache-Control: no-cache, and X-Accel-Buffering: no, then streams each SseEvent encoded to the SSE wire format (chunked, no Content-Length).

let evs = vec![SseEvent::new(&json!({ "hello": "world" }))?];
ctx.sse(futures_util::stream::iter(evs)).await

pub async fn sse_keep_alive<S>( &self, events: S, interval: Duration, ) -> Result<Response>

where S: Stream<Item = SseEvent> + Send + 'static,

Like sse, but injects a : ping comment whenever the event stream is idle for interval, so proxies and idle connections aren’t dropped. Terminates when the event stream ends.

pub fn last_event_id(&self) -> Option<String>

The Last-Event-ID request header, if present, for app-driven resume.

pub async fn redirect(&self, location: &str) -> Result<Response>

Return a redirect response

pub async fn not_found(&self) -> Result<Response>

Return a not found response

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl FromRequest for Context

The full request context — the identity extractor, so existing |ctx: Context| async move { … } handlers keep working unchanged.

fn from_request<'life0, 'async_trait>( ctx: &'life0 Context, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,