Make dyn storage Send

Author: Frando

src/storage/mod.rs

@@ -30,16 +30,16 @@ pub struct PartialKeypair {
 }
 
 /// Dynamic-dispatch Storage wrapper
-pub type BoxStorage = Box<dyn DynStorage>;
+pub type BoxStorage = Box<dyn DynStorage + Send>;
 
 /// Create a new instance backed by a `RandomAccessMemory` instance.
-pub async fn storage_memory() -> Result<Box<dyn DynStorage>> {
+pub async fn storage_memory() -> Result<Box<dyn DynStorage + Send>> {
     let create = |_| async { Ok(RandomAccessMemory::default()) }.boxed();
     Ok(Storage::new(create, false).await?)
 }
 
 /// Create a new instance backed by a `RandomAccessDisk` instance.
-pub async fn storage_disk(dir: &PathBuf) -> Result<Box<dyn DynStorage>> {
+pub async fn storage_disk(dir: &PathBuf) -> Result<Box<dyn DynStorage + Send>> {
     let storage = |storage: Store| {
         let name = match storage {
             Store::Tree => "tree",
@@ -162,7 +162,7 @@ where
     /// 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 async fn new<Cb>(create: Cb, overwrite: bool) -> Result<Box<dyn DynStorage>>
+    pub async fn new<Cb>(create: Cb, overwrite: bool) -> Result<Box<dyn DynStorage + Send>>
     where
         Cb: Fn(Store) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<T>> + Send>>,
     {

src/storage/node.rs

@@ -70,6 +70,13 @@ impl Node {
         writer.write_u64::<BigEndian>(self.length as u64)?;
         Ok(writer)
     }
+
+    // Write into a provided buffer.
+    // pub fn write(&self, buf: &mut [u8]) -> Result<()> {
+    //     buf[0..32].copy_from_slice(&self.hash);
+    //     (&mut buf[32..]).write_u64::<BigEndian>(self.length as u64)?;
+    //     Ok(())
+    // }
 }
 
 impl NodeTrait for Node {

tests/feed.rs

@@ -3,7 +3,8 @@ extern crate random_access_memory as ram;
 mod common;
 
 use common::create_feed;
-use hypercore::{generate_keypair, Feed, NodeTrait, PublicKey, SecretKey, Storage};
+use hypercore::{generate_keypair, Event, Feed, NodeTrait, PublicKey, SecretKey, Storage};
+use futures::stream::StreamExt;
 use hypercore::{storage_disk, storage_memory};
 use std::env::temp_dir;
 use std::fs;
@@ -27,6 +28,31 @@ async fn display() {
     assert_eq!(output.len(), 61);
 }
 
+#[async_std::test]
+async fn task_send() {
+    use async_std::sync::{Arc, Mutex};
+    use async_std::task;
+    let mut feed = create_feed(50).await.unwrap();
+    feed.append(b"hello").await.unwrap();
+    let feed_arc = Arc::new(Mutex::new(feed));
+    let feed = feed_arc.clone();
+    task::spawn(async move {
+        feed.lock().await.append(b"world").await.unwrap();
+    })
+    .await;
+    let feed = feed_arc.clone();
+    let t1 = task::spawn(async move {
+        let value = feed.lock().await.get(0).await.unwrap();
+        assert_eq!(value, Some(b"hello".to_vec()));
+    });
+    let feed = feed_arc.clone();
+    let t2 = task::spawn(async move {
+        let value = feed.lock().await.get(1).await.unwrap();
+        assert_eq!(value, Some(b"world".to_vec()));
+    });
+    futures::future::join_all(vec![t1, t2]).await;
+}
+
 #[async_std::test]
 /// Verify `.append()` and `.get()` work.
 async fn set_get() {
@@ -162,13 +188,17 @@ async fn put_with_data() {
     let mut a = create_feed(50).await.unwrap();
 
     // Create a second feed with the first feed's key.
+<<<<<<< HEAD
     let (public, secret) = copy_keys(&a);
     let storage = storage_memory().await.unwrap();
     let mut b = Feed::builder(public, storage)
         .secret_key(secret)
         .build()
         .await
         .unwrap();
+=======
+    let mut b = create_clone(&a).await.unwrap();
+>>>>>>> c79679a... Make dyn storage Send
 
     // Append 4 blocks of data to the writable feed.
     a.append(b"hi").await.unwrap();
@@ -226,6 +256,7 @@ async fn create_with_stored_keys() {
     );
 }
 
+<<<<<<< HEAD
 fn copy_keys(feed: &Feed) -> (PublicKey, SecretKey) {
     match &feed.secret_key() {
         Some(secret) => {
@@ -241,6 +272,8 @@ fn copy_keys(feed: &Feed) -> (PublicKey, SecretKey) {
     }
 }
 
+=======
+>>>>>>> c79679a... Make dyn storage Send
 #[async_std::test]
 async fn audit() {
     let mut feed = create_feed(50).await.unwrap();