Refactor commands in handle_command for less redundancy in error handling

Description

There were a lot of repetitions involving sending back the result of commands and checking that the result was properly received. By changing the different parts of the match statement in handle_command to use functions returning results instead, we can reduce the redundancy.

Note

Not all match statements have been refactored, because it either doesn't make sense (no redundancy in the given match), or there it is not possible as is due to having to use the sender for the operation as well as the error handling (and we have problems with move of value).

src/dragoon_network.rs

@@ -447,21 +447,15 @@ where
                 listener_id,
                 sender,
             } => {
-                if let Some(listener) = self.listeners.get(&listener_id) {
-                    let res = self.swarm.remove_listener(*listener);
-
-                    debug!("sending result {}", res);
-                    if sender.send(Ok(res)).is_err() {
-                        error!("Could not send remove listener");
-                    }
-                } else {
-                    error!("Listener {} not found", listener_id);
-                    let err = BadListener(format!("Listener {} not found", listener_id));
-
-                    debug!("sending error {}", err);
-                    if sender.send(Err(Box::new(err))).is_err() {
-                        error!("Could not send result");
-                    }
+                if sender
+                    .send(
+                        self.remove_listener(listener_id)
+                            .await
+                            .map_err(|err| err.into()),
+                    )
+                    .is_err()
+                {
+                    error!("Could not send the result of the remove_listener operation")
                 }
             }
             DragoonCommand::GetConnectedPeers { sender } => {
@@ -642,6 +636,16 @@ where
     //     Ok(id)
     // }
 
+    async fn remove_listener(&mut self, listener_id: u64) -> Result<bool> {
+        if let Some(listener) = self.listeners.get(&listener_id) {
+            Ok(self.swarm.remove_listener(*listener))
+        } else {
+            let err_msg = format!("Listener {} not found", listener_id);
+            error!(err_msg);
+            Err(BadListener(err_msg).into())
+        }
+    }
+
     async fn dial(&mut self, multiaddr: String) -> Result<()> {
         if let Ok(addr) = multiaddr.parse::<Multiaddr>() {
             match self.swarm.dial(addr) {