s/StoreValue/Value

Author: jdockerty

benches/sqrl_bench.rs

@@ -9,7 +9,7 @@ fn write_direct(c: &mut criterion::Criterion) {
 
     c.bench_with_input(BenchmarkId::new("write", "store"), &store, |b, s| {
         b.to_async(&rt).iter(|| async {
-            s.set("key".to_string(), "value".to_string()).await.unwrap();
+            s.set("key".to_string(), "value".into()).await.unwrap();
         })
     });
 }

src/bin/sqrl-client.rs

@@ -2,7 +2,7 @@ use clap::Parser;
 
 use sqrl::action::Action;
 use sqrl::client::{Client, RemoteNodeClient};
-use sqrl::StoreValue;
+use sqrl::Value;
 
 #[derive(Debug, Parser)]
 #[command(author, version, about, long_about = None)]
@@ -21,9 +21,7 @@ async fn main() -> anyhow::Result<()> {
 
     match cli.subcmd {
         Action::Set { key, value } => {
-            client
-                .set(key, StoreValue(Some(value.into_bytes())))
-                .await?;
+            client.set(key, Value(Some(value.into_bytes()))).await?;
         }
         Action::Get { key } => {
             let response = client.get(key).await?;

src/client.rs

@@ -6,15 +6,15 @@ use crate::proto::action_client::ActionClient;
 use crate::proto::{Acknowledgement, GetResponse, RemoveRequest};
 use crate::proto::{GetRequest, SetRequest};
 pub use crate::replication::ReplicatedServer;
-use crate::store::StoreValue;
+use crate::store::Value;
 use crate::Result;
 
 /// A client used for interacting with the [`KvStore`] via gRPC requests.
 #[tonic::async_trait]
 pub trait Client {
     async fn get(&mut self, key: String) -> anyhow::Result<Option<GetResponse>>;
 
-    async fn set(&mut self, key: String, value: StoreValue) -> anyhow::Result<Acknowledgement>;
+    async fn set(&mut self, key: String, value: Value) -> anyhow::Result<Acknowledgement>;
 
     async fn remove(&mut self, key: String) -> anyhow::Result<Acknowledgement>;
 }
@@ -46,7 +46,7 @@ impl RemoteNodeClient {
 
 #[tonic::async_trait]
 impl Client for RemoteNodeClient {
-    async fn set(&mut self, key: String, value: StoreValue) -> anyhow::Result<Acknowledgement> {
+    async fn set(&mut self, key: String, value: Value) -> anyhow::Result<Acknowledgement> {
         let value = value.0.unwrap_or_default();
         let req = tonic::Request::new(SetRequest {
             key,

src/engine.rs

@@ -1,6 +1,6 @@
 use std::future::Future;
 
-use crate::{store::StoreValue, Result};
+use crate::{store::Value, Result};
 
 /// Generic trait implementation for pluggable storage engines outside of the one
 /// implemented by this crate.
@@ -12,7 +12,7 @@ use crate::{store::StoreValue, Result};
 ///
 /// [`KvStore`]: crate::store::KvStore
 pub trait KvsEngine: Clone + Send + Sync + 'static {
-    fn set(&self, key: String, value: StoreValue) -> impl Future<Output = Result<()>>;
-    fn get(&self, key: String) -> impl Future<Output = Result<Option<StoreValue>>>;
+    fn set(&self, key: String, value: Value) -> impl Future<Output = Result<()>>;
+    fn get(&self, key: String) -> impl Future<Output = Result<Option<Value>>>;
     fn remove(&self, key: String) -> impl Future<Output = Result<()>>;
 }

src/lib.rs

@@ -27,7 +27,7 @@ mod store;
 pub use engine::KvsEngine;
 pub use error::Error as KvStoreError;
 pub use server::StandaloneServer;
-pub use store::{KvStore, StoreValue};
+pub use store::{KvStore, Value};
 pub mod action;
 pub mod client;
 

src/replication/server.rs

@@ -8,7 +8,7 @@ use tracing::{debug, info};
 use crate::client::{Client, RemoteNodeClient};
 use crate::proto::action_server::{Action, ActionServer};
 use crate::proto::{Acknowledgement, GetRequest, GetResponse, RemoveRequest, SetRequest};
-use crate::store::StoreValue;
+use crate::store::Value;
 use crate::{KvsEngine, StandaloneServer};
 
 /// Wrapped implementation of a [`StandaloneServer`] with an awareness of multiple
@@ -68,7 +68,7 @@ impl Action for ReplicatedServer {
         let key = req.key.clone();
         let response = match self.server.store.get(key).await.unwrap() {
             Some(r) => r,
-            None => StoreValue(None),
+            None => Value(None),
         };
         Ok(tonic::Response::new(GetResponse { value: response.0 }))
     }
@@ -81,14 +81,14 @@ impl Action for ReplicatedServer {
         debug!("Setting value to local store");
         self.server
             .store
-            .set(req.key.clone(), StoreValue(Some(req.value.clone())))
+            .set(req.key.clone(), Value(Some(req.value.clone())))
             .await
             .unwrap();
 
         debug!("Replicating to remote replicas");
         futures::stream::iter(self.remote_replicas.lock().await.iter_mut())
             .for_each(|r| async {
-                r.set(req.key.clone(), StoreValue(Some(req.value.clone())))
+                r.set(req.key.clone(), Value(Some(req.value.clone())))
                     .await
                     .unwrap();
             })

src/server.rs

@@ -2,7 +2,7 @@ use crate::proto::{
     action_server::{Action, ActionServer},
     Acknowledgement, GetRequest, GetResponse, RemoveRequest, SetRequest,
 };
-use crate::store::StoreValue;
+use crate::store::Value;
 use crate::KvStore;
 use crate::KvsEngine;
 use std::{net::SocketAddr, sync::Arc};
@@ -58,7 +58,7 @@ impl Action for StandaloneServer {
     ) -> tonic::Result<tonic::Response<Acknowledgement>, tonic::Status> {
         let req = req.into_inner();
         self.store
-            .set(req.key, StoreValue(Some(req.value)))
+            .set(req.key, Value(Some(req.value)))
             .await
             .unwrap();
         Ok(tonic::Response::new(Acknowledgement { success: true }))

src/store.rs

@@ -24,17 +24,17 @@ pub enum Operation {
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
-pub struct StoreValue(pub Option<Vec<u8>>);
+pub struct Value(pub Option<Vec<u8>>);
 
-impl From<&str> for StoreValue {
+impl From<&str> for Value {
     fn from(value: &str) -> Self {
-        StoreValue(Some(value.into()))
+        Value(Some(value.into()))
     }
 }
 
-impl From<String> for StoreValue {
+impl From<String> for Value {
     fn from(value: String) -> Self {
-        StoreValue(Some(value.into_bytes()))
+        Value(Some(value.into_bytes()))
     }
 }
 
@@ -92,7 +92,7 @@ struct LogEntry {
     /// the entry with the most recent timestamp wins.
     timestamp: i64,
     key: String,
-    value: Option<StoreValue>,
+    value: Option<Value>,
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -118,7 +118,7 @@ struct StoreConfig {
 
 impl KvsEngine for KvStore {
     /// Set the value of a key by inserting the value into the store for the given key.
-    async fn set(&self, key: String, value: StoreValue) -> Result<()> {
+    async fn set(&self, key: String, value: Value) -> Result<()> {
         debug!(key, "Setting key");
         let timestamp = chrono::Utc::now().timestamp();
         let entry = LogEntry {
@@ -165,7 +165,7 @@ impl KvsEngine for KvStore {
     ///
     /// The timestamp is typically used with replication, as the value acts as
     /// a version number and conflict resolution mechanism.
-    async fn get(&self, key: String) -> Result<Option<StoreValue>> {
+    async fn get(&self, key: String) -> Result<Option<Value>> {
         debug!(key, "Getting key");
         match self.keydir.get(&key) {
             Some(entry) => {

tests/kv_store.rs

@@ -1,5 +1,5 @@
 use rand::Rng;
-use sqrl::{KvStore, KvsEngine, Result, StoreValue};
+use sqrl::{KvStore, KvsEngine, Result, Value};
 use std::{collections::HashMap, sync::Arc};
 use tempfile::TempDir;
 use tokio::sync::Barrier;
@@ -161,7 +161,7 @@ async fn randomised_retrieval() -> Result<()> {
     let temp_dir = TempDir::new().expect("unable to create temporary working directory");
     let store = KvStore::open(temp_dir.path())?;
 
-    let mut value_tracker: HashMap<String, StoreValue> = HashMap::new();
+    let mut value_tracker: HashMap<String, Value> = HashMap::new();
     let mut rng = rand::thread_rng();
     for i in 0..1000 {
         let key = format!("key{}", i);