move mumble backend code to new client

3 files changed, 60 insertions, 40 deletions

diff --git a/mumd/src/client.rs b/mumd/src/client.rs
new file mode 100644
index 0000000..74e744f
--- /dev/null
+++ b/mumd/src/client.rs
@@ -0,0 +1,52 @@
+use crate::command;
+use crate::network::{tcp, udp, ConnectionInfo};
+use crate::state::State;
+
+use futures_util::join;
+use ipc_channel::ipc::IpcSender;
+use mumble_protocol::{Serverbound, control::ControlPacket, crypt::ClientCryptState};
+use mumlib::command::{Command, CommandResponse};
+use std::sync::{Arc, Mutex};
+use tokio::sync::{mpsc, watch};
+
+pub async fn handle(
+    command_receiver: mpsc::UnboundedReceiver<(
+        Command,
+        IpcSender<mumlib::error::Result<Option<CommandResponse>>>,
+    )>,
+) {
+    let (connection_info_sender, connection_info_receiver) =
+        watch::channel::<Option<ConnectionInfo>>(None);
+    let (crypt_state_sender, crypt_state_receiver) =
+        mpsc::channel::<ClientCryptState>(1);
+    let (packet_sender, packet_receiver) =
+        mpsc::unbounded_channel::<ControlPacket<Serverbound>>();
+    let (ping_request_sender, ping_request_receiver) =
+        mpsc::unbounded_channel();
+    let (response_sender, response_receiver) =
+        mpsc::unbounded_channel();
+
+    let state = State::new(packet_sender, connection_info_sender);
+    let state = Arc::new(Mutex::new(state));
+    join!(
+        tcp::handle(
+            Arc::clone(&state),
+            connection_info_receiver.clone(),
+            crypt_state_sender,
+            packet_receiver,
+            response_receiver,
+        ),
+        udp::handle(
+            Arc::clone(&state),
+            connection_info_receiver.clone(),
+            crypt_state_receiver,
+        ),
+        command::handle(
+            state,
+            command_receiver,
+            response_sender,
+            ping_request_sender,
+        ),
+        udp::handle_pings(ping_request_receiver),
+    );
+}
diff --git a/mumd/src/main.rs b/mumd/src/main.rs
index db6d2ef..67481f9 100644
--- a/mumd/src/main.rs
+++ b/mumd/src/main.rs
@@ -1,23 +1,17 @@
 mod audio;
+mod client;
 mod command;
 mod network;
 mod notify;
 mod state;
 
-use crate::network::ConnectionInfo;
-use crate::state::State;
-
 use futures::join;
 use ipc_channel::ipc::{self, IpcOneShotServer, IpcSender};
 use log::*;
-use mumble_protocol::control::ControlPacket;
-use mumble_protocol::crypt::ClientCryptState;
-use mumble_protocol::voice::Serverbound;
 use mumlib::command::{Command, CommandResponse};
 use mumlib::setup_logger;
 use std::fs;
-use std::sync::{Arc, Mutex};
-use tokio::sync::{mpsc, watch};
+use tokio::sync::mpsc;
 use tokio::task::spawn_blocking;
 
 #[tokio::main]
@@ -45,46 +39,17 @@ async fn main() {
         }
     }
 
-    // Oneshot channel for setting UDP CryptState from control task
-    // For simplicity we don't deal with re-syncing, real applications would have to.
-    let (crypt_state_sender, crypt_state_receiver) = mpsc::channel::<ClientCryptState>(1); // crypt state should always be consumed before sending a new one
-    let (packet_sender, packet_receiver) = mpsc::unbounded_channel::<ControlPacket<Serverbound>>();
     let (command_sender, command_receiver) = mpsc::unbounded_channel::<(
         Command,
         IpcSender<mumlib::error::Result<Option<CommandResponse>>>,
     )>();
-    let (connection_info_sender, connection_info_receiver) =
-        watch::channel::<Option<ConnectionInfo>>(None);
-    let (response_sender, response_receiver) = mpsc::unbounded_channel();
-    let (ping_request_sender, ping_request_receiver) = mpsc::unbounded_channel();
-
-    let state = State::new(packet_sender, connection_info_sender);
-    let state = Arc::new(Mutex::new(state));
 
-    let (_, _, _, e, _) = join!(
-        network::tcp::handle(
-            Arc::clone(&state),
-            connection_info_receiver.clone(),
-            crypt_state_sender,
-            packet_receiver,
-            response_receiver,
-        ),
-        network::udp::handle(
-            Arc::clone(&state),
-            connection_info_receiver.clone(),
-            crypt_state_receiver,
-        ),
-        command::handle(
-            state,
-            command_receiver,
-            response_sender,
-            ping_request_sender,
-        ),
+    let (_, e) = join!(
+        client::handle(command_receiver),
         spawn_blocking(move || {
             // IpcSender is blocking
             receive_oneshot_commands(command_sender);
         }),
-        network::udp::handle_pings(ping_request_receiver),
     );
     e.unwrap();
 }
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index 85e5449..574d0cb 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -85,7 +85,10 @@ impl State {
         state
     }
 
-    pub fn handle_command(&mut self, command: Command) -> ExecutionContext {
+    pub fn handle_command(
+        &mut self,
+        command: Command,
+    ) -> ExecutionContext {
         match command {
             Command::ChannelJoin { channel_identifier } => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {