Add rate parameter to limit number of request being sent per second. Add help text to all commandline parameters

Author: kgantsov

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "hammerload"
-version = "0.1.0"
+version = "0.3.0"
 edition = "2021"
 
 [dependencies]

Cargo.toml

@@ -20,9 +20,18 @@ cargo build --release
 hammerload <PROTOCOL> --url <URL> [OPTIONS]
 ```
 
+Core load parameters
+```
+-d, --duration <SECONDS>           Duration of test in seconds
+-c, --concurrency <N>              Number of concurrent connections
+-r, --rate <N>                     Requests per second
+-t, --timeout <SECONDS>            Timeout in seconds
+```
+
 Request options
 ```
--X, --method <METHOD>              HTTP method (GET, POST…)
+-u, --url <URL>                    URL to send requests to
+-X, --method <METHOD>              HTTP method (GET, POST, PUT, PATCH, DELETE, ...)
 -H, --header <HEADER>              Custom headers (repeatable)
 -b, --body <STRING>                Request body
 -F, --form <KEY=VALUE>             Form fields (repeatable)

README.md

@@ -13,36 +13,68 @@ enum Protocol {
 #[derive(Parser, Debug)]
 #[command(
     author = "Your Name",
-    version = "1.0.0",
+    version = "0.3.0",
     about = "Hammerload - A load testing tool for HTTP protocols"
 )]
 struct Args {
     #[arg(value_name = "PROTOCOL")]
     protocol: Protocol,
 
-    #[arg(short = 'X', long, value_name = "METHOD", default_value = "GET")]
+    #[arg(
+        short = 'X',
+        long,
+        value_name = "METHOD",
+        default_value = "GET",
+        help = "HTTP method (GET, POST, PUT, PATCH, DELETE, ...)"
+    )]
     method: Method,
 
-    #[arg(short, long, value_name = "URL")]
+    #[arg(short, long, value_name = "URL", help = "URL to send requests to")]
     url: String,
 
-    #[arg(short, long, value_name = "BODY")]
+    #[arg(short, long, value_name = "BODY", help = "Request body")]
     body: Option<String>,
 
-    #[arg(short, long, value_name = "CONCURRENCY", default_value_t = 1)]
+    #[arg(short = 'H', long = "header", help = "Request header (repeatable)")]
+    headers: Vec<String>,
+
+    #[arg(short = 'F', long = "form", help = "Form parameters (repeatable)")]
+    form_params: Vec<String>,
+
+    #[arg(
+        short,
+        long,
+        value_name = "CONCURRENCY",
+        default_value_t = 1,
+        help = "Number of concurrent connections"
+    )]
     concurrency: u64,
 
-    #[arg(short, long, value_name = "DURATION", default_value_t = 10)]
+    #[arg(
+        short,
+        long,
+        value_name = "DURATION",
+        default_value_t = 10,
+        help = "Duration of test in seconds"
+    )]
     duration: u64,
 
-    #[arg(short = 'H', long = "header")]
-    headers: Vec<String>,
-
-    #[arg(short = 'F', long = "form")]
-    form_params: Vec<String>,
+    #[arg(
+        short,
+        long,
+        value_name = "RATE",
+        help = "Number of requests per second"
+    )]
+    rate: Option<u64>,
 
     // timeout
-    #[arg(short, long, value_name = "TIMEOUT", default_value_t = 5)]
+    #[arg(
+        short,
+        long,
+        value_name = "TIMEOUT",
+        default_value_t = 5,
+        help = "Request timeout in seconds"
+    )]
     timeout: u64,
 }
 
@@ -102,6 +134,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         header_map,
         args.concurrency,
         args.duration,
+        args.rate,
         args.timeout,
     );
 

src/main.rs

@@ -13,6 +13,7 @@ pub struct Scheduler<'a> {
     headers: HeaderMap,
     concurrency: u64,
     duration: u64,
+    rate: Option<u64>,
     timeout: u64,
 }
 
@@ -26,6 +27,7 @@ impl<'a> Scheduler<'a> {
         headers: HeaderMap,
         concurrency: u64,
         duration: u64,
+        rate: Option<u64>,
         timeout: u64,
     ) -> Self {
         Scheduler {
@@ -37,6 +39,7 @@ impl<'a> Scheduler<'a> {
             headers,
             concurrency,
             duration,
+            rate,
             timeout,
         }
     }
@@ -54,7 +57,9 @@ impl<'a> Scheduler<'a> {
             let body = self.body.clone();
             let form_params = self.form_params.clone();
             let headers = headers.clone();
+            let concurrency = self.concurrency;
             let duration = self.duration;
+            let rate = self.rate;
             let timeout = self.timeout;
             let metrics = Arc::clone(self.metrics);
 
@@ -67,7 +72,9 @@ impl<'a> Scheduler<'a> {
                     body,
                     form_params,
                     headers,
+                    concurrency,
                     duration,
+                    rate,
                     timeout,
                 )
                 .await;
@@ -113,7 +120,9 @@ impl<'a> Scheduler<'a> {
         body: Option<String>,
         form_params: HashMap<String, String>,
         headers: HeaderMap,
+        concurrency: u64,
         duration: u64,
+        rate: Option<u64>,
         timeout: u64,
     ) {
         let client = Client::builder()
@@ -122,14 +131,29 @@ impl<'a> Scheduler<'a> {
             .build()
             .unwrap();
 
+        let interval = rate.map(|rps| {
+            let per_worker = (rps as f64) / (concurrency as f64);
+            Duration::from_secs_f64(1.0 / per_worker)
+        });
+
         loop {
+            let loop_start = std::time::Instant::now();
+
             let result =
                 Self::make_request(metrics, &client, &method, &url, &body, &form_params).await;
             Self::handle_request_result(metrics, result).await;
 
             if std::time::Instant::now() >= start_bench + std::time::Duration::from_secs(duration) {
                 break;
             }
+
+            // Enforce rate limiting
+            if let Some(interval) = interval {
+                let elapsed = loop_start.elapsed();
+                if elapsed < interval {
+                    tokio::time::sleep(interval - elapsed).await;
+                }
+            }
         }
     }