Struct fastly::Response

pub struct Response<T> { /* fields omitted */ }

Represents an HTTP response

An HTTP response consists of a head and a potentially optional body. The body component is generic, enabling arbitrary types to represent the HTTP body. For example, the body could be Vec<u8>, a Stream of byte chunks, or a value that has been deserialized.

Typically you'll work with responses on the client side as the result of sending a Request and on the server you'll be generating a Response to send back to the client.

Examples

Creating a Response to return

use http::{Request, Response, StatusCode};

fn respond_to(req: Request<()>) -> http::Result<Response<()>> {
    let mut builder = Response::builder()
        .header("Foo", "Bar")
        .status(StatusCode::OK);

    if req.headers().contains_key("Another-Header") {
        builder = builder.header("Another-Header", "Ack");
    }

    builder.body(())
}

A simple 404 handler

use http::{Request, Response, StatusCode};

fn not_found(_req: Request<()>) -> http::Result<Response<()>> {
    Response::builder()
        .status(StatusCode::NOT_FOUND)
        .body(())
}

Or otherwise inspecting the result of a request:

use http::{Request, Response};

fn get(url: &str) -> http::Result<Response<()>> {
    // ...
}

let response = get("https://www.rust-lang.org/").unwrap();

if !response.status().is_success() {
    panic!("failed to get a successful response status!");
}

if let Some(date) = response.headers().get("Date") {
    // we've got a `Date` header!
}

let body = response.body();
// ...

Deserialize a response of bytes via json:

use http::Response;
use serde::de;

fn deserialize<T>(req: Response<Vec<u8>>) -> serde_json::Result<Response<T>>
    where for<'de> T: de::Deserialize<'de>,
{
    let (parts, body) = req.into_parts();
    let body = serde_json::from_slice(&body)?;
    Ok(Response::from_parts(parts, body))
}

Or alternatively, serialize the body of a response to json

use http::Response;
use serde::ser;

fn serialize<T>(req: Response<T>) -> serde_json::Result<Response<Vec<u8>>>
    where T: ser::Serialize,
{
    let (parts, body) = req.into_parts();
    let body = serde_json::to_vec(&body)?;
    Ok(Response::from_parts(parts, body))
}

Implementations

impl Response<()>

pub fn builder() -> Builder

Creates a new builder-style object to manufacture a Response

This method returns an instance of Builder which can be used to create a Response.

Examples

let response = Response::builder()
    .status(200)
    .header("X-Custom-Foo", "Bar")
    .body(())
    .unwrap();

impl<T> Response<T>

pub fn new(body: T) -> Response<T>

Creates a new blank Response with the body

The component ports of this response will be set to their default, e.g. the ok status, no headers, etc.

Examples

let response = Response::new("hello world");

assert_eq!(response.status(), StatusCode::OK);
assert_eq!(*response.body(), "hello world");

pub fn from_parts(parts: Parts, body: T) -> Response<T>

Creates a new Response with the given head and body

Examples

let response = Response::new("hello world");
let (mut parts, body) = response.into_parts();

parts.status = StatusCode::BAD_REQUEST;
let response = Response::from_parts(parts, body);

assert_eq!(response.status(), StatusCode::BAD_REQUEST);
assert_eq!(*response.body(), "hello world");

pub fn status(&self) -> StatusCode

Returns the StatusCode.

Examples

let response: Response<()> = Response::default();
assert_eq!(response.status(), StatusCode::OK);

pub fn status_mut(&mut self) -> &mut StatusCode

Returns a mutable reference to the associated StatusCode.

Examples

let mut response: Response<()> = Response::default();
*response.status_mut() = StatusCode::CREATED;
assert_eq!(response.status(), StatusCode::CREATED);

pub fn version(&self) -> Version

Returns a reference to the associated version.

Examples

let response: Response<()> = Response::default();
assert_eq!(response.version(), Version::HTTP_11);

pub fn version_mut(&mut self) -> &mut Version

Returns a mutable reference to the associated version.

Examples

let mut response: Response<()> = Response::default();
*response.version_mut() = Version::HTTP_2;
assert_eq!(response.version(), Version::HTTP_2);

pub fn headers(&self) -> &HeaderMap<HeaderValue>

Returns a reference to the associated header field map.

Examples

let response: Response<()> = Response::default();
assert!(response.headers().is_empty());

pub fn headers_mut(&mut self) -> &mut HeaderMap<HeaderValue>

Returns a mutable reference to the associated header field map.

Examples

let mut response: Response<()> = Response::default();
response.headers_mut().insert(HOST, HeaderValue::from_static("world"));
assert!(!response.headers().is_empty());

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

