renamed Store, State structs. Store is now lock protected

Author: sudeep9

crates/mojo-cli/src/commit.rs

@@ -1,8 +1,8 @@
 use anyhow::Error;
-use mojokv::KVStore;
+use mojokv::Store;
 
 pub fn cmd(kvpath: &std::path::Path) -> Result<(), Error> {
-    let mut st = KVStore::writable(&kvpath, false, None, None)?;
+    let st = Store::writable(&kvpath, false, None, None)?;
 
     println!("active version before commit: {}", st.active_ver());
     let new_ver = st.commit()?;

crates/mojo-cli/src/iget.rs

@@ -1,8 +1,8 @@
 use anyhow::Error;
-use mojokv::{KVStore,BucketOpenMode};
+use mojokv::{Store,BucketOpenMode};
 
 pub fn cmd(kvpath: &std::path::Path, bucket: &str, ver: u32, key: u32) -> Result<(), Error> {
-    let mut st = KVStore::readonly(&kvpath, ver)?;
+    let st = Store::readonly(&kvpath, ver)?;
     let b = st.open(bucket, BucketOpenMode::Read)?;
 
     println!("Max key: {}", b.max_key());

crates/mojo-cli/src/iview.rs

@@ -1,8 +1,8 @@
 use anyhow::Error;
-use mojokv::{KVStore};
+use mojokv::{Store};
 
 pub fn cmd(kvpath: &std::path::Path, name: &str, ver: u32, additional: bool, keys: bool) -> Result<(), Error> {
-    let st = KVStore::readonly(kvpath, ver)?;
+    let st = Store::readonly(kvpath, ver)?;
     let ret = st.get_index(name)?; //Bucket::load_index(&kvpath, name, ver)?;
 
     if ret.is_none() {
@@ -14,7 +14,7 @@ pub fn cmd(kvpath: &std::path::Path, name: &str, ver: u32, additional: bool, key
     let h = i.header();
 
     let st = if additional {
-        Some(KVStore::load_state(kvpath)?)
+        Some(Store::load_state(kvpath)?)
     }else{
         None
     };

crates/mojo-cli/src/state.rs

@@ -1,9 +1,9 @@
 use anyhow::Error;
-use mojokv::{self, KVStore};
+use mojokv::{self, Store};
 use std::mem::size_of;
 
 pub fn cmd(kvpath: &std::path::Path, additional: bool) -> Result<(), Error> {
-    let st = KVStore::load_state(kvpath)?;
+    let st = Store::load_state(kvpath)?;
 
     println!("Format version  : {}", st.format_ver());
     println!("Minimum version : {}", st.min_ver());
@@ -14,7 +14,7 @@ pub fn cmd(kvpath: &std::path::Path, additional: bool) -> Result<(), Error> {
 
     if additional {
         println!("----------------------------");
-        println!("Size of KVStore : {} bytes", size_of::<KVStore>());
+        println!("Size of KVStore : {} bytes", size_of::<Store>());
         println!("Size of MemIndex   : {} bytes", size_of::<mojokv::index::mem::MemIndex>());
         println!("Size of KeyMap  : {} bytes", size_of::<mojokv::KeyMap>());
         println!("Size of Value   : {} bytes", size_of::<mojokv::Value>());

crates/mojofs/src/vfs.rs

@@ -5,7 +5,7 @@ use crate::open_options::*;
 use std::collections::HashMap;
 use crate::kvfile::{KVFile, KVFileOpt};
 use crate::vfsfile::FileImpl;
-use mojokv::{KVStore, BucketOpenMode};
+use mojokv::{Store, BucketOpenMode};
 
 use crate::vfsfile::VFSFile;
 
@@ -17,7 +17,7 @@ pub enum AccessCheck {
 
 #[derive(Default)]
 pub struct VFS {
-    store: Option<KVStore>,
+    store: Option<Store>,
     file_counter: usize,
     fopt: FSOptions,
 }
@@ -41,10 +41,10 @@ impl VFS {
         self.fopt = FSOptions::parse(params)?;
         let root_path = Path::new(root_path);
         if opt.access == OpenAccess::Read {
-            self.store = Some(KVStore::readonly(root_path, self.fopt.ver)?);
+            self.store = Some(Store::readonly(root_path, self.fopt.ver)?);
             log::debug!("store opened in readonly mode");
         }else{
-            self.store = Some(KVStore::writable(root_path, true, Some(self.fopt.pagesz), Some(self.fopt.pps))?);
+            self.store = Some(Store::writable(root_path, true, Some(self.fopt.pagesz), Some(self.fopt.pps))?);
             log::debug!("store opened writable mode");
         }
 

crates/mojokv/src/bmap.rs

@@ -13,7 +13,7 @@ pub struct BucketMap {
 }
 
 impl BucketMap {
-    pub fn add(&mut self, name: &str, ver: u32) {
+    pub fn add(&self, name: &str, ver: u32) {
         log::debug!("add name={} ver={} {:?}", name, ver, self.map);
         let mut map = self.map.write();
         //self.buckets.insert(name.to_owned(), b);
@@ -31,7 +31,7 @@ impl BucketMap {
         map.get(name).map(|v| *v)
     }
 
-    pub fn delete(&mut self, root_path: &Path, name: &str, ver: u32) -> Result<(), Error> {
+    pub fn delete(&self, root_path: &Path, name: &str, ver: u32) -> Result<(), Error> {
         log::debug!("delete name={} {:?}", name, self.map);
         let mut map = self.map.write();
 

crates/mojokv/src/bucket.rs

@@ -5,7 +5,7 @@ use crate::{Error, BucketMap};
 use mojoio::nix::NixFile;
 use crate::index::mem::MemIndex;
 use crate::value::Value;
-use crate::state::KVState;
+use crate::state::State;
 
 pub struct BucketInner {
     name: String,
@@ -39,15 +39,15 @@ impl BucketInner {
 }
 
 pub struct Bucket {
-    state: KVState,
+    state: State,
     //inner: Arc<RwLock<BucketInner>>,
     inner: BucketInner,
     bmap: BucketMap,
     is_write: bool,
 }
 
 impl Bucket {
-    fn with_inner(state: KVState, inner: BucketInner, bmap: BucketMap) -> Self {
+    fn with_inner(state: State, inner: BucketInner, bmap: BucketMap) -> Self {
         Bucket {
             state,
             //inner: Arc::new(RwLock::new(inner)),
@@ -61,7 +61,7 @@ impl Bucket {
         self.is_write = true
     }
 
-    pub fn readonly(root_path: &Path, name: &str, ver: u32, state: KVState, bmap: BucketMap) -> Result<Bucket, Error> {
+    pub fn readonly(root_path: &Path, name: &str, ver: u32, state: State, bmap: BucketMap) -> Result<Bucket, Error> {
         log::debug!("bucket name={} readonly at ver={}", name, ver);
 
         let b = Self::load(root_path, name,  state, bmap, ver)?;
@@ -87,7 +87,7 @@ impl Bucket {
         self.inner.is_modified
     }
 
-    pub fn writable(root_path: &Path, name: &str, state: KVState, bmap: BucketMap, load_ver: u32) -> Result<Bucket, Error> {
+    pub fn writable(root_path: &Path, name: &str, state: State, bmap: BucketMap, load_ver: u32) -> Result<Bucket, Error> {
         log::debug!("mojo initing bucket pps={}", state.pps());
 
         let aver = state.active_ver();
@@ -110,7 +110,7 @@ impl Bucket {
         Ok(b)
     }
 
-    pub fn load(root_path: &Path, name: &str, state: KVState, bmap: BucketMap, ver: u32) -> Result<Self, Error> {
+    pub fn load(root_path: &Path, name: &str, state: State, bmap: BucketMap, ver: u32) -> Result<Self, Error> {
         log::debug!("loading bucket={} version={}", name, ver);
 
         if ver < state.min_ver() || ver > state.active_ver() {
@@ -152,7 +152,7 @@ impl Bucket {
         Ok(index)
     }
 
-    pub fn new(root_path: &Path, name: &str, state: KVState, bmap: BucketMap) -> Result<Self, Error> {
+    pub fn new(root_path: &Path, name: &str, state: State, bmap: BucketMap) -> Result<Self, Error> {
         log::debug!("creating new bucket name={} at ver={}", name, state.active_ver());
 
         let _ = std::fs::create_dir_all(root_path)?;

crates/mojokv/src/index/mod.rs

@@ -1,5 +1,5 @@
 pub mod mem;
-use std::{collections::HashSet, hash::Hash};
+use std::collections::HashSet;
 
 use crate::Error;
 use crate::value::Value;

crates/mojokv/src/keymap.rs

@@ -1,5 +1,5 @@
 
-use std::{collections::HashSet, hash::Hash};
+use std::collections::HashSet;
 use crate::value::{Value, Slot};
 use serde::{Serialize, Deserialize};
 

crates/mojokv/src/lib.rs

@@ -15,7 +15,7 @@ pub use bucket::Bucket;
 pub use bmap::BucketMap;
 pub use keymap::KeyMap;
 pub use value::{Value, Slot};
-pub use store::{KVStore, BucketOpenMode};
+pub use store::{Store, BucketOpenMode};
 
 
 //TODO: Pass pps from single place