Struct Response 

pub struct Response {
    pub status: StatusCode,
    pub headers: HeaderMap,
    pub body: Bytes,
    /* private fields */
}

HTTP Response wrapper

Fields

status: StatusCode

headers: HeaderMap

body: Bytes

Implementations

impl Response

pub fn new(status: StatusCode) -> Self

pub fn stream() -> (BodySender, Self)

A response whose body is produced while it is being sent

Returns the sender for the body chunks and the response; set status and headers on the response as usual. The body ends when the last BodySender is dropped, and send fails with Disconnected once the client is gone. Middleware that rewrites body (compression, ETags) leaves streams alone.

use ullun::prelude::*;

async fn countdown(_req: Request) -> Result<Response> {
    let (tx, res) = Response::stream();
    tokio::spawn(async move {
        for n in (1..=3).rev() {
            if tx.send(format!("{n}\n")).await.is_err() {
                return; // client went away
            }
        }
    });
    Ok(res.with_header("content-type", "text/plain"))
}

pub fn is_streaming(&self) -> bool

Whether the body is streamed instead of held in body

pub fn cookie(self, cookie: Cookie) -> Self

Set a cookie

pub fn ok() -> Self

pub fn with_status(self, status: StatusCode) -> Self

pub fn with_body(self, body: impl Into<Bytes>) -> Self

pub fn with_header( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

pub fn json<T: Serialize>(data: T) -> Self

pub fn text(text: impl Into<String>) -> Self

pub fn html(html: impl Into<String>) -> Self

200 OK with an HTML body

pub fn redirect(location: impl Into<String>) -> Self

303 See Other, the right answer after a form POST (Post/Redirect/Get)

pub fn redirect_permanent(location: impl Into<String>) -> Self

308 Permanent Redirect, keeps method and body

pub fn from_error(error: Error) -> Self

Trait Implementations

impl<T: Serialize> From<Json<T>> for Response

fn from(json: Json<T>) -> Self

Converts to this type from the input type.