Examples

let response: Response<()> = Response::default();
assert!(response.extensions().get::<i32>().is_none());

pub fn extensions_mut(&mut self) -> &mut Extensions

Returns a mutable reference to the associated extensions.

Examples

let mut response: Response<()> = Response::default();
response.extensions_mut().insert("hello");
assert_eq!(response.extensions().get(), Some(&"hello"));

pub fn body(&self) -> &T

Returns a reference to the associated HTTP body.

Examples

let response: Response<String> = Response::default();
assert!(response.body().is_empty());

pub fn body_mut(&mut self) -> &mut T

Returns a mutable reference to the associated HTTP body.

Examples

let mut response: Response<String> = Response::default();
response.body_mut().push_str("hello world");
assert!(!response.body().is_empty());

pub fn into_body(self) -> T

Consumes the response, returning just the body.

Examples

let response = Response::new(10);
let body = response.into_body();
assert_eq!(body, 10);

pub fn into_parts(self) -> (Parts, T)

Consumes the response returning the head and body parts.

Examples

let response: Response<()> = Response::default();
let (parts, body) = response.into_parts();
assert_eq!(parts.status, StatusCode::OK);

pub fn map<F, U>(self, f: F) -> Response<U> where
    F: FnOnce(T) -> U, 

Consumes the response returning a new response with body mapped to the return type of the passed in function.

Examples

let response = Response::builder().body("some string").unwrap();
let mapped_response: Response<&[u8]> = response.map(|b| {
  assert_eq!(b, "some string");
  b.as_bytes()
});
assert_eq!(mapped_response.body(), &"some string".as_bytes());

Trait Implementations

impl<T> Debug for Response<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Default for Response<T> where
    T: Default, 

fn default() -> Response<T>

Returns the "default value" for a type.

impl ResponseExt for Response<Body>

fn send_downstream(self) -> Result<(), Error>

Send this response downstream to the client.

This will only begin sending bytes once the program has completed execution. If you want to begin sending before the program is complete, use ResponseExt::send_downstream_streaming().

fn send_downstream_streaming(self) -> Result<StreamingBody, Error>

Immediately begin sending this response downstream to the client, and return a StreamingBody that can accept further data to send.

fn inner_to_body(self) -> Result<Response<Body>, Error>

Replace the body of a response with a Body with the same contents.

fn inner_to_bytes(self) -> Result<Response<Vec<u8>>, Error>

Replace the body of a response with the remaining contents of its body.

impl<'_> ResponseExt for Response<&'_ [u8]>

fn inner_to_body(self) -> Result<Response<Body>, Error>

Replace the body of a response with a Body with the same contents.

fn inner_to_bytes(self) -> Result<Response<Vec<u8>>, Error>

Replace the body of a response with the remaining contents of its body.

fn send_downstream(self) -> Result<(), Error>

fn send_downstream_streaming(self) -> Result<StreamingBody, Error>

impl ResponseExt for Response<Vec<u8>>

fn inner_to_body(self) -> Result<Response<Body>, Error>

Replace the body of a response with a Body with the same contents.

fn inner_to_bytes(self) -> Result<Response<Vec<u8>>, Error>

Replace the body of a response with the remaining contents of its body.

fn send_downstream(self) -> Result<(), Error>

fn send_downstream_streaming(self) -> Result<StreamingBody, Error>

impl<'_> ResponseExt for Response<&'_ str>

fn inner_to_body(self) -> Result<Response<Body>, Error>

Replace the body of a response with a Body with the same contents.

fn inner_to_bytes(self) -> Result<Response<Vec<u8>>, Error>

Replace the body of a response with the remaining contents of its body.

fn send_downstream(self) -> Result<(), Error>

fn send_downstream_streaming(self) -> Result<StreamingBody, Error>

impl ResponseExt for Response<String>

fn inner_to_body(self) -> Result<Response<Body>, Error>

Replace the body of a response with a Body with the same contents.

fn inner_to_bytes(self) -> Result<Response<Vec<u8>>, Error>

Replace the body of a response with the remaining contents of its body.

fn send_downstream(self) -> Result<(), Error>

fn send_downstream_streaming(self) -> Result<StreamingBody, Error>

impl ResponseExt for Response<()>

fn inner_to_body(self) -> Result<Response<Body>, Error>

Replace the body of a response with a Body with the same contents.

fn inner_to_bytes(self) -> Result<Response<Vec<u8>>, Error>

Replace the body of a response with the remaining contents of its body.

fn send_downstream(self) -> Result<(), Error>

fn send_downstream_streaming(self) -> Result<StreamingBody, Error>