Add load_generator and remove web handler

Author: yanorei32

README.md

@@ -1,5 +1,2 @@
 # Webhook Benchmark
  Brand-new Webhook benchmarker for EEWBot.
-
-> [!CAUTION]
-> This fork is not focus to performance!

src/load_generator.rs

@@ -0,0 +1,69 @@
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+use std::path::Path;
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::{Context as _, Result};
+use bytes::Bytes;
+use serde_json::json;
+
+use crate::request::{Context, JobSender, Request};
+
+#[derive(Debug, Clone)]
+pub struct Targets {
+    targets: Vec<url::Url>,
+}
+
+impl Targets {
+    pub fn try_new(path: &Path) -> Result<Self> {
+        let file = File::open(path)?;
+
+        let targets: Result<Vec<url::Url>> = BufReader::new(file)
+            .lines()
+            .map(|line| {
+                line.context("Failed to read line")
+                    .and_then(|line| line.parse().context("Failed to parse as URL"))
+            })
+            .map(|v| v)
+            .collect();
+
+        let targets = targets?;
+
+        Ok(Self { targets })
+    }
+}
+
+pub async fn run(targets: Targets, sender: JobSender, interval: &Duration, message: &str) {
+    let mut interval = tokio::time::interval(*interval);
+
+    let body = Bytes::from(
+        json!({
+            "content": message,
+        })
+        .to_string()
+        .into_bytes(),
+    );
+
+    let context = Arc::new(Context {
+        identity: format!("benchmark#benchmark"),
+        body,
+        retry_limit: 0,
+    });
+
+    loop {
+        for target in &targets.targets {
+            let _ = interval.tick().await;
+
+            sender
+                .send(Request {
+                    context: context.clone(),
+                    retry_count: 0,
+                    target: target.clone(),
+                    identity: format!("benchmark#benchmark#benchmark"),
+                })
+                .await
+                .unwrap();
+        }
+    }
+}

src/main.rs

@@ -1,18 +1,20 @@
-use std::net::{Ipv4Addr, SocketAddr};
+use std::net::Ipv4Addr;
 
 use clap::Parser;
+use std::path::PathBuf;
 
+use crate::load_generator::Targets;
 use crate::metrics::Metrics;
 
 mod conn;
 mod conn_initializer;
 mod discord;
 mod limiter;
+mod load_generator;
 mod metrics;
 mod namesgenerator;
 mod reporter;
 mod request;
-mod web;
 
 #[derive(Debug, Parser)]
 struct Cli {
@@ -31,14 +33,17 @@ struct Cli {
     #[clap(long, env)]
     report_in: url::Url,
 
-    #[clap(long, env)]
+    #[clap(long, env, default_value = "600s")]
     report_interval: humantime::Duration,
 
+    #[clap(long, env, default_value = "Hello World!")]
+    message: String,
+
     #[clap(long, env)]
-    auth_token: String,
+    targets: PathBuf,
 
-    #[clap(long, env, default_value = "0.0.0.0:3000")]
-    listen: SocketAddr,
+    #[clap(long, env, default_value = "100ms")]
+    send_interval: humantime::Duration,
 }
 
 #[tokio::main]
@@ -56,12 +61,14 @@ async fn main() {
         .with_max_level(tracing::Level::INFO)
         .init();
 
+    let targets = Targets::try_new(&cli.targets).unwrap();
+
     tokio::spawn({
         let metrics = metrics.clone();
         async move { reporter::run(&cli.report_interval, &cli.report_in, metrics).await }
     });
 
-    let (sender, limiter) = conn_initializer::initialize(
+    let (sender, _limiter) = conn_initializer::initialize(
         &cli.retry_ips,
         &cli.sender_ips,
         cli.multiplier,
@@ -71,7 +78,5 @@ async fn main() {
     .await
     .expect("failed to initialize connection");
 
-    web::run(cli.listen, sender, limiter, &cli.auth_token)
-        .await
-        .unwrap();
+    load_generator::run(targets, sender, &cli.send_interval, &cli.message).await;
 }

src/reporter.rs

@@ -54,7 +54,7 @@ pub async fn run(report_interval: &Duration, report_in: &url::Url, metrics: Metr
         .build()
         .unwrap();
 
-    tokio::time::sleep(Duration::from_secs(600)).await;
+    tokio::time::sleep(Duration::from_secs(60)).await;
 
     let mut interval = tokio::time::interval(*report_interval);