fix code so that it doesn't deadlock

2 files changed, 17 insertions, 10 deletions

diff --git a/mumd/src/command.rs b/mumd/src/command.rs
index c3b72bf..8a5c715 100644
--- a/mumd/src/command.rs
+++ b/mumd/src/command.rs
@@ -1,8 +1,9 @@
-use crate::state::{Channel, Server, State};
+use crate::state::{Channel, Server, State, StatePhase};
 
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use tokio::sync::mpsc;
+use log::*;
 
 #[derive(Debug)]
 pub enum Command {
@@ -38,6 +39,13 @@ pub async fn handle(
 ) {
     //TODO err if not connected
     while let Some(command) = command_receiver.recv().await {
-        state.lock().unwrap().handle_command(command).await;
+        debug!("Parsing command {:?}", command);
+        let mut state = state.lock().unwrap();
+        let (wait_for_connected, _) = state.handle_command(command).await;
+        if wait_for_connected {
+            let mut watcher = state.phase_receiver();
+            drop(state);
+            while !matches!(watcher.recv().await.unwrap(), StatePhase::Connected) {}
+        }
     }
 }
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index 8689a9a..84e78f0 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -50,26 +50,26 @@ impl State {
         }
     }
 
-    pub async fn handle_command(&mut self, command: Command) -> Result<Option<CommandResponse>, ()> {
+    pub async fn handle_command(&mut self, command: Command) -> (bool, Result<Option<CommandResponse>, ()>) {
         match command {
             Command::ChannelJoin{channel_id} => {
                 if self.session_id.is_none() {
                     warn!("Tried to join channel but we don't have a session id");
-                    return Err(());
+                    return (false, Err(()));
                 }
                 let mut msg = msgs::UserState::new();
                 msg.set_session(self.session_id.unwrap());
                 msg.set_channel_id(channel_id);
                 self.packet_sender.send(msg.into()).unwrap();
-                Ok(None)
+                (false, Ok(None))
             }
             Command::ChannelList => {
-                Ok(Some(CommandResponse::ChannelList{channels: self.server.channels.clone()}))
+                (false, Ok(Some(CommandResponse::ChannelList{channels: self.server.channels.clone()})))
             }
             Command::ServerConnect{host, port, username, accept_invalid_cert} => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Disconnected) {
                     warn!("Tried to connect to a server while already connected");
-                    return Err(());
+                    return (false, Err(()));
                 }
                 self.username = Some(username);
                 self.phase_watcher.0.broadcast(StatePhase::Connecting).unwrap();
@@ -83,10 +83,9 @@ impl State {
                     host,
                     accept_invalid_cert,
                 )));
-                while !matches!(self.phase_receiver().recv().await.unwrap(), StatePhase::Connected) {}
-                Ok(None)
+                (true, Ok(None))
             }
-            _ => { Ok(None) }
+            _ => { (true, Ok(None)) }
         }
     }