DEV Community

Carlos Armando Marcano Vargas
Carlos Armando Marcano Vargas

Posted on • Originally published at carlosmv.hashnode.dev on

Building a HTTP Client with Reqwest | Rust

#rust #http #client #reqwest

In this article, we are going to build a basic HTTP client with Reqwest to test REST APIs

This program will have just basic functionalities, like showing the body and the status code from GET, and POST requests.

Also, we will add a feature that allows the program to read the URL from a text file. And to read the URL and the HTTP method we want to execute from a TOML file.

Requirements

  • Rust installed

  • A REST API to test the HTTP client.

cargo.toml

[dependencies]
tokio = { version = "1.15", features = ["full"] }
reqwest = { version = "0.11.22", features = ["json"] }
Enter fullscreen mode Exit fullscreen mode

main.rs

//main.rs
use reqwest::Error;

async fn get_request() -> Result<(), Error> {
    let response = reqwest::get("https://www.fruityvice.com/api/fruit/apple").await?;
    println!("Status: {}", response.status());

    let body = response.text().await?;
    println!("Body:\n{}", body);

    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    get_request().await?;
    Ok(())
}
Enter fullscreen mode Exit fullscreen mode

In the above, we create the get_resquest() function to make a GET request and show in the console the status code of the response and its body.

Then we call the get_request() function in the main() function to make the request when the program runs.

POST requests

//main.rs
async fn post_request() -> Result<(), Error> {
    let url = "http://localhost:4000/tasks";
    let json_data = r#"{"title":"Problems during installation","status":"todo","priority":"medium","label":"bug"}"#;

    let client = reqwest::Client::new();

    let response = client
        .post(url)
        .header("Content-Type", "application/json")
        .body(json_data.to_owned())
        .send()
        .await?;

    println!("Status Code: {}", response.status());

    let response_body = response.text().await?;

    println!("Response body: \n{}", response_body);

    Ok(())

}

#[tokio::main]
async fn main() -> Result<(), Error> {
  ...

    post_request().await?;
    Ok(())
}
Enter fullscreen mode Exit fullscreen mode

Here we create the post_request() function, to make a POST request to an API. Inside the post_request() function we defined the URL and JSON data we want to add to the server. When this function is called, it will print in the console the status code and the body of the response.

Then we call the post_request() function in the main() function and run the cargo run command in the console.

PUT Request

//main.rs
async fn put_request() -> Result<(), Error> {
    let url = "http://localhost:4000/tasks/7";
    let json_data = r#"{"title":"Problems during installation","status":"todo","priority":"low","label":"bug"}"#;

    let client = reqwest::Client::new();

    let response = client
        .put(url)
        .header("Content-Type", "application/json")
        .body(json_data.to_owned())
        .send()
        .await?;

    println!("Status code: {}", response.status());

    let response_body = response.text().await?;

    println!("Response body: \n{}", response_body);

    Ok(())
}
Enter fullscreen mode Exit fullscreen mode

Here we create the put_request() function, to make a PUT request to an API. Inside the put_request() function we defined the URL and JSON data we want to update to the server. When this function is called, it will print in the console the status code and the body of the response.

Then, we add the put_request() function to the main() function and run the program.

Make sure to delete the post_request() function from the main() function, so the program does not call it when it runs.

DELETE Request

//main.rs
async fn delete_request() -> Result<(), Error> {
    let url = "http://localhost:4000/tasks/5";

    let client = reqwest::Client::new();

    let response = client
        .delete(url)
        .send()
        .await?;

    println!("Status code: {}", response.status());

    let response_body = response.text().await?;

    println!("Response body: \n{}", response_body);

    Ok(())
}
Enter fullscreen mode Exit fullscreen mode

Here we create the delete_request() function, to make a DELETE request to an API. Inside the delete_request() function we defined the URL with the parameter of the row we want to delete. When this function is called, it will print in the console the status code and the body of the response.

Then we call the delete_request() function in the main() function and run the cargo run command in the console.

//main.rs
#[tokio::main]
async fn main() -> Result<(), Error> {
    let file_path = "./urls.txt";
    let url_vector = read_file_lines_to_vec(&file_path.to_string());

    println!("{:?}", url_vector);

    delete_request().await?;
    Ok(())
}
Enter fullscreen mode Exit fullscreen mode

Complete code

//main.rs
use reqwest::Error;
mod helpers;
use helpers::{read_file_lines_to_vec};

async fn get_request() -> Result<(), Error> {

    let file_path = "./urls.txt";
    let url_vector = read_file_lines_to_vec(&file_path.to_string());
    match &url_vector {
        // If the operation was successful, make requests to urls in the file.
        Ok(file_contents) => {
            for url in file_contents {
                let response = reqwest::get(url).await?;
                println!("Status code: {}", response.status());

                let body = response.text().await?;
                println!("Response body:\n{}", body);
            }
        }

        // If the operation failed, print the error message to the console.
        Err(error) => {
            println!("Error reading file: {}", error);
        }
    }
    Ok(())

}

