Add ability to spawn new thread per connection

.gitignore

@@ -1 +1,2 @@
 /target
+.vscode

src/main.rs

@@ -5,6 +5,8 @@ mod store;
 #[macro_use(concat_string)]
 extern crate concat_string;
 use std::net::{SocketAddrV4, TcpListener};
+use std::sync::Arc;
+use std::thread;
 
 use connection_manager::client_handler::handle_stream;
 use resp::deserialize::deserialize;
@@ -16,13 +18,15 @@ const PORT: u16 = 6379; //Redis PORT
 
 fn main() {
     let listener = TcpListener::bind(SocketAddrV4::new(ADDR, PORT)).unwrap();
-    let cache = Cache::new();
+    let cache = Arc::new(Cache::new());
 
     for stream in listener.incoming() {
         match stream {
             Ok(stream) => {
                 println!("New connection: {}", stream.peer_addr().unwrap());
-                handle_stream(stream, &cache)
+
+                let cache_clone = cache.clone();
+                thread::spawn(move || handle_stream(stream, &cache_clone));
             }
             Err(err) => println!("Connection failed due to {:?}", err),
         }

src/store/db.rs

@@ -1,38 +1,37 @@
-use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
+    use std::collections::HashMap;
+    use std::sync::{Arc, RwLock};
 
-#[derive(Debug, Clone)]
-pub struct Cache {
-    data: Arc<RwLock<HashMap<String, String>>>,
-}
+    #[derive(Debug, Clone)]
+    pub struct Cache {
+        data: Arc<RwLock<HashMap<String, String>>>,
+    }
 
-impl Cache {
-    // Initialize a new database
-    pub fn new() -> Self {
-        Self {
-            data: Arc::new(RwLock::new(HashMap::new())),
+    impl Cache {
+        pub fn new() -> Self {
+            Self {
+                data: Arc::new(RwLock::new(HashMap::new())),
+            }
         }
-    }
 
-    pub fn set(&self, key: String, value: String) {
-        let mut data = self.data.write().unwrap();
-        data.insert(key, value);
-    }
+        pub fn set(&self, key: String, value: String) {
+            let mut data = self.data.write().unwrap();
+            data.insert(key, value);
+        }
 
-    pub fn get(&self, key: &str) -> Option<String> {
-        let data = self.data.read().unwrap();
-        data.get(key).cloned()
+        pub fn get(&self, key: &str) -> Option<String> {
+            let data = self.data.read().unwrap();
+            data.get(key).cloned()
+        }
     }
-}
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+    #[cfg(test)]
+    mod tests {
+        use super::*;
 
-    #[test]
-    fn should_initialize_and_get_set() {
-        let cache = Cache::new();
-        cache.set(String::from("name"), String::from("The Wizard of Oz"));
-        assert_eq!("The Wizard of Oz", cache.get("name").unwrap());
+        #[test]
+        fn should_initialize_and_get_set() {
+            let cache = Cache::new();
+            cache.set(String::from("name"), String::from("The Wizard of Oz"));
+            assert_eq!("The Wizard of Oz", cache.get("name").unwrap());
+        }
     }
-}