Merge branch 'server-status' into 'main'

Add support for mumctl server list

Closes #29

See merge request gustav/mum!27

1 files changed, 41 insertions, 14 deletions

diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index 81b6c98..306ded8 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -11,26 +11,40 @@ use crate::network::tcp::{TcpEvent, TcpEventData};
 use log::*;
 use mumble_protocol::control::msgs;
 use mumble_protocol::control::ControlPacket;
+use mumble_protocol::ping::PongPacket;
 use mumble_protocol::voice::Serverbound;
 use mumlib::command::{Command, CommandResponse};
 use mumlib::config::Config;
 use mumlib::error::{ChannelIdentifierError, Error};
 use mumlib::state::UserDiff;
-use std::net::ToSocketAddrs;
+use std::net::{SocketAddr, ToSocketAddrs};
 use tokio::sync::{mpsc, watch};
 
 macro_rules! at {
     ($event:expr, $generator:expr) => {
-        (Some($event), Box::new($generator))
+        ExecutionContext::TcpEvent($event, Box::new($generator))
     };
 }
 
 macro_rules! now {
     ($data:expr) => {
-        (None, Box::new(move |_| $data))
+        ExecutionContext::Now(Box::new(move || $data))
     };
 }
 
+//TODO give me a better name
+pub enum ExecutionContext {
+    TcpEvent(
+        TcpEvent,
+        Box<dyn FnOnce(TcpEventData) -> mumlib::error::Result<Option<CommandResponse>>>,
+    ),
+    Now(Box<dyn FnOnce() -> mumlib::error::Result<Option<CommandResponse>>>),
+    Ping(
+        Box<dyn FnOnce() -> mumlib::error::Result<SocketAddr>>,
+        Box<dyn FnOnce(PongPacket) -> mumlib::error::Result<Option<CommandResponse>>>,
+    ),
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum StatePhase {
     Disconnected,
@@ -68,13 +82,7 @@ impl State {
     }
 
     //TODO? move bool inside Result
-    pub fn handle_command(
-        &mut self,
-        command: Command,
-    ) -> (
-        Option<TcpEvent>,
-        Box<dyn FnOnce(Option<&TcpEventData>) -> mumlib::error::Result<Option<CommandResponse>>>,
-    ) {
+    pub fn handle_command(&mut self, command: Command) -> ExecutionContext {
         match command {
             Command::ChannelJoin { channel_identifier } => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
@@ -128,7 +136,7 @@ impl State {
             }
             Command::ChannelList => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
-                    return (None, Box::new(|_| Err(Error::DisconnectedError)));
+                    return now!(Err(Error::DisconnectedError));
                 }
                 let list = channel::into_channel(
                     self.server.as_ref().unwrap().channels(),
@@ -173,7 +181,7 @@ impl State {
                     .unwrap();
                 at!(TcpEvent::Connected, |e| {
                     //runs the closure when the client is connected
-                    if let Some(TcpEventData::Connected(msg)) = e {
+                    if let TcpEventData::Connected(msg) = e {
                         Ok(Some(CommandResponse::ServerConnect {
                             welcome_message: if msg.has_welcome_text() {
                                 Some(msg.get_welcome_text().to_string())
@@ -217,6 +225,25 @@ impl State {
                 self.reload_config();
                 now!(Ok(None))
             }
+            Command::ServerStatus { host, port } => ExecutionContext::Ping(
+                Box::new(move || {
+                    match (host.as_str(), port)
+                        .to_socket_addrs()
+                        .map(|mut e| e.next())
+                    {
+                        Ok(Some(v)) => Ok(v),
+                        _ => Err(mumlib::error::Error::InvalidServerAddrError(host, port)),
+                    }
+                }),
+                Box::new(move |pong| {
+                    Ok(Some(CommandResponse::ServerStatus {
+                        version: pong.version,
+                        users: pong.users,
+                        max_users: pong.max_users,
+                        bandwidth: pong.bandwidth,
+                    }))
+                }),
+            ),
         }
     }
 
@@ -229,9 +256,9 @@ impl State {
         // check if this is initial state
         if !self.server().unwrap().users().contains_key(&session) {
             self.parse_initial_user_state(session, msg);
-            return None;
+            None
         } else {
-            return Some(self.parse_updated_user_state(session, msg));
+            Some(self.parse_updated_user_state(session, msg))
         }
     }