https://github.com/mlalic/tokio-solicit

An async HTTP/2 client, based on Tokio and solicit
https://github.com/mlalic/tokio-solicit

asynchttp http2 rust tokio

Last synced: 11 months ago
JSON representation

An async HTTP/2 client, based on Tokio and solicit

• Host: GitHub
• URL: https://github.com/mlalic/tokio-solicit
• Owner: mlalic
• License: mit
• Created: 2017-01-25T05:59:38.000Z (over 9 years ago)
• Default Branch: master
• Last Pushed: 2017-02-21T04:56:24.000Z (over 9 years ago)
• Last Synced: 2025-04-05T05:51:17.738Z (about 1 year ago)
• Topics: asynchttp, http2, rust, tokio
• Language: Rust
• Size: 66.4 KB
• Stars: 6
• Watchers: 1
• Forks: 1
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

          
# tokio_solicit

An async HTTP/2 client, based on [Tokio](https://tokio.rs/) and [solicit](https://github.com/mlalic/solicit).

# Example

```rust

extern crate env_logger;

extern crate tokio_core;

extern crate futures;

extern crate tokio_solicit;

use std::str;

use std::net::{ToSocketAddrs};

use futures::{Future};

use tokio_core::reactor::{Core};

use tokio_solicit::client::H2Client;

fn main() {

    env_logger::init().expect("logger init is required");

    // Prepare the Tokio event loop that will run the request to completion.

    let mut core = Core::new().expect("event loop required");

    let handle = core.handle();

    // Obtain a `SocketAddr` in any supported way...

    let addr =

        "google.com:443"

            .to_socket_addrs()

            .expect("unable to resolve the domain name")

            .next()

            .expect("no matching ip addresses");

    // Prepare the http/2 client, providing it additionally the authority that it

    // is to communicate to (aka Host name). This returns a future that resolves to

    // an `H2Client` instance...

    let future_client = H2Client::connect("google.com", &addr, &handle);

    let future_response = future_client.and_then(|mut client| {

        // ...once that is resolved, send out the request.

        println!("Connection established.");

        // (We want the future to resolve only once the full body is ready)

        client.get(b"/").into_full_body_response()

    });

    // No code up to here actually performed any IO. Now, let's spin up the event loop

    // and wait for the future we built up to resolve to the response.

    let response = core.run(future_response).expect("unexpected error");

    // Print both the headers and the response body...

    println!("{:?}", response.headers);

    // (Recklessly assume it's utf-8!)

    let body = str::from_utf8(&response.body).unwrap();

    println!("{}", body);

}

```

For more examples, including how to stream the body of the request and response, check out [`examples/client.rs`](examples/client.rs).

# License

The project is published under the terms of the MIT license.