From 3b6b1e8398f8a9ae552f82c8aeb614a55c1ef4b4 Mon Sep 17 00:00:00 2001
From: Bastian Gruber <foreach@me.com>
Date: Thu, 20 Apr 2023 18:44:22 +0000
Subject: [PATCH] Debugging

---
 problem_01/src/main.rs | 142 ++++++++++++++++++++++-------------------
 1 file changed, 78 insertions(+), 64 deletions(-)

diff --git a/problem_01/src/main.rs b/problem_01/src/main.rs
index 7f83c99..08e28b9 100644
--- a/problem_01/src/main.rs
+++ b/problem_01/src/main.rs
@@ -41,74 +41,88 @@ async fn handle_request(mut socket: TcpStream) {
 
     let mut buf: Vec<u8> = Vec::new();
     let mut reader = BufReader::new(read);
-    let bytes = reader.read_until(b'\n', &mut buf).await;
 
-    if let Ok(0) = bytes {
-        return;
-    }
+    loop {
+        let bytes = reader.read_until(b'\n', &mut buf).await;
 
-    if let Ok(1) = bytes {
-        return;
-    }
-
-    let message: serde_json::Value = serde_json::from_slice(&buf).unwrap();
-
-    log::info!("Message received: {}", message);
-
-    match serde_json::from_slice::<Request>(&buf) {
-        Ok(m) => {
-            let possible_prime = match m.number.to_string().parse::<u64>() {
-                Ok(n) => n,
-                Err(e) => {
-                    log::error!("Not a valid number: {}", e);
-
-                    let _ = write.write(&MAL_FORMAT.as_bytes()).await;
-                    let _ = write.write(&[b'\n']).await;
-                    let _ = write.flush().await;
-                    return;
-                }
-            };
-
-            let res = Response {
-                method: IS_PRIME.to_owned(),
-                prime: is_prime(possible_prime),
-            };
-
-            if m.method == IS_PRIME.to_owned() {
-                if let Err(e) = write
-                    .write(&serde_json::to_string(&res).unwrap().as_bytes())
-                    .await
-                {
-                    log::error!("Error writing serialize step: {}", e);
-                }
-                if let Err(e) = write.write(&[b'\n']).await {
-                    log::error!("Error writing: {}", e);
-                }
-                if let Err(e) = write.flush().await {
-                    log::error!("Error flushing: {}", e);
-                }
-            } else {
-                log::error!("Method is not isPrime");
-                if let Err(e) = write.write(&MAL_FORMAT.as_bytes()).await {
-                    log::error!("Write mal_format failed!");
-                }
-
-                if let Err(e) = write.write(&[b'\n']).await {
-                    log::error!("Error writing escape character!");
-                }
-                if let Err(e) = write.flush().await {
-                    log::error!("Error flushing socket!");
-                }
-                log::info!("Wrote malformat response");
-            }
+        if let Ok(0) = bytes {
+            return;
         }
-        Err(e) => {
-            log::error!("Error parsing the message: {}", e);
-            log::error!("Message: {}", String::from_utf8_lossy(&buf));
 
-            let _ = write.write(&MAL_FORMAT.as_bytes()).await;
-            let _ = write.write(&[b'\n']).await;
-            let _ = write.flush().await;
+        if let Ok(1) = bytes {
+            return;
+        }
+
+        let message: serde_json::Value = match serde_json::from_slice(&buf) {
+            Ok(m) => m,
+            Err(e) => {
+                let _ = write.write(&MAL_FORMAT.as_bytes()).await;
+                let _ = write.write(&[b'\n']).await;
+                let _ = write.flush().await;
+                return;
+            }
+        };
+
+        log::info!("Message received: {}", message);
+
+        match serde_json::from_slice::<Request>(&buf) {
+            Ok(m) => {
+                let possible_prime = match m.number.to_string().parse::<u64>() {
+                    Ok(n) => n,
+                    Err(e) => {
+                        log::error!("Not a valid number: {}", e);
+                        if let Err(e) = write
+                            .write(&serde_json::to_string(&Response {method: IS_PRIME.to_owned(), prime: false}).unwrap().as_bytes())
+                            .await
+                            {
+                                log::error!("Error writing serialize step: {}", e);
+                            }
+                        return;
+                    }
+                };
+
+                let res = Response {
+                    method: IS_PRIME.to_owned(),
+                    prime: is_prime(possible_prime),
+                };
+
+                if m.method == IS_PRIME.to_owned() {
+                    log::info!("All good, send response: {:?}", res);
+                    if let Err(e) = write
+                        .write(&serde_json::to_string(&res).unwrap().as_bytes())
+                        .await
+                    {
+                        log::error!("Error writing serialize step: {}", e);
+                    }
+                    if let Err(e) = write.write(&[b'\n']).await {
+                        log::error!("Error writing: {}", e);
+                    }
+                    if let Err(e) = write.flush().await {
+                        log::error!("Error flushing: {}", e);
+                    }
+                } else {
+                    log::error!("Method is not isPrime");
+                    if let Err(e) = write.write(&MAL_FORMAT.as_bytes()).await {
+                        log::error!("Write mal_format failed!");
+                    }
+
+                    if let Err(e) = write.write(&[b'\n']).await {
+                        log::error!("Error writing escape character!");
+                    }
+                    if let Err(e) = write.flush().await {
+                        log::error!("Error flushing socket!");
+                    }
+                    log::info!("Wrote malformat response");
+                }
+            }
+            Err(e) => {
+                log::error!("Error parsing the message: {}", e);
+                log::error!("Message: {}", String::from_utf8_lossy(&buf));
+
+                let _ = write.write(&MAL_FORMAT.as_bytes()).await;
+                let _ = write.write(&[b'\n']).await;
+                let _ = write.flush().await;
+            }
         }
     }
 }