Summary
This series is about how I upgraded hyper (Rust) 0.14 to v1 (1.3).
The next theme is higher-level Server / Client. Those in v0 were removed. It was because they had stability and complexity problems.
The Server wasn't followed by any drop-in replacement, and the Client was in a way by client::legacy::Client (that I didn't use).
In addition, hyper-util helps.
My project challenge
apimock-rs is API mock Server generating HTTP / JSON responses to help to develop microservices and APIs, written in Rust. It's one of my projects.
Its core dependencies is hyper, "a protective and efficient HTTP library for all" which is rather low-level.
Upgraded hyper
I started with hyper 0.14, and 1.0.0 was released last November 🎉
I have recently upgraded it which was a kind of somehow tough work. The change log was as below:
https://github.com/nabbisen/apimock-rs/pull/62/files
Cargo.toml change log
As to HTTP server:
[dependencies]
(...)
- hyper = { version = "0.14", features = ["server", "http1", "http2", "tcp"] }
+ hyper = { version = "1", features = ["server", "http1", "http2"] }
+ hyper-util = { version = "^0.1", features = ["server", "http1", "http2", "tokio"] }
+ http-body-util = "^0.1"
As to HTTP client:
[dev-dependencies]
- hyper = { version = "0.14", features = ["client"] }
+ hyper = { version = "1", features = ["client"] }
Server change log
hyper::Server had gone. I used conn module of auto HTTP version in hyper-util instead of the specific version in hyper since I wanted to support both http1 and http2.
The diff was like:
- use hyper::service::{make_service_fn, service_fn};
- use hyper::Server;
+ use hyper::{body, body::Bytes, service::service_fn, Request, Response};
+ use hyper_util::{
+ rt::{TokioExecutor, TokioIo},
+ server::conn::auto::Builder,
+ };
+ use tokio::net::TcpListener;
(...)
let addr = (...)
- let make_svc = make_service_fn(|_| {
- async move {
- let service = service_fn(move |req| handle(req));
- Ok::<_, Infallible>(service)
- }
- });
-
- let server = Server::bind(&addr).serve(make_svc);
+ let listener = TcpListener::bind(addr)
+ .await
+ .expect("tcp listener failed to bind address");
+ loop {
+ let (stream, _) = listener
+ .accept()
+ .await
+ .expect("tcp listener failed to accept");
+ let io = TokioIo::new(stream);
+
+ tokio::task::spawn(async move {
+ if let Err(err) = Builder::new(TokioExecutor::new())
+ .serve_connection(
+ io,
+ service_fn(move |req: Request<body::Incoming>| service(req )),
+ )
+ .await
+ {
+ eprintln!("error serving connection: {:?}", err);
+ }
+ });
+ }
+
+ async fn service(
+ req: Request<body::Incoming>,
+ ) -> Result<Response<BoxBody>, hyper::http::Error> {
+ handle(req).await
+ }
As it is relatively lower-level module, tokio requires to be dealt with together.
Client change log
In contrast, on client, I used module in hyper which supported the specific HTTP version. It was testing module whose HTTP version didn't affect the result.
- use hyper::{body::to_bytes, Body, Client, Request, Response, StatusCode, Uri};
- (...)
- let request = Request::builder()
- .uri(uri)
- .method("POST")
- .header("Content-Type", "text/plain")
- .body(Body::from(body.to_owned()))
- .unwrap();
- let client = Client::new();
- let response = client.request(request).await.unwrap();
+ let stream = TcpStream::connect(addr).await.unwrap();
+ let io = TokioIo::new(stream);
+ let (mut sender, conn) = hyper::client::conn::http1::handshake(io).await.unwrap();
+ tokio::task::spawn(async move {
+ if let Err(err) = conn.await {
+ println!("Connection failed: {:?}", err);
+ }
+ });
+ (...)
+ let req = Request::builder()
+ .uri(path)
+ .header(hyper::header::HOST, authority.as_str())
+ .body(body)
+ .unwrap();
+ let res = sender.send_request(req).await.unwrap()
hyper::client::conn::http1 is directly used as above.
Reference
Their official documentation and examples are really helpful :)
Top comments (0)