version 0.1.0

src/server.rs

@@ -0,0 +1,102 @@
+use std::{
+    collections::HashMap,
+    io::{Read, Write},
+    net::TcpListener,
+    str::from_utf8,
+    sync::{Arc, Mutex},
+    thread,
+};
+
+use crate::{
+    http::{request::RequestLine, Request, Response},
+    Client,
+};
+
+pub struct Server {
+    listener: TcpListener,
+
+    on_request: Arc<Mutex<Option<Box<dyn Fn(Request) -> Response + Send + 'static>>>>,
+}
+
+impl Server {
+    pub fn new(ip: &str, port: i32) -> Self {
+        let addr = format!("{}:{}", ip, port);
+        let listener = TcpListener::bind(addr).unwrap();
+
+        Server {
+            listener,
+
+            on_request: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    pub fn run(&mut self) {
+        for stream in self.listener.incoming() {
+            let stream = stream.unwrap();
+
+            let on_request = Arc::clone(&self.on_request);
+
+            thread::spawn(move || {
+                let mut client = Client::new(stream);
+
+                let mut buffer = vec![0; 1024];
+                let bytes_read = client.read(&mut buffer).unwrap();
+
+                if bytes_read > 0 {
+                    if let Ok(request_str) = from_utf8(&buffer[..bytes_read]) {
+                        if let Some(on_request) = &*on_request.lock().unwrap() {
+                            let request;
+                            {
+                                let mut lines = request_str.lines();
+
+                                let request_line = RequestLine::from_str(lines.next().unwrap());
+
+                                let mut headers = HashMap::new();
+                                for line in lines {
+                                    if let Some((k, v)) = line.split_once(": ") {
+                                        headers.insert(k, v);
+                                    }
+                                }
+
+                                request = Request {
+                                    request_line,
+                                    headers,
+                                };
+                            }
+
+                            let response = on_request(request);
+                            {
+                                let response_line = response.response_line.to_string();
+                                client.write_string(response_line).unwrap();
+
+                                if let Some(headers) = response.headers {
+                                    for (k, v) in headers {
+                                        client.write_string(format!("{}: {}", k, v)).unwrap();
+                                    }
+                                } else {
+                                    client.write(b"\r\n").unwrap();
+                                }
+
+                                if let Some(content) = response.content {
+                                    client.write(b"\r\n").unwrap();
+                                    client.write(&content).unwrap();
+                                } else {
+                                    client.write(b"\r\n").unwrap();
+                                }
+                            }
+
+                            client.flush().unwrap();
+                        }
+                    }
+                }
+            });
+        }
+    }
+
+    pub fn on_request<F>(&mut self, f: F)
+    where
+        F: Fn(Request) -> Response + Send + 'static,
+    {
+        *self.on_request.lock().unwrap() = Some(Box::new(f))
+    }
+}