From 11c823701b12f10933b40044a12cc4048ccf8bd2 Mon Sep 17 00:00:00 2001
From: Eskil Queseth <eskilq@kth.se>
Date: Sat, 31 Oct 2020 02:27:26 +0100
Subject: add support for mumctl server list

---
 mumd/src/command.rs | 53 +++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 37 insertions(+), 16 deletions(-)

(limited to 'mumd/src/command.rs')

diff --git a/mumd/src/command.rs b/mumd/src/command.rs
index d4b25d0..ff53dc7 100644
--- a/mumd/src/command.rs
+++ b/mumd/src/command.rs
@@ -1,4 +1,4 @@
-use crate::state::State;
+use crate::state::{State, ExecutionContext};
 
 use crate::network::tcp::{TcpEvent, TcpEventCallback};
 use ipc_channel::ipc::IpcSender;
@@ -6,6 +6,8 @@ use log::*;
 use mumlib::command::{Command, CommandResponse};
 use std::sync::{Arc, Mutex};
 use tokio::sync::{mpsc, oneshot};
+use mumble_protocol::ping::PongPacket;
+use std::net::SocketAddr;
 
 pub async fn handle(
     state: Arc<Mutex<State>>,
@@ -14,28 +16,47 @@ pub async fn handle(
         IpcSender<mumlib::error::Result<Option<CommandResponse>>>,
     )>,
     tcp_event_register_sender: mpsc::UnboundedSender<(TcpEvent, TcpEventCallback)>,
+    ping_request_sender: mpsc::UnboundedSender<(u64, SocketAddr, Box<dyn FnOnce(PongPacket)>)>,
 ) {
     debug!("Begin listening for commands");
     while let Some((command, response_sender)) = command_receiver.recv().await {
         debug!("Received command {:?}", command);
         let mut state = state.lock().unwrap();
-        let (event, generator) = state.handle_command(command);
+        let event = state.handle_command(command);
         drop(state);
-        if let Some(event) = event {
-            let (tx, rx) = oneshot::channel();
-            //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();
-                }),
-            ));
+        match event {
+            ExecutionContext::TcpEvent(event, generator) => {
+                let (tx, rx) = oneshot::channel();
+                //TODO handle this error
+                let _ = tcp_event_register_sender.send((
+                    event,
+                    Box::new(move |e| {
+                        let response = generator(e);
+                        response_sender.send(response).unwrap();
+                        tx.send(()).unwrap();
+                    }),
+                ));
 
-            rx.await.unwrap();
-        } else {
-            response_sender.send(generator(None)).unwrap();
+                rx.await.unwrap();
+            }
+            ExecutionContext::Now(generator) => {
+                response_sender.send(generator()).unwrap();
+            }
+            ExecutionContext::Ping(generator, converter) => {
+                match generator() {
+                    Ok(addr) => {
+                        let res = ping_request_sender.send((0, addr, Box::new(move |packet| {
+                            response_sender.send(converter(packet)).unwrap();
+                        })));
+                        if res.is_err() {
+                            panic!();
+                        }
+                    },
+                    Err(e) => {
+                        response_sender.send(Err(e)).unwrap();
+                    }
+                };
+            }
         }
     }
 }
-- 
cgit v1.2.1