cargo fmt

4 files changed, 43 insertions, 30 deletions

diff --git a/mumd/src/command.rs b/mumd/src/command.rs
index ff53dc7..330e3fc 100644
--- a/mumd/src/command.rs
+++ b/mumd/src/command.rs
@@ -1,13 +1,13 @@
-use crate::state::{State, ExecutionContext};
+use crate::state::{ExecutionContext, State};
 
 use crate::network::tcp::{TcpEvent, TcpEventCallback};
 use ipc_channel::ipc::IpcSender;
 use log::*;
+use mumble_protocol::ping::PongPacket;
 use mumlib::command::{Command, CommandResponse};
+use std::net::SocketAddr;
 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>>,
@@ -45,13 +45,17 @@ pub async fn handle(
             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();
-                        })));
+                        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();
                     }
diff --git a/mumd/src/main.rs b/mumd/src/main.rs
index 70cc21b..b83299f 100644
--- a/mumd/src/main.rs
+++ b/mumd/src/main.rs
@@ -64,9 +64,7 @@ async fn main() {
             // IpcSender is blocking
             receive_oneshot_commands(command_sender);
         }),
-        network::udp::handle_pings(
-            ping_request_receiver
-        ),
+        network::udp::handle_pings(ping_request_receiver),
     );
     e.unwrap();
 }
diff --git a/mumd/src/network/udp.rs b/mumd/src/network/udp.rs
index febf7f1..f97807d 100644
--- a/mumd/src/network/udp.rs
+++ b/mumd/src/network/udp.rs
@@ -6,17 +6,17 @@ use bytes::Bytes;
 use futures::{join, pin_mut, select, FutureExt, SinkExt, StreamExt};
 use futures_util::stream::{SplitSink, SplitStream};
 use mumble_protocol::crypt::ClientCryptState;
+use mumble_protocol::ping::{PingPacket, PongPacket};
 use mumble_protocol::voice::{VoicePacket, VoicePacketPayload};
 use mumble_protocol::Serverbound;
+use std::collections::HashMap;
+use std::convert::TryFrom;
 use std::net::{Ipv6Addr, SocketAddr};
+use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use tokio::net::UdpSocket;
 use tokio::sync::{mpsc, oneshot, watch};
 use tokio_util::udp::UdpFramed;
-use std::collections::HashMap;
-use mumble_protocol::ping::{PingPacket, PongPacket};
-use std::rc::Rc;
-use std::convert::TryFrom;
 
 type UdpSender = SplitSink<UdpFramed<ClientCryptState>, (VoicePacket<Serverbound>, SocketAddr)>;
 type UdpReceiver = SplitStream<UdpFramed<ClientCryptState>>;
@@ -231,7 +231,11 @@ async fn send_voice(
 }
 
 pub async fn handle_pings(
-    mut ping_request_receiver: mpsc::UnboundedReceiver<(u64, SocketAddr, Box<dyn FnOnce(PongPacket)>)>,
+    mut ping_request_receiver: mpsc::UnboundedReceiver<(
+        u64,
+        SocketAddr,
+        Box<dyn FnOnce(PongPacket)>,
+    )>,
 ) {
     let udp_socket = UdpSocket::bind((Ipv6Addr::from(0u128), 0u16))
         .await
@@ -269,4 +273,4 @@ pub async fn handle_pings(
     debug!("Waiting for ping requests");
 
     join!(sender_handle, receiver_handle);
-}
\ No newline at end of file
+}
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index 0d0fad8..306ded8 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -11,14 +11,14 @@ 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, SocketAddr};
+use std::net::{SocketAddr, ToSocketAddrs};
 use tokio::sync::{mpsc, watch};
-use mumble_protocol::ping::PongPacket;
 
 macro_rules! at {
     ($event:expr, $generator:expr) => {
@@ -34,9 +34,15 @@ macro_rules! now {
 
 //TODO give me a better name
 pub enum ExecutionContext {
-    TcpEvent(TcpEvent, Box<dyn FnOnce(TcpEventData) -> mumlib::error::Result<Option<CommandResponse>>>),
+    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>>>),
+    Ping(
+        Box<dyn FnOnce() -> mumlib::error::Result<SocketAddr>>,
+        Box<dyn FnOnce(PongPacket) -> mumlib::error::Result<Option<CommandResponse>>>,
+    ),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -76,10 +82,7 @@ impl State {
     }
 
     //TODO? move bool inside Result
-    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) {
@@ -222,21 +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()) {
+            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| {
+                }),
+                Box::new(move |pong| {
                     Ok(Some(CommandResponse::ServerStatus {
                         version: pong.version,
                         users: pong.users,
                         max_users: pong.max_users,
                         bandwidth: pong.bandwidth,
                     }))
-                }))
-            }
+                }),
+            ),
         }
     }