Module hyper::client

HTTP Client

There are two levels of APIs provided for construct HTTP clients:

• The higher-level Client type.
• The lower-level conn module.

Client

The Client is the main way to send HTTP requests to a server. The default Client provides these things on top of the lower-level API:

• A default connector, able to resolve hostnames and connect to destinations over plain-text TCP.
• A pool of existing connections, allowing better performance when making multiple requests to the same hostname.
• Automatic setting of the Host header, based on the request Uri.
• Automatic request retries when a pooled connection is closed by the server before any bytes have been written.

Many of these features can configured, by making use of Client::builder.

Example

extern crate hyper;

use hyper::Client;
use hyper::rt::{self, lazy, Future, Stream};

fn main() {
    // A runtime is needed to execute our asynchronous code.
    rt::run(lazy(|| {
        let client = Client::new();

        client
            // Make a GET /ip to 'http://httpbin.org'
            .get("http://httpbin.org/ip".parse().unwrap())

            // And then, if the request gets a response...
            .and_then(|res| {
                println!("status: {}", res.status());

                // Concatenate the body stream into a single buffer...
                // This returns a new future, since we must stream body.
                res.into_body().concat2()
            })

            // And then, if reading the full body succeeds...
            .and_then(|body| {
                // The body is just bytes, but let's print a string...
                let s = ::std::str::from_utf8(&body)
                    .expect("httpbin sends utf-8 JSON");

                println!("body: {}", s);

                // and_then requires we return a new Future, and it turns
                // out that Result is a Future that is ready immediately.
                Ok(())
            })

            // Map any errors that might have happened...
            .map_err(|err| {
                println!("error: {}", err);
            })
    }));
}

Modules

conn	Lower-level client connection API.
connect	The Connect trait, and supporting types.

Structs

Builder	Builder for a Client
Client	A Client to make outgoing HTTP requests.
HttpConnector	A connector for the http scheme.
ResponseFuture	A Future that will resolve to an HTTP Response.