add printing of welcome message to server connect

4 files changed, 65 insertions, 38 deletions

diff --git a/mumctl/src/main.rs b/mumctl/src/main.rs
index 1ed48dc..c7b65aa 100644
--- a/mumctl/src/main.rs
+++ b/mumctl/src/main.rs
@@ -185,12 +185,24 @@ fn match_server_connect(matches : &clap::ArgMatches<>) {
         Some(Ok(v)) => Some(v),
     };
     if let Some(port) = port {
-        err_print!(send_command(Command::ServerConnect {
+        match send_command(Command::ServerConnect {
             host: host.to_string(),
             port,
             username: username.to_string(),
             accept_invalid_cert: true, //TODO
-        }));
+        }) {
+            Ok(e) => {
+                if let Some(CommandResponse::ServerConnect { welcome_message }) = e {
+                    println!("Connected to {}", host);
+                    if let Some(message) = welcome_message {
+                        println!("Welcome: {}", message);
+                    }
+                }
+            }
+            Err(e) => {
+                println!("{} {}", "error:".red(), e);
+            }
+        };
     }
 }
 
diff --git a/mumd/src/command.rs b/mumd/src/command.rs
index 5285a9d..075bfaf 100644
--- a/mumd/src/command.rs
+++ b/mumd/src/command.rs
@@ -18,21 +18,21 @@ pub async fn handle(
     debug!("Begin listening for commands");
     while let Some((command, response_sender)) = command_receiver.recv().await {
         debug!("Received command {:?}", command);
-        let mut statee = state.lock().unwrap();
-        let (event_data, command_response) = statee.handle_command(command).await;
-        drop(statee);
-        if let Some((event, callback)) = event_data {
+        let mut state = state.lock().unwrap();
+        let (event, generator) = state.handle_command(command).await;
+        drop(state);
+        if let Some(event) = event {
             let (tx, rx) = oneshot::channel();
-            tcp_event_register_sender.send((event, Box::new(move |e| {
-                println!("något hände");
-                callback(e);
-                response_sender.send(command_response).unwrap();
-                tx.send(());
+            //TODO handle this error
+            let _ = tcp_event_register_sender.send((event, Box::new(move |e| {
+                let response = generator(Some(e));
+                response_sender.send(response).unwrap();
+                tx.send(()).unwrap();
             })));
 
-            rx.await;
+            rx.await.unwrap();
         } else {
-            response_sender.send(command_response).unwrap();
+            response_sender.send(generator(None)).unwrap();
         }
     }
 }
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index c247b08..0822de0 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -14,7 +14,7 @@ use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::net::ToSocketAddrs;
 use tokio::sync::{mpsc, watch};
-use crate::network::tcp::{TcpEventCallback, TcpEvent};
+use crate::network::tcp::{TcpEvent, TcpEventData};
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum StatePhase {
@@ -56,11 +56,11 @@ impl State {
     pub async fn handle_command(
         &mut self,
         command: Command,
-    ) -> (Option<(TcpEvent, TcpEventCallback)>, mumlib::error::Result<Option<CommandResponse>>) {
+    ) -> (Option<TcpEvent>, Box<dyn FnOnce(Option<&TcpEventData>) -> mumlib::error::Result<Option<CommandResponse>>>) {
         match command {
             Command::ChannelJoin { channel_identifier } => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
-                    return (None, Err(Error::DisconnectedError));
+                    return (None, Box::new(|_| Err(Error::DisconnectedError)));
                 }
 
                 let channels = self.server()
@@ -78,33 +78,34 @@ impl State {
                             .filter(|e| e.1.ends_with(&channel_identifier.to_lowercase()))
                             .collect::<Vec<_>>();
                         match soft_matches.len() {
-                            0 => return (None, Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Invalid))),
+                            0 => return (None, Box::new(|_| Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Invalid)))),
                             1 => *soft_matches.get(0).unwrap().0,
-                            _ => return (None, Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Invalid))),
+                            _ => return (None, Box::new(|_| Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Invalid)))),
                         }
                     },
                     1 => *matches.get(0).unwrap().0,
-                    _ => return (None, Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Ambiguous))),
+                    _ => return (None, Box::new(|_| Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Ambiguous)))),
                 };
 
                 let mut msg = msgs::UserState::new();
                 msg.set_session(self.server.as_ref().unwrap().session_id.unwrap());
                 msg.set_channel_id(id);
                 self.packet_sender.send(msg.into()).unwrap();
