Upgrade random-access-storage (#26)

Signed-off-by: Szabolcs Berecz <szabolcs.berecz@gmail.com>

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"

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<Feed<RandomAccessMemoryMethods>, Error> {
-  let create = |_store: Store| RandomAccessMemory::new(page_size);
+fn create_feed(page_size: usize) -> Result<Feed<RandomAccessMemory>, Error> {
+  let create = |_store: Store| Ok(RandomAccessMemory::new(page_size));
   let storage = Storage::new(create)?;
   Ok(Feed::with_storage(storage)?)
 }

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<T>
 where
-  T: RandomAccessMethods<Error = Error> + Debug,
+  T: RandomAccess<Error = Error> + Debug,
 {
   /// Merkle tree instance.
   pub(crate) merkle: Merkle,
@@ -47,7 +47,7 @@ where
 
 impl<T> Feed<T>
 where
-  T: RandomAccessMethods<Error = Error> + Debug,
+  T: RandomAccess<Error = Error> + Debug,
 {
   /// Create a new instance with a custom storage backend.
   pub fn with_storage(mut storage: ::storage::Storage<T>) -> Result<Self> {
@@ -540,7 +540,7 @@ where
   }
 }
 
-impl Feed<RandomAccessDiskMethods> {
+impl Feed<RandomAccessDisk> {
   /// 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<RandomAccessDiskMethods> {
 /// ## Panics
 /// Can panic if constructing the in-memory store fails, which is highly
 /// unlikely.
-impl Default for Feed<RandomAccessMemoryMethods> {
+impl Default for Feed<RandomAccessMemory> {
   fn default() -> Self {
     let storage = Storage::new_memory().unwrap();
     Self::with_storage(storage).unwrap()
   }
 }
 
-impl<T: RandomAccessMethods<Error = Error> + Debug> Display for Feed<T> {
+impl<T: RandomAccess<Error = Error> + Debug> Display for Feed<T> {
   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>`.

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<T>
 where
-  T: RandomAccessMethods + Debug,
+  T: RandomAccess + Debug,
 {
   storage: Storage<T>,
   public_key: PublicKey,
@@ -26,7 +26,7 @@ where
 
 impl<T> FeedBuilder<T>
 where
-  T: RandomAccessMethods<Error = Error> + Debug,
+  T: RandomAccess<Error = Error> + Debug,
 {
   /// Create a new instance.
   #[inline]

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,33 +49,33 @@ pub enum Store {
 #[derive(Debug)]
 pub struct Storage<T>
 where
-  T: RandomAccessMethods + Debug,
+  T: RandomAccess + Debug,
 {
-  tree: RandomAccess<T>,
-  data: RandomAccess<T>,
-  bitfield: RandomAccess<T>,
-  signatures: RandomAccess<T>,
-  keypair: RandomAccess<T>,
+  tree: T,
+  data: T,
+  bitfield: T,
+  signatures: T,
+  keypair: T,
 }
 
 impl<T> Storage<T>
 where
-  T: RandomAccessMethods<Error = Error> + Debug,
+  T: RandomAccess<Error = Error> + Debug,
 {
   /// Create a new instance. Takes a keypair and a callback to create new
   /// storage instances.
   // Named `.open()` in the JS version. Replaces the `.openKey()` method too by
   // requiring a key pair to be initialized before creating a new instance.
   pub fn new<Cb>(create: Cb) -> Result<Self>
   where
-    Cb: Fn(Store) -> RandomAccess<T>,
+    Cb: Fn(Store) -> Result<T>,
   {
     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<RandomAccessMemoryMethods> {
+impl Storage<RandomAccessMemory> {
   pub fn new_memory() -> Result<Self> {
-    let create = |_| RandomAccessMemory::default();
+    let create = |_| Ok(RandomAccessMemory::default());
     Ok(Self::new(create)?)
   }
 }
 
-impl Storage<RandomAccessDiskMethods> {
+impl Storage<RandomAccessDisk> {
   pub fn new_disk(dir: &PathBuf) -> Result<Self> {
     let storage = |storage: Store| {
       let name = match storage {
@@ -308,7 +308,7 @@ impl Storage<RandomAccessDiskMethods> {
         Store::Signatures => "signatures",
         Store::Keypair => "key",
       };
-      RandomAccessDisk::new(dir.as_path().join(name))
+      RandomAccessDisk::open(dir.as_path().join(name))
     };
     Ok(Self::new(storage)?)
   }

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<T>
 where
-  T: RandomAccessMethods + Debug,
+  T: RandomAccess + Debug,
 {
   /// Create an instance from a byte vector.
   fn from_bytes(index: usize, buf: &[u8]) -> Self;

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<P: AsRef<Path>>(dir: P, s: Store) -> PathBuf {
   dir.as_ref().join(filename)
 }
 
-fn mk_storage() -> (PathBuf, Storage<RandomAccessDiskMethods>) {
+fn mk_storage() -> (PathBuf, Storage<RandomAccessDisk>) {
   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)
 }

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."

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<Feed<ram::RandomAccessMemoryMethods>, Error> {
-  let create = |_store: Store| ram::RandomAccessMemory::new(page_size);
+) -> Result<Feed<ram::RandomAccessMemory>, 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<impl RandomAccessMethods<Error = Error> + Debug>,
+  feed: &Feed<impl RandomAccess<Error = Error> + Debug>,
 ) -> (PublicKey, SecretKey) {
   match &feed.secret_key() {
     Some(secret) => {