From 5ed195f981ccda099926c1fe2a8603d110eb417c Mon Sep 17 00:00:00 2001
From: Andrew <saintruler@gmail.com>
Date: Sun, 14 Feb 2021 17:48:40 +0400
Subject: Added handling of some errors

---
 blog/src/main.rs          | 13 +++++++++----
 spider/src/http_server.rs | 37 ++++++++++++++++++++++---------------
 2 files changed, 31 insertions(+), 19 deletions(-)

diff --git a/blog/src/main.rs b/blog/src/main.rs
index c27bc4e..b0b8c71 100644
--- a/blog/src/main.rs
+++ b/blog/src/main.rs
@@ -24,8 +24,13 @@ impl MyHandler {
 fn main() {
     let handler = MyHandler::new();
     let server = HttpServer::new("localhost", 3000, handler);
-    match server {
-        Some(serv) => serv.serve_forever(),
-        None => println!("Couldn't start server.")
-    }
+
+    let result = match server {
+        Ok(ref serv) => serv.serve_forever(),
+        Err(msg) => Err(msg)
+    };
+    match result {
+        Ok(_) => println!("Server exited succesfully"),
+        Err(msg) => println!("{}", msg)
+    };
 }
diff --git a/spider/src/http_server.rs b/spider/src/http_server.rs
index 675a25a..fc740d6 100644
--- a/spider/src/http_server.rs
+++ b/spider/src/http_server.rs
@@ -20,8 +20,8 @@ pub struct HttpServer<T: HttpHandler> {
 }
 
 impl<T> HttpServer<T> where T: HttpHandler {
-    // TODO(andrew): Add more verbose error handling.
-    pub fn new(host: &str, port: u16, handler: T) -> Option<HttpServer<T>> {
+    // TODO(andrew): add explanations for errors?
+    pub fn new(host: &str, port: u16, handler: T) -> Result<HttpServer<T>, &str> {
         let addr = format!("{}:{}", host, port);
         let sock = TcpListener::bind(addr);
         match sock {
@@ -32,37 +32,42 @@ impl<T> HttpServer<T> where T: HttpHandler {
                     socket: s,
                     handler: handler,
                 };
-                return Some(server);
+                return Ok(server);
             },
-            Err(_) => return None
-        }
+            Err(_) => return Err("Couldn't start server")
+        };
     }
 
-    pub fn serve_forever(&self) {
+    pub fn serve_forever(&self) -> Result<(), &str> {
         for stream in self.socket.incoming() {
             match stream {
                 Ok(s) => {
+                    // TODO(andrew): replace println with logging.
                     println!("Got connection!");
-                    self.handle_client(&s);
-                    // TODO(andrew): handle possible errors.
-                    s.shutdown(Shutdown::Both);
-                    println!("Connection hadled");
+                    match self.handle_client(&s) {
+                        Ok(_) => (),
+                        Err(msg) => return Err(msg)
+                    };
+                    match s.shutdown(Shutdown::Both) {
+                        Ok(_) => println!("Closed connection"),
+                        Err(_) => return Err("Couldn't close client socket")
+                    };
                 },
                 Err(_) => break
             };
         }
+        return Ok(());
     }
 
-    fn handle_client(&self, mut stream: &TcpStream) {
+    fn handle_client(&self, mut stream: &TcpStream) -> Result<(), &str> {
         let mut buf: [u8; 1024] = [0; 1024];
         // TODO(andrew): read all body, not first 1024 bytes.
         stream.peek(&mut buf).expect("Couldn't read from socket");
 
         let request = Request::from(&buf);
-        // TODO(andrew): remove panic.
         let request = match request {
             Some(r) => r,
-            None => panic!("Request parsed with errors")
+            None => return Err("Request parsed with errors")
         };
 
         // TODO(andrew): add more methods.
@@ -71,7 +76,9 @@ impl<T> HttpServer<T> where T: HttpHandler {
             HttpMethod::POST => self.handler.do_post(request)
         };
         let response = response.format();
-        // TODO(andrew): handle possible errors.
-        stream.write(&response);
+        match stream.write(&response) {
+            Ok(_) => return Ok(()),
+            Err(_) => return Err("Couldn't write to client socket")
+        };
     }
 }
-- 
cgit v1.2.3