Merge remote-tracking branch 'origin/main' into error-handling

9 files changed, 108 insertions, 56 deletions

diff --git a/mumctl/Cargo.toml b/mumctl/Cargo.toml
index 3a432d9..1f2f727 100644
--- a/mumctl/Cargo.toml
+++ b/mumctl/Cargo.toml
@@ -11,8 +11,8 @@ edition = "2018"
 [dependencies]
 mumlib = { path = "../mumlib" }
 
+clap = { version = "2.33", features = ["yaml"] }
 log = "0.4"
 ipc-channel = "0.14"
 
-#clap = "2.33"
 #cursive = "0.15"
diff --git a/mumctl/src/main.rs b/mumctl/src/main.rs
index 4aed39c..d6c046d 100644
--- a/mumctl/src/main.rs
+++ b/mumctl/src/main.rs
@@ -1,30 +1,104 @@
-use ipc_channel::ipc::{self, IpcSender};
+use clap::{App, AppSettings, Arg, Shell, SubCommand};
+use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use log::*;
 use mumlib::command::{Command, CommandResponse};
 use mumlib::setup_logger;
-use std::fs;
+use std::{fs, io};
 
 fn main() {
     setup_logger();
+    debug!("Logger up!");
 
-    debug!("Creating channel");
+    let mut app = App::new("mumctl")
+        .setting(AppSettings::ArgRequiredElseHelp)
+        .subcommand(SubCommand::with_name("server")
+                    .setting(AppSettings::ArgRequiredElseHelp)
+                    .subcommand(SubCommand::with_name("connect")
+                                .setting(AppSettings::ArgRequiredElseHelp)
+                                .arg(Arg::with_name("host")
+                                     .required(true)
+                                     .index(1))
+                                .arg(Arg::with_name("username")
+                                     .required(true)
+                                     .index(2)))
+                    .subcommand(SubCommand::with_name("disconnect")))
+        .subcommand(SubCommand::with_name("channel")
+                    .setting(AppSettings::ArgRequiredElseHelp)
+                    .subcommand(SubCommand::with_name("list")
+                                .arg(Arg::with_name("short")
+                                     .short("s")
+                                     .long("short")))
+                    .subcommand(SubCommand::with_name("connect")
+                                .arg(Arg::with_name("channel")
+                                     .required(true))))
+        .subcommand(SubCommand::with_name("status"))
+        .subcommand(SubCommand::with_name("completions")
+                    .arg(Arg::with_name("zsh")
+                         .long("zsh"))
+                    .arg(Arg::with_name("bash")
+                         .long("bash"))
+                    .arg(Arg::with_name("fish")
+                         .long("fish")));
+
+    let matches = app.clone().get_matches();
+
+    debug!("Matching clap");
+    if let Some(matches) = matches.subcommand_matches("server") {
+        if let Some(matches) = matches.subcommand_matches("connect") {
+            let host = matches.value_of("host").unwrap();
+            let username = matches.value_of("username").unwrap();
+            send_command(Command::ServerConnect {
+                host: host.to_string(),
+                port: 64738u16, //TODO
+                username: username.to_string(),
+                accept_invalid_cert: true, //TODO
+            }).unwrap();
+        } else if let Some(_) = matches.subcommand_matches("disconnect") {
+            send_command(Command::ServerDisconnect).unwrap();
+        }
+    } else if let Some(matches) = matches.subcommand_matches("channel") {
+        if let Some(_matches) = matches.subcommand_matches("list") {
+            let res = send_command(Command::ChannelList).unwrap().unwrap();
+            println!("{:#?}", res);
+            /*if matches.is_present("short") {
+                None //TODO
+            } else {
+                None //TODO
+            };*/
+        } else if let Some(matches) = matches.subcommand_matches("connect") {
+            send_command(Command::ChannelJoin {
+                channel_id: matches.value_of("channel").unwrap().parse::<u32>().unwrap()
+            }).unwrap();
+        }
+    } else if let Some(_matches) = matches.subcommand_matches("status") {
+        let res = send_command(Command::Status).unwrap().unwrap();
+        println!("{:#?}", res);
+    } else if let Some(matches) = matches.subcommand_matches("completions") {
+            app.gen_completions_to("mumctl",
+                                   match matches.value_of("shell").unwrap_or("zsh") {
+                                       "bash" => {
+                                           Shell::Bash
+                                       },
+                                       "fish" => {
+                                           Shell::Fish
+                                       },
+                                       _ => {
+                                           Shell::Zsh
+                                       },
+                                   },
+                                   &mut io::stdout());
+            return;
+    };
+}
+
+fn send_command(command: Command) -> mumlib::error::Result<Option<CommandResponse>> {
     let (tx_client, rx_client) = ipc::channel::<mumlib::error::Result<Option<CommandResponse>>>().unwrap();
 
     let server_name = fs::read_to_string("/var/tmp/mumd-oneshot").unwrap(); //TODO don't panic
-    debug!("Connecting to mumd at {}", server_name);
+
     let tx0 = IpcSender::connect(server_name).unwrap();
-    let connect_command = Command::ServerConnect {
-        host: "icahasse.se".to_string(),
-        port: 64738u16,
-        username: "gustav-mumd".to_string(),
-        accept_invalid_cert: true,
-    };
-    debug!("Sending {:?} to mumd", connect_command);
-    tx0.send((
-        connect_command,
-        tx_client)) .unwrap();
-
-    debug!("Reading response");
-    let response = rx_client.recv().unwrap();
-    debug!("{:?}", response);
+
+    tx0.send((command, tx_client)).unwrap();
+
+    rx_client.recv().unwrap()
 }
