2019-05-20 08:01:51 +00:00
|
|
|
// mod disk_db;
|
|
|
|
mod block_at_slot;
|
|
|
|
mod errors;
|
|
|
|
mod impls;
|
2019-05-21 06:29:34 +00:00
|
|
|
mod leveldb_store;
|
2019-02-14 01:09:18 +00:00
|
|
|
mod memory_db;
|
|
|
|
|
2019-05-21 06:29:34 +00:00
|
|
|
pub use self::leveldb_store::LevelDB;
|
2019-02-14 01:09:18 +00:00
|
|
|
pub use self::memory_db::MemoryDB;
|
2019-05-20 08:01:51 +00:00
|
|
|
pub use errors::Error;
|
|
|
|
pub use types::*;
|
|
|
|
pub type DBValue = Vec<u8>;
|
|
|
|
|
|
|
|
pub trait Store: Sync + Send + Sized {
|
|
|
|
fn put(&self, key: &Hash256, item: &impl StoreItem) -> Result<(), Error> {
|
|
|
|
item.db_put(self, key)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get<I: StoreItem>(&self, key: &Hash256) -> Result<Option<I>, Error> {
|
|
|
|
I::db_get(self, key)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn exists<I: StoreItem>(&self, key: &Hash256) -> Result<bool, Error> {
|
|
|
|
I::db_exists(self, key)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn delete<I: StoreItem>(&self, key: &Hash256) -> Result<(), Error> {
|
|
|
|
I::db_delete(self, key)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_block_at_preceeding_slot(
|
|
|
|
&self,
|
|
|
|
start_block_root: Hash256,
|
2019-05-21 02:58:11 +00:00
|
|
|
slot: Slot,
|
2019-05-20 08:01:51 +00:00
|
|
|
) -> Result<Option<(Hash256, BeaconBlock)>, Error> {
|
|
|
|
block_at_slot::get_block_at_preceeding_slot(self, slot, start_block_root)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_bytes(&self, col: &str, key: &[u8]) -> Result<Option<DBValue>, Error>;
|
|
|
|
|
|
|
|
fn put_bytes(&self, col: &str, key: &[u8], val: &[u8]) -> Result<(), Error>;
|
|
|
|
|
|
|
|
fn key_exists(&self, col: &str, key: &[u8]) -> Result<bool, Error>;
|
|
|
|
|
|
|
|
fn key_delete(&self, col: &str, key: &[u8]) -> Result<(), Error>;
|
|
|
|
}
|
|
|
|
|
|
|
|
pub enum DBColumn {
|
|
|
|
BeaconBlock,
|
|
|
|
BeaconState,
|
|
|
|
BeaconChain,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> Into<&'a str> for DBColumn {
|
|
|
|
/// Returns a `&str` that can be used for keying a key-value data base.
|
|
|
|
fn into(self) -> &'a str {
|
|
|
|
match self {
|
|
|
|
DBColumn::BeaconBlock => &"blk",
|
|
|
|
DBColumn::BeaconState => &"ste",
|
|
|
|
DBColumn::BeaconChain => &"bch",
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub trait StoreItem: Sized {
|
|
|
|
fn db_column() -> DBColumn;
|
|
|
|
|
|
|
|
fn as_store_bytes(&self) -> Vec<u8>;
|
|
|
|
|
|
|
|
fn from_store_bytes(bytes: &mut [u8]) -> Result<Self, Error>;
|
|
|
|
|
|
|
|
fn db_put(&self, store: &impl Store, key: &Hash256) -> Result<(), Error> {
|
|
|
|
let column = Self::db_column().into();
|
|
|
|
let key = key.as_bytes();
|
|
|
|
|
|
|
|
store
|
|
|
|
.put_bytes(column, key, &self.as_store_bytes())
|
|
|
|
.map_err(|e| e.into())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn db_get(store: &impl Store, key: &Hash256) -> Result<Option<Self>, Error> {
|
|
|
|
let column = Self::db_column().into();
|
|
|
|
let key = key.as_bytes();
|
|
|
|
|
|
|
|
match store.get_bytes(column, key)? {
|
|
|
|
Some(mut bytes) => Ok(Some(Self::from_store_bytes(&mut bytes[..])?)),
|
|
|
|
None => Ok(None),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn db_exists(store: &impl Store, key: &Hash256) -> Result<bool, Error> {
|
|
|
|
let column = Self::db_column().into();
|
|
|
|
let key = key.as_bytes();
|
|
|
|
|
|
|
|
store.key_exists(column, key)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn db_delete(store: &impl Store, key: &Hash256) -> Result<(), Error> {
|
|
|
|
let column = Self::db_column().into();
|
|
|
|
let key = key.as_bytes();
|
|
|
|
|
|
|
|
store.key_delete(column, key)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
use ssz::{Decode, Encode};
|
|
|
|
use ssz_derive::{Decode, Encode};
|
2019-05-21 06:29:34 +00:00
|
|
|
use tempfile::tempdir;
|
2019-05-20 08:01:51 +00:00
|
|
|
|
|
|
|
#[derive(PartialEq, Debug, Encode, Decode)]
|
|
|
|
struct StorableThing {
|
|
|
|
a: u64,
|
|
|
|
b: u64,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl StoreItem for StorableThing {
|
|
|
|
fn db_column() -> DBColumn {
|
|
|
|
DBColumn::BeaconBlock
|
|
|
|
}
|
|
|
|
|
|
|
|
fn as_store_bytes(&self) -> Vec<u8> {
|
|
|
|
self.as_ssz_bytes()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn from_store_bytes(bytes: &mut [u8]) -> Result<Self, Error> {
|
|
|
|
Self::from_ssz_bytes(bytes).map_err(Into::into)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-21 06:37:15 +00:00
|
|
|
fn test_impl(store: impl Store) {
|
2019-05-21 06:29:34 +00:00
|
|
|
let key = Hash256::random();
|
|
|
|
let item = StorableThing { a: 1, b: 42 };
|
|
|
|
|
2019-05-21 06:37:15 +00:00
|
|
|
assert_eq!(store.exists::<StorableThing>(&key), Ok(false));
|
|
|
|
|
2019-05-21 06:29:34 +00:00
|
|
|
store.put(&key, &item).unwrap();
|
|
|
|
|
2019-05-21 06:37:15 +00:00
|
|
|
assert_eq!(store.exists::<StorableThing>(&key), Ok(true));
|
2019-05-21 06:29:34 +00:00
|
|
|
|
2019-05-21 06:37:15 +00:00
|
|
|
let retrieved = store.get(&key).unwrap().unwrap();
|
2019-05-21 06:29:34 +00:00
|
|
|
assert_eq!(item, retrieved);
|
2019-05-21 06:37:15 +00:00
|
|
|
|
|
|
|
store.delete::<StorableThing>(&key).unwrap();
|
|
|
|
|
|
|
|
assert_eq!(store.exists::<StorableThing>(&key), Ok(false));
|
|
|
|
|
|
|
|
assert_eq!(store.get::<StorableThing>(&key), Ok(None));
|
2019-05-21 06:29:34 +00:00
|
|
|
}
|
|
|
|
|
2019-05-20 08:01:51 +00:00
|
|
|
#[test]
|
2019-05-21 06:37:15 +00:00
|
|
|
fn leveldb() {
|
|
|
|
let dir = tempdir().unwrap();
|
|
|
|
let path = dir.path();
|
|
|
|
let store = LevelDB::open(&path).unwrap();
|
2019-05-20 08:01:51 +00:00
|
|
|
|
2019-05-21 06:37:15 +00:00
|
|
|
test_impl(store);
|
|
|
|
}
|
2019-05-20 08:01:51 +00:00
|
|
|
|
2019-05-21 06:37:15 +00:00
|
|
|
#[test]
|
|
|
|
fn memorydb() {
|
|
|
|
let store = MemoryDB::open();
|
2019-05-20 08:01:51 +00:00
|
|
|
|
2019-05-21 06:37:15 +00:00
|
|
|
test_impl(store);
|
2019-05-20 08:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn exists() {
|
|
|
|
let store = MemoryDB::open();
|
|
|
|
let key = Hash256::random();
|
|
|
|
let item = StorableThing { a: 1, b: 42 };
|
|
|
|
|
|
|
|
assert_eq!(store.exists::<StorableThing>(&key).unwrap(), false);
|
|
|
|
|
|
|
|
store.put(&key, &item).unwrap();
|
|
|
|
|
|
|
|
assert_eq!(store.exists::<StorableThing>(&key).unwrap(), true);
|
|
|
|
|
|
|
|
store.delete::<StorableThing>(&key).unwrap();
|
2019-02-27 23:24:27 +00:00
|
|
|
|
2019-05-20 08:01:51 +00:00
|
|
|
assert_eq!(store.exists::<StorableThing>(&key).unwrap(), false);
|
|
|
|
}
|
2019-02-27 23:24:27 +00:00
|
|
|
}
|