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

@@ -372,51 +372,11 @@ where
         debug!("[cmd] {:?}", cmd);
         match cmd {
             DragoonCommand::Listen { multiaddr, sender } => {
-                if let Ok(addr) = multiaddr.parse() {
-                    match self.swarm.listen_on(addr) {
-                        Ok(listener_id) => {
-                            info!("Listening on {}", multiaddr);
-
-                            let id = regex::Regex::new(r"ListenerId\((\d+)\)")
-                                .unwrap()
-                                .captures(&format!("{:?}", listener_id))
-                                .unwrap()
-                                .get(1)
-                                .unwrap()
-                                .as_str()
-                                .parse::<u64>()
-                                .unwrap();
-                            self.listeners.insert(id, listener_id);
-
-                            debug!("sending id {}", id);
-                            if sender.send(Ok(id)).is_err() {
-                                error!("Could not send listener ID");
-                            }
-                        }
-                        Err(te) => {
-                            let err_msg = match te {
-                                TransportError::Other(e) => e.to_string(),
-                                TransportError::MultiaddrNotSupported(addr) => {
-                                    format!("multiaddr {} not supported", addr)
-                                }
-                            };
-
-                            error!("{}", err_msg);
-
-                            debug!("sending error {}", err_msg);
-                            if sender.send(Err(Box::new(BadListener(err_msg)))).is_err() {
-                                error!("Could not send result");
-                            }
-                        }
-                    }
-                } else {
-                    error!("Could not parse addr {}", multiaddr);
-                    let err = BadListener(format!("Could not parse {}", multiaddr));
-
-                    debug!("sending error {}", err);
-                    if sender.send(Err(Box::new(err))).is_err() {
-                        error!("Could not send result");
-                    }
+                if sender
+                    .send(self.listen(multiaddr).await.map_err(|err| err.into()))
+                    .is_err()
+                {
+                    error!("Could not send the result of the listen operation")
                 }
             }
             DragoonCommand::GetListeners { sender } => {
@@ -636,6 +596,43 @@ where
     //     Ok(id)
     // }
 
+    async fn listen(&mut self, multiaddr: String) -> Result<u64> {
+        if let Ok(addr) = multiaddr.parse() {
+            match self.swarm.listen_on(addr) {
+                Ok(listener_id) => {
+                    info!("Listening on {}", multiaddr);
+
+                    let id = regex::Regex::new(r"ListenerId\((\d+)\)")
+                        .unwrap()
+                        .captures(&format!("{:?}", listener_id))
+                        .unwrap()
+                        .get(1)
+                        .unwrap()
+                        .as_str()
+                        .parse::<u64>()
+                        .unwrap();
+                    self.listeners.insert(id, listener_id);
+
+                    Ok(id)
+                }
+                Err(te) => {
+                    let err_msg = match te {
+                        TransportError::Other(e) => e.to_string(),
+                        TransportError::MultiaddrNotSupported(addr) => {
+                            format!("multiaddr {} not supported", addr)
+                        }
+                    };
+                    error!(err_msg);
+                    Err(BadListener(err_msg).into())
+                }
+            }
+        } else {
+            let err_msg = format!("Could not parse {}", multiaddr);
+            error!(err_msg);
+            Err(BadListener(err_msg).into())
+        }
+    }
+
     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))