From 420a3b19b0daa7d32d96c3c67045adab10c0f38d Mon Sep 17 00:00:00 2001 From: Szabolcs Berecz Date: Fri, 31 Aug 2018 15:40:59 +0200 Subject: [PATCH] Upgrade random-access-storage (#26) Signed-off-by: Szabolcs Berecz --- Cargo.toml | 6 +++--- benches/bench.rs | 8 +++----- src/feed.rs | 16 ++++++++-------- src/feed_builder.rs | 6 +++--- src/storage/mod.rs | 40 ++++++++++++++++++++-------------------- src/storage/persist.rs | 4 ++-- tests/compat.rs | 6 +++--- tests/feed.rs | 10 +++++----- tests/helpers.rs | 8 ++++---- 9 files changed, 51 insertions(+), 53 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index e2aa238..29c7ca7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -19,9 +19,9 @@ memory-pager = "0.7.0" merkle-tree-stream = "0.5.0" pretty-hash = "0.2.0" rand = "0.4.2" -random-access-disk = "0.5.0" -random-access-memory = "0.4.0" -random-access-storage = "0.5.0" +random-access-disk = "0.6.0" +random-access-memory = "0.5.0" +random-access-storage = "0.6.0" sha2 = "0.7.1" sleep-parser = "0.6.0" sparse-bitfield = "0.8.0" diff --git a/benches/bench.rs b/benches/bench.rs index b8835fc..7f706bd 100644 --- a/benches/bench.rs +++ b/benches/bench.rs @@ -9,12 +9,10 @@ extern crate test; use self::test::Bencher; use failure::Error; use hypercore::{Feed, Storage, Store}; -use ram::{RandomAccessMemory, RandomAccessMemoryMethods}; +use ram::RandomAccessMemory; -fn create_feed( - page_size: usize, -) -> Result, Error> { - let create = |_store: Store| RandomAccessMemory::new(page_size); +fn create_feed(page_size: usize) -> Result, Error> { + let create = |_store: Store| Ok(RandomAccessMemory::new(page_size)); let storage = Storage::new(create)?; Ok(Feed::with_storage(storage)?) } diff --git a/src/feed.rs b/src/feed.rs index fd63ebf..9abe6e0 100644 --- a/src/feed.rs +++ b/src/feed.rs @@ -11,9 +11,9 @@ use failure::Error; use flat_tree as flat; use pretty_hash::fmt as pretty_fmt; use proof::Proof; -use random_access_disk::RandomAccessDiskMethods; -use random_access_memory::RandomAccessMemoryMethods; -use random_access_storage::RandomAccessMethods; +use random_access_disk::RandomAccessDisk; +use random_access_memory::RandomAccessMemory; +use random_access_storage::RandomAccess; use tree_index::TreeIndex; use Result; @@ -28,7 +28,7 @@ use std::rc::Rc; #[derive(Debug)] pub struct Feed where - T: RandomAccessMethods + Debug, + T: RandomAccess + Debug, { /// Merkle tree instance. pub(crate) merkle: Merkle, @@ -47,7 +47,7 @@ where impl Feed where - T: RandomAccessMethods + Debug, + T: RandomAccess + Debug, { /// Create a new instance with a custom storage backend. pub fn with_storage(mut storage: ::storage::Storage) -> Result { @@ -540,7 +540,7 @@ where } } -impl Feed { +impl Feed { /// Create a new instance that persists to disk at the location of `dir`. // TODO: Ensure that dir is always a directory. // NOTE: Should we `mkdirp` here? @@ -556,14 +556,14 @@ impl Feed { /// ## Panics /// Can panic if constructing the in-memory store fails, which is highly /// unlikely. -impl Default for Feed { +impl Default for Feed { fn default() -> Self { let storage = Storage::new_memory().unwrap(); Self::with_storage(storage).unwrap() } } -impl + Debug> Display for Feed { +impl + Debug> Display for Feed { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // TODO: yay, we should find a way to convert this .unwrap() to an error // type that's accepted by `fmt::Result<(), fmt::Error>`. diff --git a/src/feed_builder.rs b/src/feed_builder.rs index c80b86b..bc0e2a7 100644 --- a/src/feed_builder.rs +++ b/src/feed_builder.rs @@ -3,7 +3,7 @@ use ed25519_dalek::{PublicKey, SecretKey}; use bitfield::Bitfield; use crypto::Merkle; use failure::Error; -use random_access_storage::RandomAccessMethods; +use random_access_storage::RandomAccess; use std::fmt::Debug; use storage::Storage; use tree_index::TreeIndex; @@ -17,7 +17,7 @@ use Result; #[derive(Debug)] pub struct FeedBuilder where - T: RandomAccessMethods + Debug, + T: RandomAccess + Debug, { storage: Storage, public_key: PublicKey, @@ -26,7 +26,7 @@ where impl FeedBuilder where - T: RandomAccessMethods + Debug, + T: RandomAccess + Debug, { /// Create a new instance. #[inline] diff --git a/src/storage/mod.rs b/src/storage/mod.rs index d7353c4..2daade6 100644 --- a/src/storage/mod.rs +++ b/src/storage/mod.rs @@ -12,9 +12,9 @@ use ed25519_dalek::{ }; use failure::Error; use flat_tree as flat; -use random_access_disk::{RandomAccessDisk, RandomAccessDiskMethods}; -use random_access_memory::{RandomAccessMemory, RandomAccessMemoryMethods}; -use random_access_storage::{RandomAccess, RandomAccessMethods}; +use random_access_disk::RandomAccessDisk; +use random_access_memory::RandomAccessMemory; +use random_access_storage::RandomAccess; use sleep_parser::*; use std::borrow::Borrow; use std::fmt::Debug; @@ -49,18 +49,18 @@ pub enum Store { #[derive(Debug)] pub struct Storage where - T: RandomAccessMethods + Debug, + T: RandomAccess + Debug, { - tree: RandomAccess, - data: RandomAccess, - bitfield: RandomAccess, - signatures: RandomAccess, - keypair: RandomAccess, + tree: T, + data: T, + bitfield: T, + signatures: T, + keypair: T, } impl Storage where - T: RandomAccessMethods + Debug, + T: RandomAccess + Debug, { /// Create a new instance. Takes a keypair and a callback to create new /// storage instances. @@ -68,14 +68,14 @@ where // requiring a key pair to be initialized before creating a new instance. pub fn new(create: Cb) -> Result where - Cb: Fn(Store) -> RandomAccess, + Cb: Fn(Store) -> Result, { let mut instance = Self { - tree: create(Store::Tree), - data: create(Store::Data), - bitfield: create(Store::Bitfield), - signatures: create(Store::Signatures), - keypair: create(Store::Keypair), + tree: create(Store::Tree)?, + data: create(Store::Data)?, + bitfield: create(Store::Bitfield)?, + signatures: create(Store::Signatures)?, + keypair: create(Store::Keypair)?, }; let header = create_bitfield(); @@ -291,14 +291,14 @@ where } } -impl Storage { +impl Storage { pub fn new_memory() -> Result { - let create = |_| RandomAccessMemory::default(); + let create = |_| Ok(RandomAccessMemory::default()); Ok(Self::new(create)?) } } -impl Storage { +impl Storage { pub fn new_disk(dir: &PathBuf) -> Result { let storage = |storage: Store| { let name = match storage { @@ -308,7 +308,7 @@ impl Storage { Store::Signatures => "signatures", Store::Keypair => "key", }; - RandomAccessDisk::new(dir.as_path().join(name)) + RandomAccessDisk::open(dir.as_path().join(name)) }; Ok(Self::new(storage)?) } diff --git a/src/storage/persist.rs b/src/storage/persist.rs index 647d6a3..6fa8014 100644 --- a/src/storage/persist.rs +++ b/src/storage/persist.rs @@ -1,12 +1,12 @@ use super::Storage; -use random_access_storage::RandomAccessMethods; +use random_access_storage::RandomAccess; use std::fmt::Debug; use Result; /// Persist data to a `Storage` instance. pub trait Persist where - T: RandomAccessMethods + Debug, + T: RandomAccess + Debug, { /// Create an instance from a byte vector. fn from_bytes(index: usize, buf: &[u8]) -> Self; diff --git a/tests/compat.rs b/tests/compat.rs index 44f9cfa..31f3c18 100644 --- a/tests/compat.rs +++ b/tests/compat.rs @@ -16,7 +16,7 @@ use data_encoding::HEXLOWER; use ed25519_dalek::Keypair; use hypercore::Feed; use hypercore::{Storage, Store}; -use random_access_disk::{RandomAccessDisk, RandomAccessDiskMethods}; +use random_access_disk::RandomAccessDisk; use remove_dir_all::remove_dir_all; #[test] @@ -120,11 +120,11 @@ fn storage_path>(dir: P, s: Store) -> PathBuf { dir.as_ref().join(filename) } -fn mk_storage() -> (PathBuf, Storage) { +fn mk_storage() -> (PathBuf, Storage) { let temp_dir = tempfile::tempdir().unwrap(); let dir = temp_dir.into_path(); let storage = - Storage::new(|s| RandomAccessDisk::new(storage_path(dir.clone(), s))) + Storage::new(|s| RandomAccessDisk::open(storage_path(dir.clone(), s))) .unwrap(); (dir, storage) } diff --git a/tests/feed.rs b/tests/feed.rs index c3daada..79738f0 100644 --- a/tests/feed.rs +++ b/tests/feed.rs @@ -82,7 +82,7 @@ fn verify() { let mut feed = create_feed(50).unwrap(); let (public, secret) = copy_keys(&feed); let feed_bytes = secret.to_bytes().to_vec(); - let storage = Storage::new(|_| ram::RandomAccessMemory::new(50)).unwrap(); + let storage = Storage::new(|_| Ok(ram::RandomAccessMemory::new(50))).unwrap(); let mut evil_feed = Feed::builder(public, storage) .secret_key(secret) .build() @@ -111,7 +111,7 @@ fn verify() { fn put() { let mut a = create_feed(50).unwrap(); let (public, secret) = copy_keys(&a); - let storage = Storage::new(|_| ram::RandomAccessMemory::new(50)).unwrap(); + let storage = Storage::new(|_| Ok(ram::RandomAccessMemory::new(50))).unwrap(); let mut b = Feed::builder(public, storage) .secret_key(secret) .build() @@ -142,7 +142,7 @@ fn create_with_storage() { fn create_with_stored_public_key() { let mut storage = Storage::new_memory().unwrap(); let keypair = generate_keypair(); - storage.write_public_key(&keypair.public); + storage.write_public_key(&keypair.public).unwrap(); assert!( Feed::with_storage(storage).is_ok(), "Could not create a feed with a stored public key." @@ -153,8 +153,8 @@ fn create_with_stored_public_key() { fn create_with_stored_keys() { let mut storage = Storage::new_memory().unwrap(); let keypair = generate_keypair(); - storage.write_public_key(&keypair.public); - storage.write_secret_key(&keypair.secret); + storage.write_public_key(&keypair.public).unwrap(); + storage.write_secret_key(&keypair.secret).unwrap(); assert!( Feed::with_storage(storage).is_ok(), "Could not create a feed with a stored keypair." diff --git a/tests/helpers.rs b/tests/helpers.rs index e4ede49..59e452d 100644 --- a/tests/helpers.rs +++ b/tests/helpers.rs @@ -4,20 +4,20 @@ extern crate random_access_memory as ram; extern crate random_access_storage; use self::failure::Error; -use self::random_access_storage::RandomAccessMethods; +use self::random_access_storage::RandomAccess; use hypercore::{Feed, PublicKey, SecretKey, Storage, Store}; use std::fmt::Debug; pub fn create_feed( page_size: usize, -) -> Result, Error> { - let create = |_store: Store| ram::RandomAccessMemory::new(page_size); +) -> Result, Error> { + let create = |_store: Store| Ok(ram::RandomAccessMemory::new(page_size)); let storage = Storage::new(create)?; Ok(Feed::with_storage(storage)?) } pub fn copy_keys( - feed: &Feed + Debug>, + feed: &Feed + Debug>, ) -> (PublicKey, SecretKey) { match &feed.secret_key() { Some(secret) => {