Write `get-file` and commands to get the list of blocks from another node

Description

This closes #1 (closed) by providing an API that allows to get a file with just its hash

Detailed list of changes

• add get_file, get_blocks_info_from and other things related to managing the filesystem
• add new commands to nu API
• remove DragoonBehaviour as it was not useful
• add two new tests for get_file and change the already existing test to use the new API

Note

The get_file is still very rough, the error management needs to be handled better to take into a lot more cases of failure

src/commands.rs

@@ -7,6 +7,7 @@ use libp2p::swarm::NetworkInfo;
 use libp2p::{Multiaddr, PeerId};
 use serde::{Deserialize, Serialize};
 //use std::collections::HashSet;
+use anyhow;
 use std::error::Error;
 use std::sync::Arc;
 use tokio::sync::{
@@ -54,33 +55,46 @@ pub(crate) enum Sender<T> {
     SenderMPSC(SenderMPSC<T>),
 }
 
+impl<T> Sender<T> {
+    pub fn send(&self, value: Result<T, Box<dyn Error + Send>>) -> anyhow::Result<()> {
+        match self {
+            Self::SenderOneS(sender) => sender
+                .send(value)
+                .map_err(|e| anyhow::anyhow!("Could not send value")),
+            Self::SenderMPSC(sender) => sender
+                .send(value)
+                .map_err(|e| anyhow::anyhow!("Could not send value")),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub(crate) enum DragoonCommand {
     AddPeer {
         multiaddr: String,
-        sender: SenderOneS<()>,
+        sender: Sender<()>,
     },
     Bootstrap {
-        sender: SenderOneS<()>,
+        sender: Sender<()>,
     },
     DecodeBlocks {
         block_dir: String,
         block_hashes: Vec<String>,
         output_filename: String,
-        sender: SenderOneS<()>,
+        sender: Sender<()>,
     },
     Dial {
         multiaddr: String,
-        sender: SenderOneS<()>,
+        sender: Sender<()>,
     },
     // DragoonPeers {
-    //     sender: SenderOneS<HashSet<PeerId>>,
+    //     sender: Sender<HashSet<PeerId>>,
     // },
     // DragoonSend {
     //     block_hash: String,
     //     block_path: String,
     //     peerid: String,
-    //     sender: SenderOneS<()>,
+    //     sender: Sender<()>,
     // },
     EncodeFile {
         file_path: String,
@@ -89,56 +103,56 @@ pub(crate) enum DragoonCommand {
         encode_mat_k: usize,
         encode_mat_n: usize,
         powers_path: String,
-        sender: SenderOneS<(String, String)>,
+        sender: Sender<(String, String)>,
     },
     GetBlockFrom {
         peer_id: PeerId,
         file_hash: String,
         block_hash: String,
-        sender: SenderOneS<BlockResponse>,
+        sender: Sender<BlockResponse>,
     },
     GetBlocksInfoFrom {
         peer_id: PeerId,
         file_hash: String,
-        sender: SenderOneS<PeerBlockInfo>,
+        sender: Sender<PeerBlockInfo>,
     },
     GetBlockList {
         file_hash: String,
-        sender: SenderOneS<Vec<String>>,
+        sender: Sender<Vec<String>>,
     },
     GetConnectedPeers {
-        sender: SenderOneS<Vec<PeerId>>,
+        sender: Sender<Vec<PeerId>>,
     },
     GetFile {
         file_hash: String,
         output_filename: String,
         powers_path: String,
-        sender: SenderOneS<String>,
+        sender: Sender<String>,
     },
     GetListeners {
-        sender: SenderOneS<Vec<Multiaddr>>,
+        sender: Sender<Vec<Multiaddr>>,
     },
     GetNetworkInfo {
-        sender: SenderOneS<NetworkInfo>,
+        sender: Sender<NetworkInfo>,
     },
     GetPeerId {
-        sender: SenderOneS<PeerId>,
+        sender: Sender<PeerId>,
     },
     GetProviders {
         key: String,
-        sender: SenderOneS<Vec<PeerId>>,
+        sender: Sender<Vec<PeerId>>,
     },
     Listen {
         multiaddr: String,
-        sender: SenderOneS<u64>,
+        sender: Sender<u64>,
     },
     RemoveListener {
         listener_id: u64,
-        sender: SenderOneS<bool>,
+        sender: Sender<bool>,
     },
     StartProvide {
         key: String,
-        sender: SenderOneS<()>,
+        sender: Sender<()>,
     },
 }
 
@@ -201,6 +215,8 @@ macro_rules! dragoon_command {
         {
         let (sender, receiver) = oneshot::channel(); // create a channel
 
+        let sender = Sender::SenderOneS(sender);
+
         let cmd = DragoonCommand::$variant {$($variant_args,)* sender}; // build the command
         // for example, when calling `dragoon_command!(state, Listen, multiaddr)` the expanded result will be:
         // `let cmd = DragoonCommand::Listen {multiaddr, sender}`