Note

You’ll find this example in the book’s repository in the ch10/b-rust-futures-experiments folder. The different experiments will be implemented as different versions of the async_main function numbered chronologically. I’ll indicate which function corresponds with which function in the repository example in the heading of the code snippet.

Before we start experimenting, let’s copy everything we have now to a new folder:

1. Create a new folder called b-rust-futures-experiments.
2. Copy everything from the a-rust-futures folder to the new folder.
3. Open Cargo.toml and change the name attribute to b-rust-futures-experiments.

The first experiment will be to exchange our very limited HTTP client with a proper one.

The easiest way to do that is to simply pick another production-quality HTTP client library that supports async Rust and use that instead.

So, when trying to find a suitable replacement for our HTTP client, we check the list of the most popular high-level HTTP client libraries and find reqwest at the top. That might work for our purposes, so let’s try that first.

The first thing we do is add reqwest as a dependency in Cargo.toml by typing the following:
cargo add [email protected]

Next, let’s change our async_main function so we use reqwest instead of our own HTTP client:

ch10/b-rust-futures-examples/src/main.rs (async_main2)
async fn async_main() {
    println!(“Program starting”);
    let url = “http://127.0.0.1:8080/600/HelloAsyncAwait
1
“;
    let res = reqwest::get(url).await.unwrap();
    let txt = res.text().await.unwrap();
    println!(“{txt}”);
    let url = “http://127.0.0.1:8080/400/HelloAsyncAwait
2
“;
    let res = reqwest::get(url).await.unwrap();
    let txt = res.text().await.unwrap();
    println!(“{txt}”);
}

Besides using the reqwest API, I also changed the message we send. Most HTTP clients don’t return the raw HTTP response to us and usually only provide a convenient way to get the body of the response, which up until now was similar for both our requests.

That should be all we need to change, so let’s try to run our program by writing cargo run:
     Running `target\debug\a-rust-futures.exe`
Program starting
thread ‘main’ panicked at C:\Users\cf\.cargo\registry\src\index.crates.io-6f17d22bba15001f\tokio-1.35.0\src\net\tcp\stream.rs:160:18:
there is no reactor running, must be called from the context of a Tokio 1.x runtime

Okay, so the error tells us that there is no reactor running and that it must be called from the context of a Tokio 1.x runtime. Well, we know there is a reactor running, just not the one reqwest expects, so let’s see how we can fix this.

We obviously need to add Tokio to our program, and since Tokio is heavily feature-gated (meaning that it has very few features enabled by default), we’ll make it easy on ourselves and enable all of them:
cargo add tokio@1 –features full

According to the documentation, we need to start a Tokio runtime and explicitly enter it to enable the reactor. The enter function will return EnterGuard to us that we can hold on to it as long as we need the reactor up and running.

Adding this to the top of our async_main function should work:

ch10/b-rust-futures-examples/src/main.rs (async_main2)
use tokio::runtime::Runtime;
async fn async_main
let rt = Runtime::new().unwrap();
let _guard = rt.enter();
    println!(“Program starting”);
    let url = “http://127.0.0.1:8080/600/HelloAsyncAwait1”;