so78124765

Cargo.toml

[package]
name = "so78124765"
version = "0.1.0"
edition = "2021"

[dependencies]
reqwest = { version = "0.11.24", features = ["json"] }
serde_json = "1.0.114"
tokio = { version = "1.36.0", features = ["net", "io-util", "rt-multi-thread", "macros"] }

main.rs

mod server;

use reqwest::Client;
use serde_json::json;
use server::Server;
use tokio::task::JoinSet;

#[tokio::main]
async fn main() {
    if std::env::args().nth(1).as_deref() == Some("s") {
        let server = Server::new("localhost:8080".to_owned());
        server.run().await;
    }

    let client = Client::new();

    let send_req = |client: Client| async move {
        client
            .post("http://127.0.0.1:8080/api/create/user")
            .json(&json!({
                "name": "John",
                "age": 30
            }))
            .send()
            .await?
            .text()
            .await
    };

    let mut set = JoinSet::new();
    for _ in 0..256 {
        set.spawn(send_req(client.clone()));
    }

    while let Some(x) = set.join_next().await {
        println!("{x:?}")
    }
}

server.rs

use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;

pub struct Server {
    address: String,
}

impl Server {
    pub fn new(address: String) -> Self {
        Server { address }
    }

    pub async fn run(self) {
        let listener = TcpListener::bind(&self.address)
            .await
            .expect("Failed to bind");
        println!("Server listening on {}", self.address);

        loop {
            let (mut stream, _) = match listener.accept().await {
                Ok(connection) => connection,
                Err(e) => {
                    eprintln!("Connection failed: {}", e);
                    continue;
                }
            };

            tokio::spawn(async move {
                let mut buffer = Vec::new();
                let mut read_buffer = [0; 1024];
                let mut headers_ended = false;

                while let Ok(n) = stream.read(&mut read_buffer).await {
                    if n == 0 {
                        break;
                    }
                    buffer.extend_from_slice(&read_buffer[..n]);

                    // Check if we've encountered the end of the headers section
                    if buffer.windows(4).any(|window| window == b"\r\n\r\n") {
                        headers_ended = true;
                        break;
                    }
                }

                if !headers_ended {
                    eprintln!("Failed to read the complete headers.");
                    return;
                }

                // let request_str = String::from_utf8_lossy(&buffer);

                // Split the request string into headers and body parts
                // let mut parts = request_str.split("\r\n\r\n");
                // let headers_part = parts.next().unwrap_or_default();
                // let body_part = parts.next().unwrap_or_default();

                // let request = Request::new(headers_part.to_string(), body_part.to_string());
                // let response = router.handle(request).await;

                let _ = stream.write(b"HTTP/1.1 200\r\n\r\nHello").await;
                let _ = stream.flush().await;
                let _ = stream.shutdown().await;
            });
        }
    }
}