Need an examples of http2 client for hyper

[niranjankhare]

The examples don't seem to include good examples of http2 clients, especially for ones that POST bodies.
Seems like http1 and http2 clients api are different, and especially http2 ones need more boiler plate code?
I'm looking particularly for one that would send bytes::Bytes over the wire.
I'm noob , and would appreciate some examples around this!

I've looked quite a bit on the net an also in the examples, but did not find something useful.

Thank you!

[seanmonstar]

The shape of the APIs for HTTP/1 and HTTP/2 is very similar. However, if you find the differences difficult, and don't care about them, I'd recommend using the reqwest crate.

[niranjankhare]

Thanks, @seanmonstar, for the suggestion.
I looked at reqwest crate and it seems to support multipart/form-data but not multipart/related. Please correct me if I'm wrong.

[seanmonstar]

True, it doesn't have easy support for multipart/related. reqwest does allow you to send any header and any body though.

[akrasic]

@niranjankhare did you manage get a HTTP2 connection with hyper ?

[akrasic]

I'll just add a example scrip there, if there are any comments, please let me know.
Thanks!

use core::panic;
use http_body_util::{combinators::BoxBody, BodyExt, Empty};
use hyper::body::Bytes;
use hyper::Request;
use hyper_util::rt::TokioIo;
use log::debug;
use std::{net::ToSocketAddrs, sync::Arc};
use tokio::net::TcpStream;
use tokio_rustls::{rustls, TlsConnector};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Set log level to TRACE to see detailed information
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .init();

    let domain = "www.google.com";
    let uri = format!("https://{}/", domain);
    let target_host = match format!("{}:443", domain).to_socket_addrs() {
        Ok(socket_ip) => socket_ip.into_iter().next().unwrap(),
        Err(e) => {
            panic!("DNS resolution error: {}", e);
        }
    };

    let mut root_cert_store = rustls::RootCertStore::empty();
    root_cert_store.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());

    let mut config = rustls::ClientConfig::builder()
        .with_root_certificates(root_cert_store)
        .with_no_client_auth();
    config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec(), b"http/1.0".to_vec()];

    let connector = TlsConnector::from(Arc::new(config));
      let tcp_stream = TcpStream::connect(target_host).await?;
    let tls_domain = rustls_pki_types::ServerName::try_from(domain)
        .map_err(|_| std::io::Error::new(std::io::ErrorKind::InvalidInput, "invalid dnsname"))?
        .to_owned();

    let stream = connector.connect(tls_domain, tcp_stream).await?;
    let io = TokioIo::new(stream);
    let executor = hyper_util::rt::tokio::TokioExecutor::new();

    let (mut sender, conn) = hyper::client::conn::http2::handshake(executor, io).await?;

    tokio::task::spawn(async move {
        if let Err(e) = conn.await {
            println!("Error: {:?}", e);
        }
    });

    let upstream_request = Request::builder()
        .uri(uri)
        .header("user-agent", "hyper-client-http2")
        .version(hyper::Version::HTTP_2)
        .body(Empty::<Bytes>::new())?;

    debug!("Request: {:#?}", upstream_request);
    let res = sender.send_request(upstream_request).await?;

    debug!("Response: {:#?}", res);

    let body = res.collect().await?.to_bytes();

    println!("{}", String::from_utf8_lossy(&body));
    Ok(())
}

[niranjankhare]

@akrasic Thank you for the sample. I did find an example here: https://github.com/hyperium/hyper/blob/master/examples/single_threaded.rs, and using that I built a rudimentary relay to listen on http and relay it via http2 client
(I have a openapi generated codebase using hyper 0.14, (http2 server) and I need this server to implement a callback toward the client over http2. )
I ended up using the example code to run a hyper 1.2 http server and use hyper 1.2 http2 client to relay the request.
Not the best approach, but woking well for my needs for now.
I'll have to come back to your example and see if this will help me getting rid of the relay, but that'd have to wait till I can find some time to come back to this! Sincerely appreciate the example you shared!
Thanks again!

[freerig]

Hi,
I've used some pieces of your code, and I have this line of code :
let (mut sender, conn) = hyper::client::conn::http2::handshake(executor, io).await?;
and the rust compiler says that :

error[E0284]: type annotations needed
  --> src/main.rs:56:25
   |
56 |                         hyper::client::conn::http2::handshake(executor, io).await.unwrap();
   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `B` declared on the function `handshake`
   |
   = note: cannot satisfy `<_ as Body>::Data == _`
help: consider specifying the generic arguments
   |
56 |                         hyper::client::conn::http2::handshake::<TokioExecutor, TokioIo<tokio::net::TcpStream>, B>(executor, io).await.unwrap();
   |                                                              ++++++++++++++++++++++++++++++++++++++++++++++++++++

And obviously I don't know what to put in B, I don't understand this stuff in client/conn/http2.rs :

    B: Body + 'static,
    B::Data: Send,
    B::Error: Into<Box<dyn Error + Send + Sync>>,

In case, this is my code:

        async fn get(&self, host: &str, port: u16) -> ComponentAnswer<String> {
            // TODO: host validation (must not contain ":" and other stuff)
            let addr = format!("{}:{}", host, port);
            let result = TcpStream::connect(addr).await;
            match result {
                Ok(stream) => {
                    let io = TokioIo::new(stream);
                    let executor = hyper_util::rt::tokio::TokioExecutor::new();

                    let (mut sender, conn) =
                        hyper::client::conn::http2::handshake(executor, io).await.unwrap();

                    tokio::task::spawn(async move {
                        if let Err(e) = conn.await {
                            println!("Error: {:?}", e);
                        }
                    });
                }
                _ => {}
            }
            ComponentAnswer::Real("Web Page".into())
        }

I'm new to Rust so maybe the answer is obvious, but I didn't figured it out myself

PS: Builder::new(exec).handshake(io) does the same

[akrasic]

Not sure what is the use case for yourself, but it seems that have you have set up traits might be causing issues. If you just need to call a HTTP endpoint you're better off using reqwest or the client from hyper_util ( https://docs.rs/hyper-util/latest/hyper_util/client/legacy/struct.Builder.html ).
I've switched up to legacy Hyper util since it offers connection pooling and that's what I needed.