Hyperium | Hyperium , Free Minecraft client with HUDs and Popular mods | Video Game library

It is not obvious but if you specify the local_address option, the connection will use that ip address to send the request.

I use Reqwest (v0.11.1 in the example) now.

The option is #[cfg(test)] (singular), not #[cfg(tests)] (plural). This is probably not failing because it's not being compiled or run at all, since the option is never set.

Invalidating caches and restarting in IntelliJ fixed it.

(Note to self: stop using EAP.)

Thank you Omer Erden for answering this. So it came down to implementing AsyncRead based on the futures::Stream trait, which tonic::Streaming implements. Here is the code I actually used.

The tokio::main macro converts an async main to a regular main that spawns a runtime. However, because the macro is not found is scope, it cannot transform your main function, and the compiler is complaining that your main has an invalid return type of impl Future. To fix this, you have to enable the required features to import the main macro:

.then() is used for chaining two futures together. It returns a Then, which is a Future that does the work of: polling the first future, processing the result with given function, and polling the resulting future.

The Either type is designed to combine two different futures having the same associated output into a single type. Say you were making a function that will return two different futures depending on the input:

From the Tonic documentation:

Sending a request on a channel requires a &mut self and thus can only send one request in flight. This is intentional and is required to follow the Service contract from the tower library which this channel implementation is built on top of.
...
To work around this and to ease the use of the channel, Channel provides a Clone implementation that is cheap. This is because at the very top level the channel is backed by a tower_buffer::Buffer which runs the connection in a background task and provides a mpsc channel interface. Due to this cloning the Channel type is cheap and encouraged.

Therefore, you can clone the client for each concurrent request you make. This eliminates the possibility of a single client being mutably borrowed more than once at any given time, so the borrow checker is appeased.

The hyper crate depends on http, so it means the dependency in cargo can't be shared to my project? But I see the http 0.2.3 in Clion's External Libraries list. In a Java project built by Maven, the dependency can be shared from jar to my project, So I can use it directly.

That's correct. You can only use declared direct dependencies: indirect dependencies can't be assumed to be part of the direct dependency's API, so they could be removed in any minor update, breaking semver guarantees.

However there are cases where the direct dependency will re-export part of its own dependency (or even the underlying dependency in its entirety), as "E_net4 with 20k" links that seems to be the case for hyper which re-exports parts of http. If what Hyper re-exports does not suffice for your use case, then yes you will have to add an explicit dependency on http to access what you need beyond that.

Quoting https://doc.rust-lang.org/reference/trait-bounds.html#higher-ranked-trait-bounds:

Bounds on an item must be satisfied when using the item. When type checking and borrow checking a generic item, the bounds can be used to determine that a trait is implemented for a type. For example, given Ty: Trait

In the body of a generic function, methods from Trait can be called on Ty values. Likewise associated constants on the Trait can be used. Associated types from Trait can be used. Generic functions and types with a T: Trait bounds can be used with Ty being used for T.

Nothing states that Ty is a type parameter (and not a fixed type). So I would say it is simply a trait bound, albeit admittedly not very often encountered in Rust tutorials.