Posibility to specify method of the request

Author: kgantsov

src/main.rs

@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use clap::{Parser, ValueEnum};
 use hammerload::{metrics::metrics::Metrics, scheduler::scheduler::Scheduler};
+use reqwest::Method;
 
 #[derive(ValueEnum, Debug, Clone)]
 enum Protocol {
@@ -18,6 +19,9 @@ struct Args {
     #[arg(value_name = "PROTOCOL")]
     protocol: Protocol,
 
+    #[arg(short, long, value_name = "METHOD", default_value = "GET")]
+    method: Method,
+
     #[arg(short, long, value_name = "URL")]
     url: String,
 
@@ -69,6 +73,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 
     let scheduler = Scheduler::new(
         &metrics,
+        args.method,
         args.url,
         args.concurrency,
         args.duration,

src/scheduler/scheduler.rs

@@ -1,11 +1,12 @@
 use std::sync::Arc;
 
-use reqwest::{header::HeaderMap, Client};
+use reqwest::{header::HeaderMap, Client, Method};
 
 use crate::metrics::metrics::Metrics;
 
 pub struct Scheduler<'a> {
     metrics: &'a Arc<Metrics>,
+    method: Method,
     url: String,
     concurrency: u64,
     duration: u64,
@@ -15,13 +16,15 @@ pub struct Scheduler<'a> {
 impl<'a> Scheduler<'a> {
     pub fn new(
         metrics: &'a Arc<Metrics>,
+        method: Method,
         url: String,
         concurrency: u64,
         duration: u64,
         headers: HeaderMap,
     ) -> Self {
         Scheduler {
             metrics,
+            method,
             url,
             concurrency,
             duration,
@@ -37,13 +40,14 @@ impl<'a> Scheduler<'a> {
         let headers = self.headers.clone();
 
         for _ in 0..self.concurrency {
+            let method = self.method.clone();
             let url = url.clone();
             let headers = headers.clone();
             let duration = self.duration;
             let metrics = Arc::clone(self.metrics);
 
             tasks.push(tokio::spawn(async move {
-                Scheduler::run_client(&metrics, start_bench, url, duration, headers).await;
+                Scheduler::run_client(&metrics, start_bench, method, url, duration, headers).await;
             }));
         }
 
@@ -81,14 +85,15 @@ impl<'a> Scheduler<'a> {
     async fn run_client(
         metrics: &'a Arc<Metrics>,
         start_bench: std::time::Instant,
+        method: Method,
         url: String,
         duration: u64,
         headers: HeaderMap,
     ) {
         let client = Client::builder().default_headers(headers).build().unwrap();
 
         loop {
-            let result = Self::make_request(metrics, &client, &url).await;
+            let result = Self::make_request(metrics, &client, &method, &url).await;
             Self::handle_request_result(metrics, result).await;
 
             if std::time::Instant::now() >= start_bench + std::time::Duration::from_secs(duration) {
@@ -100,11 +105,12 @@ impl<'a> Scheduler<'a> {
     async fn make_request(
         metrics: &Arc<Metrics>,
         client: &Client,
+        method: &Method,
         url: &str,
     ) -> Result<String, reqwest::Error> {
         let start = std::time::Instant::now();
 
-        let resp = client.get(url).send().await?;
+        let resp = client.request(method.clone(), url).send().await?;
         let _status = resp.status();
         let body = resp.text().await?;