Logging, better error handling

rog-core/Cargo.toml

@@ -6,8 +6,9 @@ edition = "2018"
 
 [dependencies]
 gumdrop = "0.8"
-dbus = "0.7.1"
+dbus = "0.7"
 serde = "1.0"
 serde_derive = "1.0"
-
+log = "0.4"
+env_logger = "0.7"
 rog-lib = { path = "../rog-lib" }

rog-core/src/daemon.rs

@@ -3,6 +3,7 @@ use dbus::{
     blocking::Connection,
     tree::{Factory, MethodErr},
 };
+use log::{error, info, warn};
 use rog_lib::core::RogCore;
 use std::error::Error;
 use std::time::Duration;
@@ -15,12 +16,30 @@ pub struct Daemon {
 impl Daemon {
     pub fn new() -> Self {
         Daemon {
-            rogcore: RogCore::new().expect("Could not start RogCore"),
+            rogcore: RogCore::new().map_or_else(
+                |err| {
+                    error!("{}", err);
+                    panic!("{}", err);
+                },
+                |daemon| {
+                    info!("RogCore loaded");
+                    daemon
+                },
+            ),
         }
     }
 
     pub fn start() -> Result<(), Box<dyn Error>> {
-        let mut connection = Connection::new_system().expect("Could not set up dbus system");
+        let mut connection = Connection::new_system().map_or_else(
+            |err| {
+                error!("{}", err);
+                panic!("{}", err);
+            },
+            |dbus| {
+                info!("DBus connected");
+                dbus
+            },
+        );
         connection.request_name(DBUS_IFACE, false, true, false)?;
         let factory = Factory::new_fnmut::<()>();
 
@@ -41,15 +60,18 @@ impl Daemon {
                                 move |m| {
                                     // Reads the args passed to the method
                                     let bytes: Vec<u8> = m.msg.read1()?;
-                                    let s = format!("Wrote {:x?}", bytes);
 
                                     match daemon.borrow_mut().rogcore.aura_set_and_save(&bytes[..])
                                     {
                                         Ok(_) => {
-                                            let mret = m.msg.method_return().append1(s);
+                                            let s = format!("Wrote {:x?}", bytes);
+                                            let mret = m.msg.method_return().append1(&s);
                                             Ok(vec![mret])
                                         }
-                                        Err(err) => Err(MethodErr::failed(&err)),
+                                        Err(err) => {
+                                            warn!("{}", err);
+                                            Err(MethodErr::failed(&err))
+                                        }
                                     }
                                 }
                             })
@@ -65,7 +87,12 @@ impl Daemon {
 
         let mut key_buf = [0u8; 32];
         loop {
-            connection.process(Duration::from_millis(1))?;
+            connection
+                .process(Duration::from_millis(10))
+                .unwrap_or_else(|err| {
+                    error!("{}", err);
+                    false
+                });
             // READ KEYBOARD
             // TODO: this needs to move to a thread, but there is unsafety
             let borrowed_daemon = daemon.borrow();
@@ -78,11 +105,15 @@ impl Daemon {
 
                     if let Some(_count) = read {
                         if key_buf[0] == laptop.hotkey_group_byte() {
-                            laptop.do_hotkey_action(&mut rogcore, key_buf[1]);
+                            laptop
+                                .do_hotkey_action(&mut rogcore, key_buf[1])
+                                .unwrap_or_else(|err| {
+                                    warn!("{}", err);
+                                });
                         }
                     }
                 }
-                Err(err) => println!("{:?}", err),
+                Err(err) => error!("{}", err),
             }
         }
     }

rog-core/src/main.rs

@@ -3,7 +3,9 @@ mod daemon;
 use crate::daemon::*;
 use dbus::Error as DbusError;
 use dbus::{ffidisp::Connection, Message};
+use env_logger::{Builder, Target};
 use gumdrop::Options;
+use log::LevelFilter;
 use rog_lib::{
     cli_options::SetAuraBuiltin,
     core::{LedBrightness, RogCore, LED_MSG_LEN},
@@ -40,6 +42,10 @@ struct LedModeCommand {
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut builder = Builder::from_default_env();
+    builder.target(Target::Stdout);
+    builder.filter(None, LevelFilter::Info).init();
+
     let parsed = CLIStart::parse_args_default_or_exit();
     if parsed.daemon {
         Daemon::start()?;