cargo fmt

7 files changed, 63 insertions, 46 deletions

diff --git a/mumctl/src/main.rs b/mumctl/src/main.rs
index 18967db..50ccfe0 100644
--- a/mumctl/src/main.rs
+++ b/mumctl/src/main.rs
@@ -23,11 +23,6 @@ fn main() {
     setup_logger(io::stderr(), true);
     let mut config = config::read_default_cfg();
 
-    /*println!("{:?}", send_command(Command::ServerStatus {
-        host: "icahasse.se".to_string(),
-        port: 64738,
-    }).unwrap());*/
-
     let mut app = App::new("mumctl")
         .setting(AppSettings::ArgRequiredElseHelp)
         .subcommand(
@@ -125,10 +120,7 @@ fn main() {
         } else if let Some(_) = matches.subcommand_matches("list") {
             let servers = config
                 .as_ref()
-                .map(|e| e.servers
-                    .as_ref()
-                    .map(|e| e.clone())
-                    .unwrap_or(Vec::new()))
+                .map(|e| e.servers.as_ref().map(|e| e.clone()).unwrap_or(Vec::new()))
                 .unwrap_or(Vec::new());
             for (server, response) in servers
                 .into_iter()
@@ -142,7 +134,10 @@ fn main() {
                 .filter(|e| e.1.is_ok())
                 .map(|e| (e.0, e.1.unwrap().unwrap()))
             {
-                if let CommandResponse::ServerStatus { users, max_users, .. } = response {
+                if let CommandResponse::ServerStatus {
+                    users, max_users, ..
+                } = response
+                {
                     println!("{} [{}/{}]", server.name, users, max_users)
                 } else {
                     unreachable!()
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,
                     }))
-                }))
-            }
+                }),
+            ),
         }
     }
 
diff --git a/mumlib/src/command.rs b/mumlib/src/command.rs
index 26071ac..9b0c9ed 100644
--- a/mumlib/src/command.rs
+++ b/mumlib/src/command.rs
@@ -26,9 +26,15 @@ pub enum Command {
 
 #[derive(Debug, Deserialize, Serialize)]
 pub enum CommandResponse {
-    ChannelList { channels: Channel },
-    ServerConnect { welcome_message: Option<String> },
-    Status { server_state: Server },
+    ChannelList {
+        channels: Channel,
+    },
+    ServerConnect {
+        welcome_message: Option<String>,
+    },
+    Status {
+        server_state: Server,
+    },
     ServerStatus {
         version: u32,
         users: u32,
diff --git a/mumlib/src/config.rs b/mumlib/src/config.rs
index e7d107a..ae569aa 100644
--- a/mumlib/src/config.rs
+++ b/mumlib/src/config.rs
@@ -1,11 +1,11 @@
+use crate::DEFAULT_PORT;
 use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 use std::fs;
+use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::Path;
 use toml::value::Array;
 use toml::Value;
-use std::net::{SocketAddr, ToSocketAddrs};
-use crate::DEFAULT_PORT;
 
 #[derive(Debug, Deserialize, Serialize)]
 struct TOMLConfig {
@@ -62,7 +62,10 @@ pub struct ServerConfig {
 
 impl ServerConfig {
     pub fn to_socket_addr(&self) -> Option<SocketAddr> {
-        match (self.host.as_str(), self.port.unwrap_or(DEFAULT_PORT)).to_socket_addrs().map(|mut e| e.next()) {
+        match (self.host.as_str(), self.port.unwrap_or(DEFAULT_PORT))
+            .to_socket_addrs()
+            .map(|mut e| e.next())
+        {
             Ok(Some(addr)) => Some(addr),
             _ => None,
         }