-                (None, Ok(None))
+                (None, Box::new(|_| Ok(None)))
             }
             Command::ChannelList => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
-                    return (None, Err(Error::DisconnectedError));
+                    return (None, Box::new(|_| Err(Error::DisconnectedError)));
                 }
+                let list = into_channel(
+                    self.server.as_ref().unwrap().channels(),
+                    self.server.as_ref().unwrap().users(),
+                );
                 (
                     None,
-                    Ok(Some(CommandResponse::ChannelList {
-                        channels: into_channel(
-                            self.server.as_ref().unwrap().channels(),
-                            self.server.as_ref().unwrap().users(),
-                        ),
-                    })),
+                    Box::new(move |_| Ok(Some(CommandResponse::ChannelList {
+                        channels: list,
+                    }))),
                 )
             }
             Command::ServerConnect {
@@ -114,7 +115,7 @@ impl State {
                 accept_invalid_cert,
             } => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Disconnected) {
-                    return (None, Err(Error::AlreadyConnectedError));
+                    return (None, Box::new(|_| Err(Error::AlreadyConnectedError)));
                 }
                 let mut server = Server::new();
                 server.username = Some(username);
@@ -132,7 +133,7 @@ impl State {
                     Ok(Some(v)) => v,
                     _ => {
                         warn!("Error parsing server addr");
-                        return (None, Err(Error::InvalidServerAddrError(host, port)));
+                        return (None, Box::new(move |_| Err(Error::InvalidServerAddrError(host, port))));
                     }
                 };
                 self.connection_info_sender
@@ -142,22 +143,35 @@ impl State {
                         accept_invalid_cert,
                     )))
                     .unwrap();
-                (Some((TcpEvent::Connected, Box::new(|_| {}))), Ok(None))
+                (Some(TcpEvent::Connected), Box::new(|e| {
+                    if let Some(TcpEventData::Connected(msg)) = e {
+                        Ok(Some(CommandResponse::ServerConnect {
+                            welcome_message: if msg.has_welcome_text() {
+                                Some(msg.get_welcome_text().to_string())
+                            } else {
+                                None
+                            }
+                        }))
+                    } else {
+                        unreachable!("callback should be provided with a TcpEventData::Connected");
+                    }
+                }))
             }
             Command::Status => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
-                    return (None, Err(Error::DisconnectedError));
+                    return (None, Box::new(|_| Err(Error::DisconnectedError)));
                 }
+                let state = self.server.as_ref().unwrap().into();
                 (
                     None,
-                    Ok(Some(CommandResponse::Status {
-                        server_state: self.server.as_ref().unwrap().into(), //guaranteed not to panic because if we are connected, server is guaranteed to be Some
-                    })),
+                    Box::new(move |_| Ok(Some(CommandResponse::Status {
+                        server_state: state, //guaranteed not to panic because if we are connected, server is guaranteed to be Some
+                    }))),
                 )
             }
             Command::ServerDisconnect => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
-                    return (None, Err(Error::DisconnectedError));
+                    return (None, Box::new(|_| Err(Error::DisconnectedError)));
                 }
 
                 self.server = None;
@@ -167,15 +181,15 @@ impl State {
                     .0
                     .broadcast(StatePhase::Disconnected)
                     .unwrap();
-                (None, Ok(None))
+                (None, Box::new(|_| Ok(None)))
             }
             Command::InputVolumeSet(volume) => {
                 self.audio.set_input_volume(volume);
-                (None, Ok(None))
+                (None, Box::new(|_| Ok(None)))
             }
             Command::ConfigReload => {
                 self.reload_config();
-                (false, Ok(None))
+                (None, Box::new(|_| Ok(None)))
             }
         }
     }
diff --git a/mumlib/src/command.rs b/mumlib/src/command.rs
index 05702f0..e404056 100644
--- a/mumlib/src/command.rs
+++ b/mumlib/src/command.rs
@@ -23,5 +23,6 @@ pub enum Command {
 #[derive(Debug, Deserialize, Serialize)]
 pub enum CommandResponse {
     ChannelList { channels: Channel },
+    ServerConnect { welcome_message: Option<String> },
     Status { server_state: Server },
 }