Connection pool

Cargo.toml

@@ -21,3 +21,5 @@ rand = "0.8.5"
 clap = { version = "4.5.16", features = ["derive"] }
 uuid = { version = "1.10.0", features = ["v4", "fast-rng"] }
 thiserror = "1.0.64"
+axum = "0.7.7"
+bytes = "1.8.0"

ekilibri.toml

@@ -10,3 +10,4 @@ connection_timeout = 1000
 write_timeout = 1000
 read_timeout = 1000
 health_check_path = "/health"
+pool_size = 10

src/bin/command.rs

@@ -1,17 +1,15 @@
 use std::time::Duration;
 
-use clap::Parser;
-use tokio::{
-    io::AsyncWriteExt,
-    net::{TcpListener, TcpStream},
-    time,
+use axum::{
+    body::Bytes,
+    http::{header, HeaderMap, StatusCode},
+    routing::{get, post},
+    Router,
 };
+use clap::Parser;
+use tokio::{net::TcpListener, time};
 
-use tracing::{debug, info, warn};
-
-use uuid::Uuid;
-
-use ekilibri::http::{parse_request, Method, ParsingError, CRLF};
+use tracing::info;
 
 #[derive(Debug, Parser)]
 struct Args {
@@ -25,6 +23,12 @@ async fn main() {
 
     let args = Args::parse();
     let port = args.port;
+
+    let app = Router::new()
+        .route("/health", get(health))
+        .route("/sleep", get(sleep))
+        .route("/echo", post(echo));
+
     let listener = match TcpListener::bind(format!("127.0.0.1:{port}")).await {
         Ok(listener) => listener,
         Err(e) => panic!(
@@ -33,84 +37,30 @@ async fn main() {
         ),
     };
 
-    loop {
-        accept_and_handle_connection(&listener).await;
-    }
+    axum::serve(listener, app).await.unwrap();
 }
 
-async fn accept_and_handle_connection(listener: &TcpListener) {
-    match listener.accept().await {
-        Ok((stream, _)) => {
-            tokio::spawn(async move {
-                process_request(stream).await;
-            });
-        }
-        Err(_) => eprintln!("Error listening to socket"),
-    }
+async fn health() -> StatusCode {
+    info!("Received request for /health");
+    StatusCode::OK
 }
 
-async fn process_request(mut stream: TcpStream) {
-    let request_id = Uuid::new_v4();
-    let request = match parse_request(&request_id, &mut stream).await {
-        Ok((request, _)) => request,
-        Err(e) => {
-            let status = match e {
-                ParsingError::MissingContentLength => "411",
-                ParsingError::HTTPVersionNotSupported => "505",
-                _ => "400",
-            };
-            let response = format!("HTTP/1.1 {status}{CRLF}{CRLF}");
-            if let Err(e) = stream.write_all(response.as_bytes()).await {
-                debug!("Unable to send response to the client {e}");
-            }
-            return;
-        }
-    };
+async fn sleep() -> StatusCode {
+    info!("Received request for /sleep");
+    time::sleep(Duration::from_millis(2000)).await;
+    StatusCode::OK
+}
 
-    let response = match request.method {
-        Method::Get => match request.path.as_str() {
-            "/sleep" => {
-                info!("Received request for /sleep, request_id={request_id}");
-                time::sleep(Duration::from_millis(2000)).await;
-                format!("HTTP/1.1 200{CRLF}{CRLF}")
-            }
-            "/health" => {
-                info!("Received request for /health, request_id={request_id}");
-                format!("HTTP/1.1 200{CRLF}{CRLF}")
-            }
-            _ => {
-                info!("Received request for unmapped path, request_id={request_id}");
-                format!("HTTP/1.1 404{CRLF}{CRLF}")
-            }
-        },
-        Method::Post => match request.path.as_str() {
-            "/echo" => {
-                info!("Received request for /echo, request_id={request_id}");
-                let length = match request.headers.get("content-length") {
-                    Some(value) => value,
-                    None => "0",
-                };
-                let content_length = format!("Content-Length: {length}");
-                let content_type = match request.headers.get("content-type") {
-                    Some(value) => value,
-                    None => "text/plain",
-                };
-                let content_type = format!("Content-Type: {content_type}");
-                let body = request.body.unwrap_or_default();
-                format!("HTTP/1.1 200{CRLF}{content_length}{CRLF}{content_type}{CRLF}{CRLF}{body}")
-            }
-            _ => {
-                info!("Received request for unmapped path, request_id={request_id}");
-                format!("HTTP/1.1 404{CRLF}{CRLF}")
-            }
-        },
-        Method::Unknown => {
-            warn!("Received request for unmapped path, request_id={request_id}");
-            format!("HTTP/1.1 404{CRLF}{CRLF}")
-        }
+async fn echo(headers: HeaderMap, body: Bytes) -> Result<(HeaderMap, String), StatusCode> {
+    info!("Received request for /echo");
+    let content_type = match headers.get("content-type") {
+        Some(value) => value.to_str().unwrap(),
+        None => "text/plain",
     };
-
-    if let Err(e) = stream.write_all(response.as_bytes()).await {
-        debug!("Unable to send response to the client {e}");
+    let mut headers = HeaderMap::new();
+    headers.insert(header::CONTENT_TYPE, content_type.parse().unwrap());
+    match String::from_utf8(body.to_vec()) {
+        Ok(body) => Ok((headers, body)),
+        Err(_) => Err(StatusCode::BAD_REQUEST),
     }
 }