Add Project 4 - Part 3, Adding multithreading

Author: hindenbug

kvs-2/src/kv.rs

@@ -41,8 +41,8 @@ impl KvStore {
         let log = Self::new_log_file(&path)?;
 
         let mut store = KvStore {
-            path: path,
-            log: log,
+            path,
+            log,
             map: BTreeMap::new(),
         };
 

kvs-client-server/src/server.rs

@@ -1,5 +1,5 @@
 use crate::network::{GetResponse, RemoveResponse, Request, SetResponse};
-use crate::{KvsEngine, Result};
+use crate::{KvsEngine, NaiveThreadPool, Result, ThreadPool};
 use log::{debug, error, info};
 use serde_json::Deserializer;
 use std::io::{BufReader, BufWriter, Write};
@@ -24,21 +24,23 @@ impl<E: KvsEngine> Server<E> {
 
     pub fn serve(&self) -> Result<()> {
         debug!("Waiting for connections...");
+        let thread_pool = NaiveThreadPool::new(1)?;
         let listnr = self.listener.try_clone().unwrap();
         for stream in listnr.incoming() {
-            match stream {
+            let engine = self.engine.clone();
+            thread_pool.spawn(move || match stream {
                 Ok(stream) => {
-                    if let Err(e) = self.handle_client(stream) {
+                    if let Err(e) = Self::handle_client(engine, stream) {
                         error!("Error on serving client: {}", e);
                     }
                 }
                 Err(e) => error!("Connection failed, reason: {:?}", e),
-            }
+            })
         }
         Ok(())
     }
 
-    fn handle_client(&self, stream: TcpStream) -> Result<()> {
+    fn handle_client(engine: E, stream: TcpStream) -> Result<()> {
         debug!(
             "Connection established from {}, waiting for data...",
             stream.peer_addr()?
@@ -64,21 +66,21 @@ impl<E: KvsEngine> Server<E> {
             debug!("Received request from {}: {:?}", peer_addr, req);
             match req {
                 Request::Get { key } => {
-                    let engine_response = match self.engine.get(key) {
+                    let engine_response = match engine.get(key) {
                         Ok(value) => GetResponse::Ok(value),
                         Err(err) => GetResponse::Err(format!("{}", err)),
                     };
                     send_response!(engine_response);
                 }
                 Request::Set { key, value } => {
-                    let engine_response = match self.engine.set(key, value) {
+                    let engine_response = match engine.set(key, value) {
                         Ok(_) => SetResponse::Ok(()),
                         Err(err) => SetResponse::Err(format!("{}", err)),
                     };
                     send_response!(engine_response);
                 }
                 Request::Remove { key } => {
-                    let engine_response = match self.engine.remove(key) {
+                    let engine_response = match engine.remove(key) {
                         Ok(_) => RemoveResponse::Ok(()),
                         Err(err) => RemoveResponse::Err(format!("{}", err)),
                     };