support for cmdline args and better error handling (#4)

* support for cmdline args and better error handling

* make config.toml optional

* dont abuse panic for error handling

* update doc

* more panics removed

* more unwraps removed

src/main.rs

@@ -1,4 +1,4 @@
-use std::sync::mpsc;
+use std::{sync::mpsc, process, env};
 
 use lan_mouse::{
     client::ClientManager,
@@ -6,12 +6,24 @@ use lan_mouse::{
     config, event, request,
 };
 
+fn usage() {
+    eprintln!("usage: {} [--backend <backend>] [--port <port>]",
+        env::args().next().unwrap_or("lan-mouse".into()));
+}
+
 pub fn main() {
     // parse config file
-    let config = config::Config::new("config.toml").unwrap();
+    let config = match config::Config::new() {
+        Err(e) => {
+            eprintln!("{e}");
+            usage();
+            process::exit(1);
+        }
+        Ok(config) => config,
+    };
 
     // port or default
-    let port = config.port.unwrap_or(42069);
+    let port = config.port;
 
     // event channel for producing events
     let (produce_tx, produce_rx) = mpsc::sync_channel(128);
@@ -20,26 +32,64 @@ pub fn main() {
     let (consume_tx, consume_rx) = mpsc::sync_channel(128);
 
     // create client manager
-    let mut client_manager = ClientManager::new(&config);
+    let mut client_manager = match ClientManager::new(&config) {
+        Err(e) => {
+            eprintln!("{e}");
+            process::exit(1);
+        }
+        Ok(m) => m,
+    };
 
     // start receiving client connection requests
     let (request_server, request_thread) = request::Server::listen(port).unwrap();
 
     // start producing and consuming events
-    let event_producer = producer::start(produce_tx, client_manager.get_clients(), request_server);
-    let event_consumer = consumer::start(consume_rx, client_manager.get_clients(), config.backend);
+    let event_producer = match producer::start(produce_tx, client_manager.get_clients(), request_server) {
+        Err(e) => {
+            eprintln!("Could not start event producer: {e}");
+            None
+        },
+        Ok(p) => Some(p),
+    };
+    let event_consumer = match consumer::start(consume_rx, client_manager.get_clients(), config.backend) {
+        Err(e) => {
+            eprintln!("Could not start event consumer: {e}");
+            None
+        },
+        Ok(p) => Some(p),
+    };
+
+    if event_consumer.is_none() && event_producer.is_none() {
+        process::exit(1);
+    }
 
     // start sending and receiving events
-    let event_server = event::server::Server::new(port);
-    let (receiver, sender) = event_server
-        .run(&mut client_manager, produce_rx, consume_tx)
-        .unwrap();
+    let event_server = match event::server::Server::new(port) {
+        Ok(s) => s,
+        Err(e) => {
+            eprintln!("{e}");
+            process::exit(1);
+        }
+    };
+    let (receiver, sender) = match event_server.run(&mut client_manager, produce_rx, consume_tx) {
+        Ok((r,s)) => (r,s),
+        Err(e) => {
+            eprintln!("{e}");
+            process::exit(1);
+        }
+    };
 
     request_thread.join().unwrap();
 
+    // stop receiving events and terminate event-consumer
     receiver.join().unwrap();
-    sender.join().unwrap();
+    if let Some(thread) = event_consumer {
+        thread.join().unwrap();
+    }
 
-    event_producer.join().unwrap();
-    event_consumer.join().unwrap();
+    // stop producing events and terminate event-sender
+    if let Some(thread) = event_producer {
+        thread.join().unwrap();
+    }
+    sender.join().unwrap();
 }