Struct lta::reqwest_blocking::Response

pub struct Response { /* private fields */ }

A Response to a submitted Request.

Implementations

impl Response

pub fn status(&self) -> StatusCode

Get the StatusCode of this Response.

Examples

Checking for general status class:

let resp = reqwest::blocking::get("http://httpbin.org/get")?;
if resp.status().is_success() {
    println!("success!");
} else if resp.status().is_server_error() {
    println!("server error!");
} else {
    println!("Something else happened. Status: {:?}", resp.status());
}

Checking for specific status codes:

use reqwest::blocking::Client;
use reqwest::StatusCode;
let client = Client::new();

let resp = client.post("http://httpbin.org/post")
    .body("possibly too large")
    .send()?;

match resp.status() {
    StatusCode::OK => println!("success!"),
    StatusCode::PAYLOAD_TOO_LARGE => {
        println!("Request payload is too large!");
    }
    s => println!("Received response status: {:?}", s),
};

pub fn headers(&self) -> &HeaderMap

Get the Headers of this Response.

Example

Saving an etag when caching a file:

use reqwest::blocking::Client;
use reqwest::header::ETAG;

let client = Client::new();

let mut resp = client.get("http://httpbin.org/cache").send()?;
if resp.status().is_success() {
    if let Some(etag) = resp.headers().get(ETAG) {
        std::fs::write("etag", etag.as_bytes());
    }
    let mut file = std::fs::File::create("file")?;
    resp.copy_to(&mut file)?;
}

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

Get a mutable reference to the Headers of this Response.

pub fn version(&self) -> Version

Get the HTTP Version of this Response.

pub fn url(&self) -> &Url

Get the final Url of this Response.

Example

let resp = reqwest::blocking::get("http://httpbin.org/redirect/1")?;
assert_eq!(resp.url().as_str(), "http://httpbin.org/get");

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

Get the remote address used to get this Response.

Example

let resp = reqwest::blocking::get("http://httpbin.org/redirect/1")?;
println!("httpbin.org address: {:?}", resp.remote_addr());

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

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

Returns a mutable reference to the associated extensions.

pub fn content_length(&self) -> Option<u64>

Get the content-length of the response, if it is known.

Reasons it may not be known:

• The server didn’t send a content-length header.
• The response is gzipped and automatically decoded (thus changing the actual decoded length).

pub fn json<T>(self) -> Result<T, Error>

where T: DeserializeOwned,

Try and deserialize the response body as JSON using serde.

Optional

This requires the optional json feature enabled.

Examples

// This `derive` requires the `serde` dependency.
#[derive(Deserialize)]
struct Ip {
    origin: String,
}

let json: Ip = reqwest::blocking::get("http://httpbin.org/ip")?.json()?;

Errors

This method fails whenever the response body is not in JSON format or it cannot be properly deserialized to target type T. For more details please see serde_json::from_reader.

pub fn bytes(self) -> Result<Bytes, Error>

Get the full response body as Bytes.

Example

let bytes = reqwest::blocking::get("http://httpbin.org/ip")?.bytes()?;

println!("bytes: {:?}", bytes);

pub fn text(self) -> Result<String, Error>

Get the response text.

This method decodes the response body with BOM sniffing and with malformed sequences replaced with the REPLACEMENT CHARACTER. Encoding is determined from the charset parameter of Content-Type header, and defaults to utf-8 if not presented.

Example

let content = reqwest::blocking::get("http://httpbin.org/range/26")?.text()?;

pub fn text_with_charset(self, default_encoding: &str) -> Result<String, Error>

Get the response text given a specific encoding.

This method decodes the response body with BOM sniffing and with malformed sequences replaced with the REPLACEMENT CHARACTER. You can provide a default encoding for decoding the raw message, while the charset parameter of Content-Type header is still prioritized. For more information about the possible encoding name, please go to encoding_rs docs.

Example

let content = reqwest::blocking::get("http://httpbin.org/range/26")?
    .text_with_charset("utf-8")?;

pub fn copy_to<W>(&mut self, w: &mut W) -> Result<u64, Error>

where W: Write + ?Sized,

Copy the response body into a writer.

This function internally uses std::io::copy and hence will continuously read data from the body and then write it into writer in a streaming fashion until EOF is met.

On success, the total number of bytes that were copied to writer is returned.

Example

let mut resp = reqwest::blocking::get("http://httpbin.org/range/5")?;
let mut buf: Vec<u8> = vec![];
resp.copy_to(&mut buf)?;
assert_eq!(b"abcde", buf.as_slice());

pub fn error_for_status(self) -> Result<Response, Error>

Turn a response into an error if the server returned an error.

Example

let res = reqwest::blocking::get("http://httpbin.org/status/400")?
    .error_for_status();
if let Err(err) = res {
    assert_eq!(err.status(), Some(reqwest::StatusCode::BAD_REQUEST));
}

pub fn error_for_status_ref(&self) -> Result<&Response, Error>

Turn a reference to a response into an error if the server returned an error.

Example

let res = reqwest::blocking::get("http://httpbin.org/status/400")?;
let res = res.error_for_status_ref();
if let Err(err) = res {
    assert_eq!(err.status(), Some(reqwest::StatusCode::BAD_REQUEST));
}

Trait Implementations

impl Debug for Response

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

Formats the value using the given formatter.

impl<T> From<Response<T>> for Response

where T: Into<Body>,

fn from(r: Response<T>) -> Response

Converts to this type from the input type.

impl Read for Response

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.