Use bytes::Bytes

- Replace String with Bytes for Value containers
- Remove del operation on server side
- Covert use of string in grpc messages to bytes

Author: de-sh

proto/dstore.proto

@@ -4,7 +4,7 @@ package dstore;
 
 message SetArg {
     string key = 1;
-    string value = 2;
+    bytes value = 2;
 }
 
 message GetArg {
@@ -16,12 +16,11 @@ message SetResult {
 }
 
 message GetResult {
-    string value = 1;
+    bytes value = 1;
     bool success = 2;
 }
 
 service Dstore {
     rpc Set(SetArg) returns (SetResult);
     rpc Get(GetArg) returns (GetResult);
-    rpc Del(GetArg) returns (SetResult);
 }

src/global.rs

@@ -1,15 +1,16 @@
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
+use bytes::Bytes;
 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 {
-    db: Arc<Mutex<HashMap<String, String>>>,
+    db: Arc<Mutex<HashMap<String, Bytes>>>,
 }
 
 impl Store {
-    fn new(db: Arc<Mutex<HashMap<String, String>>>) -> Self {
+    fn new(db: Arc<Mutex<HashMap<String, Bytes>>>) -> Self {
         Self { db }
     }
 }
@@ -22,7 +23,7 @@ impl Dstore for Store {
         match db.contains_key(&args.key) {
             true => Ok(Response::new(SetResult { success: false })),
             false => {
-                db.insert(args.key, args.value);
+                db.insert(args.key, Bytes::from(args.value));
                 Ok(Response::new(SetResult { success: true }))
             }
         }
@@ -33,33 +34,21 @@ impl Dstore for Store {
         let args = get_arg.into_inner();
         match db.get(&args.key) {
             Some(val) => Ok(Response::new(GetResult {
-                value: val.clone(),
+                value: val.to_vec(),
                 success: true,
             })),
             None => Ok(Response::new(GetResult {
-                value: "".to_string(),
+                value: vec![],
                 success: false,
             })),
         }
     }
-
-    async fn del(&self, del_arg: Request<GetArg>) -> Result<Response<SetResult>, Status> {
-        let mut db = self.db.lock().unwrap();
-        let args = del_arg.into_inner();
-        match db.contains_key(&args.key) {
-            false => Ok(Response::new(SetResult { success: false })),
-            true => {
-                db.remove(&args.key);
-                Ok(Response::new(SetResult { success: true }))
-            }
-        }
-    }
 }
 
 #[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, String>::new()));
+    let global_store = Arc::new(Mutex::new(HashMap::<String, Bytes>::new()));
 
     println!("Dstore server listening on {}", addr);
 

src/local.rs

@@ -1,13 +1,14 @@
 use std::collections::HashMap;
 use std::io;
 use std::io::{stdin, BufRead, Write};
+use bytes::Bytes;
 use tonic::{transport::Channel, Request};
 
 use dstore::dstore_proto::dstore_client::DstoreClient;
 use dstore::dstore_proto::{GetArg, SetArg};
 
 struct Store {
-    db: HashMap<String, String>,
+    db: HashMap<String, Bytes>,
     global: DstoreClient<Channel>,
 }
 
@@ -37,31 +38,31 @@ impl Store {
                         let value = words[2..].join(" ");
                         let req = Request::new(SetArg {
                             key: key.clone(),
-                            value: value.clone(),
+                            value: value.as_bytes().to_vec(),
                         });
                         let res = self.global.set(req).await.unwrap();
                         if res.into_inner().success {
-                            self.db.insert(key, value);
+                            self.db.insert(key, Bytes::from(value));
                             eprintln!("Database updated");
                         } else {
                             let req = Request::new(GetArg { key: key.clone() });
                             let res = self.global.get(req).await.unwrap().into_inner();
-                            self.db.insert(key, res.value);
+                            self.db.insert(key, Bytes::from(res.value));
                             eprintln!("(Updated local) Key occupied!");
                         }
                     }
                 }
                 "get" | "select" | "output" | "out" | "o" => {
                     let key = words[1].to_string();
                     match self.db.get(&key) {
-                        Some(value) => println!("db: {} -> {}", key, value),
+                        Some(value) => println!("db: {} -> {}", key, String::from_utf8(value.to_vec()).unwrap()),
                         None => {
                             let req = Request::new(GetArg { key: key.clone() });
                             let res = self.global.get(req).await.unwrap().into_inner();
                             if res.success {
-                                println!("global: {} -> {}\t(Updating Local)", key, res.value);
+                                println!("global: {} -> {}\t(Updating Local)", key, String::from_utf8(res.value.clone()).unwrap());
                                 // Update local
-                                self.db.insert(key, res.value);
+                                self.db.insert(key, Bytes::from(res.value));
                             } else {
                                 eprintln!("Key-Value mapping doesn't exist");
                             }
@@ -73,7 +74,7 @@ impl Store {
                     let key = words[1];
                     match self.db.get(key) {
                         Some(value) => {
-                            eprintln!("({} -> {}) Removing local mapping!", key, value);
+                            eprintln!("({} -> {}) Removing local mapping!", key, String::from_utf8(value.to_vec()).unwrap());
                             self.db.remove(key);
                         }
                         None => eprintln!("Key-Value mapping doesn't exist"),