Refactor command to make is shorter

Description

I noticed that most functions of commands had a similar shape, so I made it more compact by making calls to the same function for all the commands, with different parameters

List of changes

• Factorize the match.receiver by writing a new async function
• Write code to convert to serialize (which was the main thing that didn't allow the previous point)
• Write a macro to further factorize the code that was left in functions

Additional notes

I think that the first two changes should be kept as it's pretty clear was it is done and it organizes the code better. For the macro part, while it indeed shortens the code, macros are generally a bit harder to read and maintain, so we may want to keep code very similar between functions.

The reason for using a macro is that the number of arguments for each variant of DragoonCommand is not always the same, so factorizing means writing a function with a variable number of parameters (thus the macro).

I think it would be interesting to run this first after building it, to check that everything works as intended (since we don't have tests yet).

src/commands.rs

@@ -160,40 +160,39 @@ async fn command_res_match(
     }
 }
 
+macro_rules! dragoon_command {
+    ($state:expr, $variant:ident$(,)? $($t:ident),*) => {
+        {
+        let (sender, receiver) = oneshot::channel();
+
+        let cmd = DragoonCommand::$variant {$($t,)* sender};
+        let cmd_name = cmd.to_string();
+        send_command(cmd, $state).await;
+
+        command_res_match(receiver, cmd_name).await
+        }
+    };
+}
+
+// dragoon_command(state, DragoonCommand::Something, peerid, data)
+
 pub(crate) async fn listen(
     Path(multiaddr): Path<String>,
     State(state): State<Arc<AppState>>,
 ) -> Response {
     info!("running command `listen`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::Listen { multiaddr, sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, Listen, multiaddr)
 }
 
 pub(crate) async fn get_listeners(State(state): State<Arc<AppState>>) -> Response {
     info!("running command `get_listeners`");
-    let (sender, receiver) = oneshot::channel();
+    dragoon_command!(state, GetListeners)
 
-    let cmd = DragoonCommand::GetListeners { sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
 }
 
 pub(crate) async fn get_peer_id(State(state): State<Arc<AppState>>) -> Response {
     info!("running command `get_peer_id`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::GetPeerId { sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, GetPeerId)
 }
 
 #[derive(Serialize, Deserialize)]
@@ -226,13 +225,7 @@ impl SerNetworkInfo {
 
 pub(crate) async fn get_network_info(State(state): State<Arc<AppState>>) -> Response {
     info!("running command `get_network_info`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::GetNetworkInfo { sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, GetNetworkInfo)
 }
 
 pub(crate) async fn remove_listener(
@@ -240,27 +233,12 @@ pub(crate) async fn remove_listener(
     State(state): State<Arc<AppState>>,
 ) -> Response {
     info!("running command `remove_listener`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::RemoveListener {
-        listener_id,
-        sender,
-    };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, RemoveListener, listener_id)
 }
 
 pub(crate) async fn get_connected_peers(State(state): State<Arc<AppState>>) -> Response {
     info!("running command `get_connected_peers`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::GetConnectedPeers { sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, GetConnectedPeers)
 }
 
 pub(crate) async fn dial(
@@ -268,13 +246,7 @@ pub(crate) async fn dial(
     State(state): State<Arc<AppState>>,
 ) -> Response {
     info!("running command `dial`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::Dial { multiaddr, sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, Dial, multiaddr)
 }
 
 pub(crate) async fn add_peer(
@@ -282,13 +254,7 @@ pub(crate) async fn add_peer(
     State(state): State<Arc<AppState>>,
 ) -> Response {
     info!("running command `add_peer`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::AddPeer { multiaddr, sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, AddPeer, multiaddr)
 }
 
 pub(crate) async fn start_provide(
@@ -296,54 +262,29 @@ pub(crate) async fn start_provide(
     State(state): State<Arc<AppState>>,
 ) -> Response {
     info!("running command `start_provide`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::StartProvide { key, sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, StartProvide, key)
 }
 
 pub(crate) async fn dragoon_peers(State(state): State<Arc<AppState>>) -> Response {
-    let (sender, receiver) = oneshot::channel();
-    let cmd = DragoonCommand::DragoonPeers { sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    info!("running command `dragoon_peers`");
+    dragoon_command!(state, DragoonPeers)
 }
 
 pub(crate) async fn dragoon_send(
     Path((peerid, data)): Path<(String, String)>,
     State(state): State<Arc<AppState>>,
 ) -> Response {
-    let (sender, receiver) = oneshot::channel();
-    let cmd = DragoonCommand::DragoonSend {
-        data,
-        peerid,
-        sender,
-    };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    info!("running command `dragoon_send`");
+    dragoon_command!(state, DragoonSend, data, peerid)
 }
 
 pub(crate) async fn dragoon_get(
     Path((peerid, key)): Path<(String, String)>,
     State(state): State<Arc<AppState>>,
 ) -> Response {
-    let (sender, receiver) = oneshot::channel();
-    let cmd = DragoonCommand::DragoonGet {
-        peerid,
-        key,
-        sender,
-    };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
+    info!("running command `dragoon_get`");
+    dragoon_command!(state, DragoonGet, peerid, key)
 
-    command_res_match(receiver, cmd_name).await
 }
 
 pub(crate) async fn get_providers(
@@ -351,24 +292,12 @@ pub(crate) async fn get_providers(
     State(state): State<Arc<AppState>>,
 ) -> Response {
     info!("running command `get_providers`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::GetProviders { key, sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, GetProviders, key)
 }
 
 pub(crate) async fn bootstrap(State(state): State<Arc<AppState>>) -> Response {
     info!("running command `bootstrap`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::Bootstrap { sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, Bootstrap)
 }
 
 #[cfg(feature = "file-sharing")]
@@ -446,17 +375,8 @@ pub(crate) async fn put_record(
     State(state): State<Arc<AppState>>,
 ) -> Response {
     info!("running command `put_record`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::PutRecord {
-        key,
-        value: value.as_bytes().to_vec(),
-        sender,
-    };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    let value = value.as_bytes().to_vec();
+    dragoon_command!(state, PutRecord, key, value)
 }
 
 pub(crate) async fn get_record(
@@ -464,13 +384,7 @@ pub(crate) async fn get_record(
     State(state): State<Arc<AppState>>,
 ) -> Response {
     info!("running command `get_record`");
-    let (sender, receiver) = oneshot::channel();
-
-    let cmd = DragoonCommand::GetRecord { key, sender };
-    let cmd_name = cmd.to_string();
-    send_command(cmd, state).await;
-
-    command_res_match(receiver, cmd_name).await
+    dragoon_command!(state, GetRecord, key)
 }
 
 fn handle_dragoon_error(err: Box<dyn Error + Send>, command: &str) -> Response {