Restructure demos

- Move demo code into `examples/` folder
- Restructure to enable generic use cases

Author: de-sh

Cargo.toml

@@ -4,14 +4,6 @@ version = "0.1.0"
 authors = ["Devdutt Shenoi <devdutt@outlook.in>"]
 edition = "2018"
 
-[[bin]]
-name = "global"
-path = "src/global.rs"
-
-[[bin]]
-name = "local"
-path = "src/local.rs"
-
 [dependencies]
 tokio = { version = "0.2", features = ["full"] }
 bytes = "1"

README.md

@@ -17,15 +17,15 @@ git clone https://github.com/vyuham/dstore
 ```
 2. Run the server(ensure `cargo` is installed with [rustup](https://rustup.rs)):
 ```bash
-cargo run --bin global
+cargo run --example global
 ```
 Ensure the following is showing on the terminal:
 ```
 Dstore server listening on 127.0.0.1:50051
 ```
 3. On another terminal, start a client:
 ```bash
-cargo run --bin local
+cargo run --example local
 ```
 Ensure the following is showing on the terminal:
 ```

examples/global.rs

@@ -0,0 +1,9 @@
+use dstore::global::Store;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let addr = "127.0.0.1:50051".parse().unwrap();
+
+    println!("Dstore server listening on {}", addr);
+    Store::start(addr).await
+}

examples/local.rs

@@ -0,0 +1,97 @@
+use bytes::Bytes;
+use dstore::local::Store;
+use std::io;
+use std::io::{stdin, BufRead, Write};
+
+pub struct REPL {
+    store: Store,
+}
+
+impl REPL {
+    async fn new(store: Store) -> Self {
+        Self { store }
+    }
+
+    async fn parse_input(&mut self, cmd: String) -> Result<(), Box<dyn std::error::Error>> {
+        // Meta commands start with `.`.
+        if cmd.starts_with(".") {
+            match MetaCmdResult::run(&cmd) {
+                MetaCmdResult::Unrecognized => Ok(println!("db: meta command not found: {}", cmd)),
+                MetaCmdResult::Success => Ok(()),
+            }
+        } else {
+            let words = cmd.split(" ").collect::<Vec<&str>>();
+            match words[0].to_lowercase().as_ref() {
+                "set" | "put" | "insert" | "in" | "i" => {
+                    let key = words[1].to_string();
+                    let value = Bytes::from(words[2..].join(" "));
+                    if let Err(e) = self.store.insert(key, value).await {
+                        eprintln!("{}", e);
+                    }
+
+                    Ok(())
+                }
+                "get" | "select" | "output" | "out" | "o" => {
+                    let key = words[1].to_string();
+                    match self.store.get(&key).await {
+                        Ok(value) => {
+                            println!("db: {} -> {}", key, String::from_utf8(value.to_vec())?)
+                        }
+                        Err(e) => eprintln!("{}", e),
+                    }
+
+                    Ok(())
+                }
+                "del" | "delete" | "rem" | "remove" | "rm" | "d" => {
+                    // Removes only from local
+                    let key = words[1].to_string();
+                    Ok(self.store.remove(key))
+                }
+                _ => Ok(eprintln!("Unknown command!")),
+            }
+        }
+    }
+}
+pub enum MetaCmdResult {
+    Success,
+    Unrecognized,
+}
+
+impl MetaCmdResult {
+    /// Execute Meta commands on the REPL.
+    pub fn run(cmd: &String) -> Self {
+        match cmd.as_ref() {
+            ".exit" => std::process::exit(0),
+            ".version" => {
+                if let Some(ver) = option_env!("CARGO_PKG_VERSION") {
+                    println!("You are using KVDB v{}", ver);
+                }
+                Self::Success
+            }
+            _ => Self::Unrecognized,
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client_addr = "http://127.0.0.1:50051".parse().unwrap();
+    let local_store = Store::new(client_addr).await?;
+    let mut repl = REPL::new(local_store).await;
+
+    print!("dstore v0.1.0\nThis is an experimental database, do contribute to further developments at https://github.com/vyuham/dstore. \nUse `.exit` to exit the repl\ndb > ");
+    io::stdout().flush().expect("Error");
+
+    for cmd in stdin().lock().lines() {
+        match cmd {
+            Ok(cmd) => {
+                repl.parse_input(cmd.trim().to_string()).await?;
+            }
+            Err(_) => eprint!("Error in reading command, exiting REPL."),
+        }
+        print!("db > ");
+        io::stdout().flush().expect("Error");
+    }
+
+    Ok(())
+}

src/global.rs

@@ -1,17 +1,29 @@
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
 use bytes::Bytes;
+use std::sync::{Arc, Mutex};
+use std::{collections::HashMap, net::SocketAddr};
 use tonic::{transport::Server, Request, Response, Status};
 
-use dstore::dstore_proto::dstore_server::{Dstore, DstoreServer};
-use dstore::dstore_proto::{GetArg, GetResult, SetArg, SetResult};
-struct Store {
+use crate::dstore_proto::dstore_server::{Dstore, DstoreServer};
+use crate::dstore_proto::{GetArg, GetResult, SetArg, SetResult};
+
+pub struct Store {
     db: Arc<Mutex<HashMap<String, Bytes>>>,
 }
 
 impl Store {
-    fn new(db: Arc<Mutex<HashMap<String, Bytes>>>) -> Self {
-        Self { db }
+    fn new() -> Self {
+        Self {
+            db: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    pub async fn start(addr: SocketAddr) -> Result<(), Box<dyn std::error::Error>> {
+        Server::builder()
+            .add_service(DstoreServer::new(Store::new()))
+            .serve(addr)
+            .await?;
+
+        Ok(())
     }
 }
 
@@ -44,18 +56,3 @@ impl Dstore for Store {
         }
     }
 }
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let addr = "127.0.0.1:50051".parse().unwrap();
-    let global_store = Arc::new(Mutex::new(HashMap::<String, Bytes>::new()));
-
-    println!("Dstore server listening on {}", addr);
-
-    Server::builder()
-        .add_service(DstoreServer::new(Store::new(global_store)))
-        .serve(addr)
-        .await?;
-
-    Ok(())
-}

src/lib.rs

@@ -1,3 +1,28 @@
+use std::error::Error;
+use std::fmt;
+
+#[derive(Debug)]
+pub struct DstoreError {
+    msg: String,
+}
+
+impl DstoreError {
+    pub fn new(msg: String) -> Self {
+        Self { msg }
+    }
+}
+
+impl fmt::Display for DstoreError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "dstore error: {}", self.msg)
+    }
+}
+
+impl Error for DstoreError {}
+
 pub mod dstore_proto {
     tonic::include_proto!("dstore");
 }
+
+pub mod global;
+pub mod local;