Summary
This series is about how I upgraded hyper (Rust) 0.14 to v1 (1.3).
The first theme is Body
. hyper::Body
in v0 was Struct
changed to Trait
. At the same time, the successors such as hyper::body
::Bytes
and hyper::body::Incoming
came in. It was because it brought more flexibility to hyper even in the future. According to their 1.0 Roadmap:
Forwards-compatibility
There’s a concern about forwards-compatibility. We want to be able to add support for new HTTP features without needing a new major version.
In addition, http_body_util
::combinators::BoxBody
, http_body_util::Full
, http_body_util::Empty
and so on are available.
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"
Body
change log
Here comes the point. Let's see a part of the diff:
- use hyper::Body;
+ use hyper::body::{Bytes, Incoming}};
Again, Body
Struct disappeared. Instead, std::body::*
Structs implementing Body
Trait are available. They are such as std::body::Bytes
and std::body::Incoming
.
How did usage changed ?
- pub async fn handle(
- req: Request<Body>,
- app_state: Arc<Mutex<Config>>,
- ) -> Result<Response<Body>, Error> {
+ type BoxBody = http_body_util::combinators::BoxBody<Bytes, Infallible>;
+ pub async fn handle(
+ req: Request<Incoming>,
+ app_state: Arc<Mutex<Config>>,
+ ) -> Result<Response<BoxBody>, Error> {
Not big, because "The 0.14 Body could be multiple variants, and in v1 they have been split into distinct types" (due to their Upgrade guide).
Well, they seem familiar with streaming process. It's very nice. However, it is sometimes unnecessary to deal with it, especially around either testing or mocking. Therefore, on the app, I managed to deal with the whole bulk full of the frames at once with BoxBody
:
- let body_bytes = hyper::body::to_bytes(request_body).await.unwrap();
+ let body_bytes = request_body
+ .boxed() // here, `BoxBody` comes !
+ .collect()
+ .await
+ .expect("failed to collect request incoming body")
+ .to_bytes();
The client case was similar with it.
- hyper::body::to_bytes;
- (...)
- let response = client.request(request).await.unwrap();
- (...)
- let response_body_str =
- String::from_utf8(to_bytes(response.into_body()).await.unwrap().to_vec()).unwrap();
+ use http_body_util::{BodyExt, Empty, Full};
+ (...)
+ let request_body = Full::new(Bytes::from(body.unwrap().to_owned())).boxed()
+ (...)
+ let response_body_bytes = response
+ .into_body()
+ .boxed()
+ .collect()
+ .await
+ .unwrap()
+ .to_bytes();
+ let response_body_str = String::from_utf8(body_bytes.into()).unwrap();
You can see modules were changed, high-level client was removed and BoxBody
also works here.
Reference
Their official documentation and examples are really helpful :)
Top comments (0)