Implement async API for random-access-storage

This commit moves the API from a sync call into async functions using async_trait.

We would like to use async operations on hypercore, and it would be nice to have the underlying storage using async-io when possible.
As discussed on #97, we could change the API to use async functions on the 'ram' trait.

Async Trait methods are still unstable, but possible using the 'async-trait' crate through a macro.

This PR moves the API to use async-fns. Tests are passing.

Author: bltavares

Cargo.toml

@@ -28,18 +28,20 @@ memory-pager = "0.9.0"
 merkle-tree-stream =  "0.12.0"
 pretty-hash = "0.4.1"
 rand = "0.7.3"
-random-access-disk = "1.1.0"
-random-access-memory = "1.2.0"
-random-access-storage = "3.0.0"
+random-access-disk = "2.0.0"
+random-access-memory = "2.0.0"
+random-access-storage = "4.0.0"
 sha2 = "0.8.1"
 sleep-parser = "0.8.0"
 sparse-bitfield = "0.11.0"
 tree-index = "0.6.0"
 bitfield-rle = "0.1.1"
+futures = "0.3.4"
+async-std = "1.5.0"
 
 [dev-dependencies]
 quickcheck = "0.9.2"
 data-encoding = "2.2.0"
 remove_dir_all = "0.5.2"
 tempfile = "3.1.0"
-async-std = "1.5.0"
+async-std = { version = "1.5.0", features = ["attributes"] }

README.md

@@ -10,13 +10,13 @@ WIP. Secure, distributed, append-only log structure. Adapted from
 
 ## Usage
 ```rust
-let mut feed = hypercore::open("./feed.db")?;
+let mut feed = hypercore::open("./feed.db").await?;
 
-feed.append(b"hello")?;
-feed.append(b"world")?;
+feed.append(b"hello").await?;
+feed.append(b"world").await?;
 
-assert_eq!(feed.get(0)?, Some(b"hello".to_vec()));
-assert_eq!(feed.get(1)?, Some(b"world".to_vec()));
+assert_eq!(feed.get(0).await?, Some(b"hello".to_vec()));
+assert_eq!(feed.get(1).await?, Some(b"world".to_vec()));
 ```
 
 ## Installation

benches/bench.rs

@@ -5,41 +5,51 @@ use anyhow::Error;
 use random_access_memory::RandomAccessMemory;
 use test::Bencher;
 
-use hypercore::{Feed, Storage, Store};
+use hypercore::{Feed, Storage};
 
-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)?)
+async fn create_feed(page_size: usize) -> Result<Feed<RandomAccessMemory>, Error> {
+    let storage =
+        Storage::new(|_| Box::pin(async move { Ok(RandomAccessMemory::new(page_size)) })).await?;
+    Feed::with_storage(storage).await
 }
 
 #[bench]
 fn create(b: &mut Bencher) {
     b.iter(|| {
-        create_feed(1024).unwrap();
+        async_std::task::block_on(async {
+            create_feed(1024).await.unwrap();
+        });
     });
 }
 
 #[bench]
 fn write(b: &mut Bencher) {
-    let mut feed = create_feed(1024).unwrap();
-    let data = Vec::from("hello");
-    b.iter(|| {
-        feed.append(&data).unwrap();
+    async_std::task::block_on(async {
+        let mut feed = create_feed(1024).await.unwrap();
+        let data = Vec::from("hello");
+        b.iter(|| {
+            async_std::task::block_on(async {
+                feed.append(&data).await.unwrap();
+            });
+        });
     });
 }
 
 #[bench]
 fn read(b: &mut Bencher) {
-    let mut feed = create_feed(1024).unwrap();
-    let data = Vec::from("hello");
-    for _ in 0..1000 {
-        feed.append(&data).unwrap();
-    }
+    async_std::task::block_on(async {
+        let mut feed = create_feed(1024).await.unwrap();
+        let data = Vec::from("hello");
+        for _ in 0..1000 {
+            feed.append(&data).await.unwrap();
+        }
 
-    let mut i = 0;
-    b.iter(|| {
-        feed.get(i).unwrap();
-        i += 1;
+        let mut i = 0;
+        b.iter(|| {
+            async_std::task::block_on(async {
+                feed.get(i).await.unwrap();
+                i += 1;
+            });
+        });
     });
 }

examples/async.rs

@@ -5,17 +5,17 @@ use std::fmt::Debug;
 
 async fn append<T>(feed: &mut Feed<T>, content: &[u8])
 where
-    T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug,
+    T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug + Send,
 {
-    feed.append(content).unwrap();
+    feed.append(content).await.unwrap();
 }
 
 async fn print<T>(feed: &mut Feed<T>)
 where
-    T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug,
+    T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug + Send,
 {
-    println!("{:?}", feed.get(0));
-    println!("{:?}", feed.get(1));
+    println!("{:?}", feed.get(0).await);
+    println!("{:?}", feed.get(1).await);
 }
 
 fn main() {

examples/main.rs

@@ -1,11 +1,12 @@
 use hypercore::Feed;
 
-fn main() {
+#[async_std::main]
+async fn main() {
     let mut feed = Feed::default();
 
-    feed.append(b"hello").unwrap();
-    feed.append(b"world").unwrap();
+    feed.append(b"hello").await.unwrap();
+    feed.append(b"world").await.unwrap();
 
-    println!("{:?}", feed.get(0)); // prints "hello"
-    println!("{:?}", feed.get(1)); // prints "world"
+    println!("{:?}", feed.get(0).await); // prints "hello"
+    println!("{:?}", feed.get(1).await); // prints "world"
 }