async fn post_request() -> Result<(), Error> {
    let url = "http://localhost:4000/tasks";
    let json_data = r#"{"title":"Problems during installation","status":"todo","priority":"medium","label":"bug"}"#;

    let client = reqwest::Client::new();

    let response = client
        .post(url)
        .header("Content-Type", "application/json")
        .body(json_data.to_owned())
        .send()
        .await?;

    println!("Status code: {}", response.status());

    let response_body = response.text().await?;

    println!("Response body: \n{}", response_body);

    Ok(())

}

async fn put_request() -> Result<(), Error> {
    let url = "http://localhost:4000/tasks/7";
    let json_data = r#"{"title":"Problems during installation","status":"todo","priority":"low","label":"bug"}"#;

    let client = reqwest::Client::new();

    let response = client
        .put(url)
        .header("Content-Type", "application/json")
        .body(json_data.to_owned())
        .send()
        .await?;

    println!("Status code: {}", response.status());

    let response_body = response.text().await?;

    println!("Response body: \n{}", response_body);

    Ok(())
}

async fn delete_request() -> Result<(), Error> {
    let url = "http://localhost:4000/tasks/5";

    let client = reqwest::Client::new();

    let response = client
        .delete(url)
        .send()
        .await?;

    println!("Status code: {}", response.status());

    let response_body = response.text().await?;

    println!("Response body: \n{}", response_body);

    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    let file_path = "./urls.txt";
    let url_vector = read_file_lines_to_vec(&file_path.to_string());

    println!("{:?}", url_vector);

    delete_request().await?;
    Ok(())
}
Enter fullscreen mode Exit fullscreen mode

Using just a text file will make this program difficult to use. The .txt file for just making a GET request to multiple URLs will be fine. But what if we want to use the other HTTP methods?

So, we are going to add another feature, to read a config file where we write the URLs we want to make the requests and the HTTP methods we want to use.

Adding Config file

As a config file, we are going to use a TOML file. To parse this file we have to add a TOML parser and Serde to the project's dependencies.

cargo.toml

...
serde = {version = "1.0", features = ["derive"]}
toml = "0.8.2"
Enter fullscreen mode Exit fullscreen mode

Now, we create a config.toml file in the project's root directory.

config.toml

[config]
url = "http://localhost:4000/tasks/8"
method = "DELETE"
Enter fullscreen mode Exit fullscreen mode

main.rs

Here we have to create the struct of the data we want to deserialize from the TOML file.

use serde::Deserialize;
use std::fs;
use serde_json::Value;

#[derive(Deserialize)]
struct Data {
   config: Config,
}
#[derive(Deserialize)]
struct Config {
    url: String,
    method: String,
}
Enter fullscreen mode Exit fullscreen mode

I going to comment on the code that opens the .txt file in the main() function. And write the code that opens the .toml file.