diff --git a/mumd/src/audio.rs b/mumd/src/audio.rs
index 1445415..edc2f7f 100644
--- a/mumd/src/audio.rs
+++ b/mumd/src/audio.rs
@@ -191,6 +191,10 @@ impl Audio {
     pub fn take_receiver(&mut self) -> Option<Receiver<VoicePacketPayload>> {
         self.input_channel_receiver.take()
     }
+
+    pub fn clear_clients(&mut self) {
+        self.client_streams.lock().unwrap().clear();
+    }
 }
 
 impl ClientStream {
diff --git a/mumd/src/main.rs b/mumd/src/main.rs
index 7ab3c61..3a0d7ec 100644
--- a/mumd/src/main.rs
+++ b/mumd/src/main.rs
@@ -37,7 +37,6 @@ async fn main() {
     );
     let state = Arc::new(Mutex::new(state));
 
-    // Run it
     let (_, _, _, e) = join!(
         network::tcp::handle(
             Arc::clone(&state),
@@ -54,7 +53,7 @@ async fn main() {
             state,
             command_receiver,
         ),
-        spawn_blocking(move || {
+        spawn_blocking(move || { // IpcSender is blocking
             receive_oneshot_commands(command_sender);
         }),
     );
@@ -68,7 +67,7 @@ fn receive_oneshot_commands(
         // create listener
         let (server, server_name): (IpcOneShotServer<(Command, IpcSender<mumlib::error::Result<Option<CommandResponse>>>)>, String) = IpcOneShotServer::new().unwrap();
         fs::write("/var/tmp/mumd-oneshot", &server_name).unwrap();
-        debug!("Listening for command at {}...", server_name);
+        debug!("Listening to {}", server_name);
 
         // receive command and response channel
         let (_, conn): (_, (Command, IpcSender<mumlib::error::Result<Option<CommandResponse>>>)) = server.accept().unwrap();
diff --git a/mumd/src/network/tcp.rs b/mumd/src/network/tcp.rs
index 6a369e5..ea4ef86 100644
--- a/mumd/src/network/tcp.rs
+++ b/mumd/src/network/tcp.rs
@@ -286,8 +286,8 @@ async fn listen(
                         ControlPacket::UserState(msg) => {
                             let mut state = state.lock().unwrap();
                             let session = msg.get_session();
-                            state.audio_mut().add_client(msg.get_session()); //TODO
                             if *state.phase_receiver().borrow() == StatePhase::Connecting {
+                                state.audio_mut().add_client(msg.get_session());
                                 state.parse_initial_user_state(*msg);
                             } else {
                                 state.server_mut().unwrap().parse_user_state(*msg);
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index 0b3663d..58280cc 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -131,6 +131,7 @@ impl State {
                 self.session_id = None;
                 self.username = None;
                 self.server = None;
+                self.audio.clear_clients();
 
                 self.phase_watcher
                     .0
diff --git a/mumlib/src/command.rs b/mumlib/src/command.rs
index 483d8c6..b2ac321 100644
--- a/mumlib/src/command.rs
+++ b/mumlib/src/command.rs
@@ -13,7 +13,7 @@ pub enum Command {
         host: String,
         port: u16,
         username: String,
-        accept_invalid_cert: bool, //TODO ask when connecting
+        accept_invalid_cert: bool,
     },
     ServerDisconnect,
     Status,
diff --git a/todo.org b/todo.org
deleted file mode 100644
index 638e6f1..0000000
--- a/todo.org
+++ /dev/null
@@ -1,26 +0,0 @@
-* Current
-** Städa mumctl
-
-* Next
-** Flytta ljudgrejer till client state
-** Split audio input/output
-** Refaktorera TCP-paket
-** Hantera fler TCP-paket
-** Tolka diffs när nytt state kommer in
-** Lägg till ett sätt att stänga av daemonen
-
-* Later
-** Kombinera flera ljudkällor rimligt (utan clipping)
-Compression. https://docs.rs/compressor/0.3.0/compressor/
-** UDP crypt state resync?? Kommentar från exemplet
-Se Mumble.proto: CryptSetup. Både server och klient kan skicka en tom request
-för att skaffa en ny crypt.
-** Coolare invalid cert-check
-Fråga användaren vad som ska hända om ett invalid cert dyker upp istället för
-att ha det som en flagga vid start
-** Mindre pub
-Urk
-** Ljudvolymen
-Via kommando, inget automatiskt
-** Bättre error handling
-** Hantera resterande TCP-paket
diff --git a/usage.org b/usage.org
index f866dca..e340165 100644
--- a/usage.org
+++ b/usage.org
@@ -20,8 +20,8 @@ The daemon doesn't do anything by itself. Interfacing with it is done through
 The basic commands are the smallest subset of commands that allow the user to
 actually use mum for something. In this case it means connecting to a server,
 listing channels and connecting to channels.
-** TODO server
-*** TODO connect
+** DONE server
+*** DONE connect
 #+BEGIN_SRC bash
 $ mumctl server connect localhost your_name
 connecting to localhost...
@@ -31,8 +31,8 @@ root
 │  some person
 |  your_name
 #+END_SRC
-** TODO channel
-*** TODO list
+** DONE channel
+*** DONE list
 #+BEGIN_SRC bash
 $ mumctl channel list
 root                 [3](4)
@@ -60,13 +60,13 @@ root                 [3](4)
 │  └─ subsubchannel  [2]
 └─ AFK               [1]
 #+END_SRC
-*** TODO connect
+*** DONE connect
 #+BEGIN_SRC bash
 $ mumctl channel connect some channel
 connecting to some channel...
 connected
 #+END_SRC
-** TODO status
+** DONE status
 #+BEGIN_SRC bash
 $ mumctl status
 connected to localhost:65837 as your_name