feat: connect client and server

Author: odysa

.github/workflows/rust.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        build: [stable, beta, nightly, macos, windows, msrv]
+        build: [stable, beta, nightly]
         include:
           - build: stable
             os: ubuntu-latest
@@ -24,15 +24,7 @@ jobs:
           - build: nightly
             os: ubuntu-latest
             rust: nightly
-          - build: macos
-            os: macos-latest
-            rust: stable
-          - build: windows
-            os: windows-latest
-            rust: stable
-          - build: msrv
-            os: ubuntu-latest
-            rust: stable
+
     steps:
     - uses: actions/checkout@master
     - name: Install Rust

src/bin/kvs-client.rs

@@ -1,7 +1,6 @@
 use clap::{crate_authors, crate_version, Clap};
-use kvs::common::KvsEngine;
-use kvs::kvs_store::KvStore;
-use std::{net::SocketAddr, path::Path, process};
+use kvs::client::Client;
+use std::{net::SocketAddr, process};
 #[derive(Clap)]
 #[clap(version =crate_version!() , author = crate_authors!())]
 struct Options {
@@ -29,30 +28,38 @@ struct KeyValue {
 }
 fn main() {
     let opts = Options::parse();
-    let mut kvs = KvStore::open(Path::new("./db")).unwrap();
     match opts.subcmd {
-        SubCommand::Get(m) => match kvs.get(m.key) {
-            Ok(Some(value)) => {
-                println!("{}", value);
+        SubCommand::Get(m) => {
+            let mut client = Client::connect(m.addr).expect("cannot connect to server");
+            match client.get(m.key) {
+                Ok(Some(value)) => {
+                    println!("{}", value);
+                }
+                _ => {
+                    println!("Key not found");
+                    process::exit(0);
+                }
             }
-            _ => {
-                println!("Key not found");
-                process::exit(0);
+        }
+        SubCommand::RM(m) => {
+            let mut client = Client::connect(m.addr).expect("cannot connect to server");
+            match client.remove(m.key) {
+                Ok(_) => {}
+                _ => {
+                    eprintln!("Key not found");
+                    process::exit(-1);
+                }
             }
-        },
-        SubCommand::RM(m) => match kvs.remove(m.key) {
-            Ok(_) => {}
-            _ => {
-                eprintln!("Key not found");
-                process::exit(-1);
+        }
+        SubCommand::Set(m) => {
+            let mut client = Client::connect(m.addr).expect("cannot connect to server");
+            match client.set(m.key, m.value) {
+                Ok(_) => {}
+                Err(e) => {
+                    println!("{}", e);
+                    process::exit(-1);
+                }
             }
-        },
-        SubCommand::Set(m) => match kvs.set(m.key, m.value) {
-            Ok(_) => {}
-            Err(e) => {
-                println!("{}", e);
-                process::exit(-1);
-            }
-        },
+        }
     }
 }

src/lib.rs

@@ -1,4 +1,4 @@
-mod client;
+pub mod client;
 pub mod common;
 mod database;
 pub mod error;

src/server.rs

@@ -1,6 +1,7 @@
 use crate::common::KvsEngine;
 use crate::error::Result;
 use crate::net::{Request, Response};
+use crate::thread_pool::{QueueThreadPool, ThreadPool};
 use serde_json::Deserializer;
 use slog::{debug, error, info, Logger};
 use std::io::{BufReader, BufWriter, Write};
@@ -15,12 +16,14 @@ impl<T: KvsEngine> Server<T> {
     }
 
     pub fn serve(&mut self, addr: &SocketAddr, logger: &Logger) -> Result<()> {
+        let pool = QueueThreadPool::new(10)?;
         let listener = TcpListener::bind(addr)?;
         for stream in listener.incoming() {
             self.handle_client(stream?, logger)?;
         }
         Ok(())
     }
+    
     fn handle_client(&mut self, stream: TcpStream, logger: &Logger) -> Result<()> {
         let peer_addr = stream.peer_addr()?;
         let reader = BufReader::new(&stream);