//main.rs
#[tokio::main]
async fn main()-> Result<(), Error> {
    //let file_path = "./urls.txt";
   // let url_vector = read_file_lines_to_vec(&file_path.to_string());

  ...  
    let filename = "config.toml";

    let contents = match fs::read_to_string(filename) {

        Ok(c) => c,

        Err(error) => {
            (&error).to_string()     
        }
    };
Enter fullscreen mode Exit fullscreen mode

Now, we parse the content of the TOML file.

let data: Data = match toml::from_str(&contents) {
        Ok(d) => d,

        Err(error) => {

            eprintln!("Unable to load data because `{}`", error);

            std::process::exit(1);
        }
    };
Enter fullscreen mode Exit fullscreen mode

For POST requests and PUT requests, we need to send JSON data.

Something I figured out was to use a JSON parser and extract the body from a JSON file.

For this, we have to add serde_json as a dependency

serde_json = "1.0"
Enter fullscreen mode Exit fullscreen mode

In the main function, we write the code to open and parse the JSON file.

#[tokio::main]
async fn main()-> Result<(), Error> {
   ...

    let body = {
        let file_content = fs::read_to_string("./body.json").expect("Error reading file");
        serde_json::from_str::<Value>(&file_content).expect("Error serializing to JSON")
    };

 Ok(())

}
Enter fullscreen mode Exit fullscreen mode

Finally, we add the control flow.

//main.rs
#[tokio::main]
async fn main()-> Result<(), Error> {
    ...

    if data.config.method == "DELETE" {
        delete_request(data.config.url).await;
    } else if data.config.method == "POST" {
        post_request(data.config.url, body.to_string()).await;

    } else if data.config.method == "PUT" {
       put_request(data.config.url, body.to_string()).await;
    } else {

        get_request(data.config.url).await;
    }

    Ok(())

}
Enter fullscreen mode Exit fullscreen mode

Now, we create the http_method.rs file and move all the functions related to the HTTP requests to this new file.

Then, create a function with the control flow in the main.rs file.

//main.rs
async fn method_control(http_method: &str, url: String, body: String
) -> Result<(), reqwest::Error> {

    match http_method {
        "POST" => post_request(url, body).await,
        "PUT" => put_request(url, body).await,
        "DELETE" => delete_request(url).await,
        _ => get_request(url).await,

    }
}
Enter fullscreen mode Exit fullscreen mode

Now, let's try our HTTP client.

Write the URL and the HTTP method in the config.toml file.

Define the body you want to send to the API.

Then run the cargo run command in the console.

Complete the http_method.rs file.

use reqwest::Error;

pub async fn get_request(url: String) -> Result<(), Error> {

    let response = reqwest::get(url).await?;
    println!("Status code: {}", response.status());

    let body = response.text().await?;
    println!("Response body:\n{}", body);
    Ok(())

}

pub async fn post_request(url: String, json_data: String) -> Result<(), Error> {

    let client = reqwest::Client::new();

    let response = client
        .post(url)
        .header("Content-Type", "application/json")
        .body(json_data.to_owned())
        .send()
        .await?;

    println!("Status code: {}", response.status());

    let response_body = response.text().await?;

    println!("Response body: \n{}", response_body);

    Ok(())

}

pub async fn put_request(url: String, json_data: String) -> Result<(), Error> {

    let client = reqwest::Client::new();

    let response = client
        .put(url)
        .header("Content-Type", "application/json")
        .body(json_data.to_owned())
        .send()
        .await?;

    println!("Status code: {}", response.status());

    let response_body = response.text().await?;

    println!("Response body: \n{}", response_body);

    Ok(())
}

pub async fn delete_request(url: String) -> Result<(), Error> {

    let client = reqwest::Client::new();

    let response = client
        .delete(url)
        .send()
        .await?;

    println!("Status code: {}", response.status());

    let response_body = response.text().await?;

    println!("Response body: \n{}", response_body);

    Ok(())
}
Enter fullscreen mode Exit fullscreen mode

Complete main.rs file.

use serde::Deserialize;
use std::fs;
use serde_json::Value;

mod http_methods;
use http_methods::{get_request, post_request, put_request, delete_request};

#[derive(Deserialize)]
struct Data {
   config: Config,
}
#[derive(Deserialize)]
struct Config {
    url: String,
    method: String,
}

#[tokio::main]
async fn main()-> Result<(), Error> {

    let filename = "config.toml";

    let contents = match fs::read_to_string(filename) {      
        Ok(c) => c,   
        Err(error) => {
            (&error).to_string()       
        }
    };

    let data: Data = match toml::from_str(&contents) {    
        Ok(d) => d,
        Err(error) => {   
            eprintln!("Unable to load data because `{}`", error);
            std::process::exit(1);
        }
    };

    let body = {
        let file_content = fs::read_to_string("./body.json").expect("Error reading file");
        serde_json::from_str::<Value>(&file_content).expect("Error serializing to JSON")
    };

    let result = method_flow(&data.config.method, data.config.url, body.to_string()).await;

    match result {
        Ok(contents) => contents,
        Err(e) => println!("Error during the request: {}", e),
    }
    Ok(())

}

async fn method_control(http_method: &str, url: String, body: String) -> Result<(), reqwest::Error> {

    match http_method {
        "POST" => post_request(url, body).await,
        "PUT" => put_request(url, body).await,
        "DELETE" => delete_request(url).await,
        _ => get_request(url).await,
    }
}
Enter fullscreen mode Exit fullscreen mode

Conclusion

In this article, we learn how to use the Reqwest crate to make HTTP requests. And also we built a HTTP client to take its input from a text file and a configuration file.

I built this program just for learning purposes and learn how to use the Reqwest crate. But I want it to build something different than just a program that makes GET requests.

The source code is here.

Thank you for taking the time to read this article.

If you have any recommendations about other packages, architectures, how to improve my code, my English, or anything; please leave a comment or contact me through Twitter, or LinkedIn.

Resources

Reqwest documentation

Making HTTP Requests in Rust With Reqwest

Making HTTP requests in Rust with Reqwest

How to Work With TOML Files in Rust

Rust Load a TOML File

Top comments (1)

Collapse
 
stacy-roll profile image
Stacy Roll • • Edited

Hi Carlos I see code without rust color, you can do ` rust (with ` consecutive). Great article!

Read next

andrewchaa profile image

Mocking ES6 Class Instances with Jest

Andrew Chaa -

jigar_online profile image

Native vs Cross-Platform: The Best Approach for Mobile App Development

Jigar Shah -

willemturkstra profile image

Simple DX improvement in PHPStorm

Willem Turkstra -

attaelahi profile image

Becoming a Figma Pro: Mastering the Leading Design Tool

Atta Elahi -