rewrite

src/main.rs

@@ -1,68 +1,44 @@
-pub mod assets;
-pub mod io;
+use std::{
+    io::{BufRead, BufReader, Write},
+    net::TcpListener,
+    sync::Arc,
+};
+
+pub mod database;
 pub mod methods;
 pub mod parser;
-
-use std::io::{Read, Write};
-use std::net::{TcpListener, TcpStream};
-use std::sync::Arc;
-use std::thread;
-
-use io::Database;
-use methods::handle_request;
-use mongodb::sync::Client;
-
-const MONGO_URI: &str = "mongodb://admin:admin@localhost/";
+pub mod response;
 
 fn main() -> std::io::Result<()> {
-    let client = Client::with_uri_str(MONGO_URI).unwrap();
-    let database = Arc::new(Database::new(&client));
-    let listener = TcpListener::bind("127.0.0.1:8080")?;
+    let client = mongodb::sync::Client::with_uri_str("mongodb://admin:admin@localhost/").unwrap();
+    let database = Arc::new(database::Database::new(&client));
 
-    println!("Server listening on port 8080");
+    let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
 
     for stream in listener.incoming() {
-        match stream {
-            Ok(stream) => {
-                println!("New connection: {}", stream.peer_addr().unwrap());
-                thread::spawn({
-                    let database = Arc::clone(&database);
-                    move || handle_client(stream, database)
-                });
+        println!("New connection");
+        let database = Arc::clone(&database);
+
+        std::thread::spawn({
+            move || {
+                let mut stream = stream.unwrap();
+                let mut reader = BufReader::new(stream.try_clone().unwrap());
+                let session = methods::Session::new(&mut reader, database).unwrap();
+
+                loop {
+                    let mut request_string = String::new();
+                    match reader.read_line(&mut request_string).unwrap() {
+                        0 => break,
+                        _ => {
+                            let (method, params) = parser::parse(&request_string).unwrap();
+                            let response = session.handle_request(&method, &params);
+                            stream.write_all(response.to_string().as_bytes()).unwrap();
+                        }
+                    };
+                }
             }
-            Err(e) => eprintln!("Connection failed: {}", e),
-        }
+        });
     }
 
     Ok(())
 }
-
-pub fn handle_client(mut stream: TcpStream, database: Arc<Database>) {
-    let mut buffer = [0; 512];
-
-    loop {
-        match stream.read(&mut buffer) {
-            Ok(0) => break,
-            Ok(n) => {
-                let recv = String::from_utf8_lossy(&buffer[..n]).to_string();
-                match parser::parse(&recv) {
-                    Ok((method, params)) => {
-                        match handle_request(Arc::clone(&database), method, params) {
-                            Ok(response) => {
-                                stream.write_all(response.to_string().as_bytes()).unwrap()
-                            }
-                            Err(e) => eprintln!("Error handling request: {}", e),
-                        }
-                    }
-                    Err(e) => eprintln!("Error parsing request: {}", e),
-                };
-            }
-            Err(e) => {
-                eprintln!("Error reading from client: {}", e);
-                break;
-            }
-        }
-    }
-
-    println!("Client disconnected");
-}