Add -v flag to optionally increase Gecko verbosity (#103)

* add -v flag to optionally increase gecko verbosity

Introduces a cumulative -v flag where a single instance mean INFO level
and above are shown and two mean TRACE. The log levels are defined in
Log.jsm in the Gecko toolkit.

MarionetteSettings gains a new `verbosity' property that if undefined
uses the defaults in Gecko. This means we are no longer requiring the
marionette.logging preference to be set.

The defaults in Gecko are INFO for optimised builds and DEBUG for
debug builds.

2 files changed, 135 insertions, 35 deletions

diff --git a/src/main.rs b/src/main.rs
index b3fd0ac..66e28f6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -14,15 +14,17 @@ extern crate webdriver;
 extern crate zip;
 
 use std::borrow::ToOwned;
-use std::process::exit;
+use std::env;
+use std::io::Write;
 use std::net::{SocketAddr, IpAddr};
-use std::str::FromStr;
 use std::path::Path;
+use std::process;
+use std::str::FromStr;
 
-use argparse::{ArgumentParser, StoreTrue, Store};
+use argparse::{ArgumentParser, IncrBy, StoreTrue, Store};
 use webdriver::server::start;
 
-use marionette::{MarionetteHandler, BrowserLauncher, MarionetteSettings, extension_routes};
+use marionette::{MarionetteHandler, BrowserLauncher, LogLevel, MarionetteSettings, extension_routes};
 
 macro_rules! try_opt {
     ($expr:expr, $err_type:expr, $err_msg:expr) => ({
@@ -33,6 +35,21 @@ macro_rules! try_opt {
     })
 }
 
+macro_rules! println_stderr {
+    ($($arg:tt)*) => { {
+        let r = writeln!(&mut ::std::io::stderr(), $($arg)*);
+        r.expect("failed printing to stderr");
+    } }
+}
+
+macro_rules! err {
+    ($($arg:tt)*) => { {
+        let prog = env::args().next().unwrap();
+        println_stderr!("{}: error: {}", prog, format_args!($($arg)*));
+        process::exit(64);
+    } }
+}
+
 mod marionette;
 
 struct Options {
@@ -41,7 +58,9 @@ struct Options {
     webdriver_port: u16,
     marionette_port: u16,
     connect_existing: bool,
-    e10s: bool
+    e10s: bool,
+    log_level: String,
+    verbosity: u8,
 }
 
 
@@ -52,12 +71,14 @@ fn parse_args() -> Options {
         webdriver_port: 4444u16,
         marionette_port: 2828u16,
         connect_existing: false,
-        e10s: false
+        e10s: false,
+        log_level: "".to_owned(),
+        verbosity: 0,
     };
 
     {
         let mut parser = ArgumentParser::new();
-        parser.set_description("WebDriver to marionette proxy.");
+        parser.set_description("WebDriver to Marionette proxy.");
         parser.refer(&mut opts.binary)
             .add_option(&["-b", "--binary"], Store,
                         "Path to the Firefox binary");
@@ -76,13 +97,23 @@ fn parse_args() -> Options {
         parser.refer(&mut opts.e10s)
             .add_option(&["--e10s"], StoreTrue,
                         "Load Firefox with an e10s profile");
+        parser.refer(&mut opts.log_level)
+            .add_option(&["--log"], Store,
+            "Desired verbosity level of Gecko \
+            (fatal, error, warn, info, config, debug, trace)")
+            .metavar("LEVEL");
+        parser.refer(&mut opts.verbosity)
+            .add_option(&["-v"], IncrBy(1),
+            "Shorthand to increase verbosity of output \
+            to include debug messages with -v, \
+            and trace messages with -vv");
         parser.parse_args_or_exit();
     }
 
     if opts.binary == "" && !opts.connect_existing {
-        println!("Must supply a binary path or --connect-existing\n");
-        exit(1)
+        err!("path to browser binary required unless --connect-existing");
     }
+
     opts
 }
 
@@ -94,23 +125,39 @@ fn main() {
     let port = opts.webdriver_port;
     let addr = IpAddr::from_str(host).map(
         |x| SocketAddr::new(x, port)).unwrap_or_else(
-        |_| {
-            println!("Invalid host address");
-            exit(1);
+        |_| { err!("invalid host address"); });
+
+    // overrides defaults in Gecko
+    // which are info for optimised builds
+    // and debug for debug builds
+    let log_level = if opts.log_level.len() > 0 && opts.verbosity > 0 {
+        err!("conflicting logging- and verbosity arguments");
+    } else if opts.log_level.len() > 0 {
+        match LogLevel::from_str(&opts.log_level) {
+            Ok(level) => Some(level),
+            Err(_) => { err!("unknown log level: {}", opts.log_level); },
         }
-        );
+    } else {
+        match opts.verbosity {
+            0 => None,
+            1 => Some(LogLevel::Debug),
+            _ => Some(LogLevel::Trace),
+        }
+    };
 
+    // TODO: what if binary isn't a valid path?
     let launcher = if opts.connect_existing {
         BrowserLauncher::None
     } else {
         BrowserLauncher::BinaryLauncher(Path::new(&opts.binary).to_path_buf())
     };
 
-    let settings = MarionetteSettings::new(opts.marionette_port,
-                                           launcher,
-                                           opts.e10s);
-
-    //TODO: what if binary isn't a valid path?
+    let settings = MarionetteSettings {
+        port: opts.marionette_port,
+        launcher: launcher,
+        e10s: opts.e10s,
+        log_level: log_level,
+    };
     start(addr, MarionetteHandler::new(settings), extension_routes());
 }
 
@@ -146,8 +193,13 @@ mod tests {
             required: required
         };
 
-        let handler = MarionetteHandler::new(
-            MarionetteSettings::new(2828u16, BrowserLauncher::None, false));
+        let settings = MarionetteSettings {
+            port: 2828,
+            launcher: BrowserLauncher::None,
+            e10s: false,
+            log_level: None,
+        };
+        let handler = MarionetteHandler::new(settings);
 
         let mut gecko_profile = handler.load_profile(&capabilities).unwrap().unwrap();
         handler.set_prefs(&mut gecko_profile, true).unwrap();
diff --git a/src/marionette.rs b/src/marionette.rs
index 4abae73..1f6a4c9 100644
--- a/src/marionette.rs
+++ b/src/marionette.rs
@@ -21,6 +21,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 use std::thread::sleep;
 use std::time::Duration;
+use std::str::FromStr;
 use webdriver::command::{WebDriverCommand, WebDriverMessage, Parameters,
                          WebDriverExtensionCommand};
 use webdriver::command::WebDriverCommand::{
@@ -109,13 +110,12 @@ lazy_static! {
         ("toolkit.telemetry.rejected", Pref::new(true)),
     ];
 
-    pub static ref FIREFOX_REQUIRED_PREFERENCES: [(&'static str, Pref); 5] = [
+    pub static ref FIREFOX_REQUIRED_PREFERENCES: [(&'static str, Pref); 4] = [
         ("browser.tabs.warnOnClose", Pref::new(false)),
         ("browser.warnOnQuit", Pref::new(false)),
         // until bug 1238095 is fixed, we have to allow CPOWs
         ("dom.ipc.cpows.forbid-unsafe-from-browser", Pref::new(false)),
         ("marionette.defaultPrefs.enabled", Pref::new(true)),
-        ("marionette.logging", Pref::new(true)),
     ];
 }
 
@@ -230,28 +230,72 @@ pub enum BrowserLauncher {
     BinaryLauncher(PathBuf)
 }
 
-pub struct MarionetteSettings {
-    port: u16,
-    launcher: BrowserLauncher,
-    e10s: bool
+/// Logger levels from [Log.jsm]
+/// (https://developer.mozilla.org/en/docs/Mozilla/JavaScript_code_modules/Log.jsm).
+#[derive(Debug)]
+#[allow(dead_code)]
+pub enum LogLevel {
+    Fatal,
+    Error,
+    Warn,
+    Info,
+    Config,
+    Debug,
+    Trace,
 }
 
-impl MarionetteSettings {
-    pub fn new(port: u16, launcher: BrowserLauncher, e10s: bool) -> MarionetteSettings {
-        MarionetteSettings {
-            port: port,
-            launcher: launcher,
-            e10s: e10s
+impl ToString for LogLevel {
+    fn to_string(&self) -> String {
+        match *self {
+            LogLevel::Fatal => "fatal",
+            LogLevel::Error => "error",
+            LogLevel::Warn => "warn",
+            LogLevel::Info => "info",
+            LogLevel::Config => "config",
+            LogLevel::Debug => "debug",
+            LogLevel::Trace => "trace",
+        }.to_string()
+    }
+}
+
+impl FromStr for LogLevel {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<LogLevel, ()> {
+        let l: &str = &s.to_lowercase();
+        match l {
+            "fatal" => Ok(LogLevel::Fatal),
+            "error" => Ok(LogLevel::Error),
+            "warn" => Ok(LogLevel::Warn),
+            "info" => Ok(LogLevel::Info),
+            "config" => Ok(LogLevel::Config),
+            "debug" => Ok(LogLevel::Debug),
+            "trace" => Ok(LogLevel::Trace),
+            _ => Err(()),
         }
     }
 }
 
+pub struct MarionetteSettings {
+    pub port: u16,
+    pub launcher: BrowserLauncher,
+
+    /// Enable or disable Electrolysis, or multi-processing, in Gecko.
+    pub e10s: bool,
+
+    /// Optionally increase Marionette's verbosity by providing a log
+    /// level. The Gecko default is LogLevel::Info for optimised
+    /// builds and LogLevel::Debug for debug builds.
+    pub log_level: Option<LogLevel>,
+}
+
 pub struct MarionetteHandler {
     connection: Mutex<Option<MarionetteConnection>>,
     launcher: BrowserLauncher,
     browser: Option<FirefoxRunner>,
     port: u16,
     e10s: bool,
+    log_level: Option<LogLevel>,
 }
 
 impl MarionetteHandler {
@@ -261,7 +305,8 @@ impl MarionetteHandler {
             launcher: settings.launcher,
             browser: None,
             port: settings.port,
-            e10s: settings.e10s
+            e10s: settings.e10s,
+            log_level: settings.log_level,
         }
     }
 
@@ -311,8 +356,7 @@ impl MarionetteHandler {
     pub fn set_prefs(&self, profile: &mut Profile, custom_profile: bool)
                  -> Result<(), RunnerError> {
         let prefs = try!(profile.user_prefs());
-        prefs.insert("marionette.defaultPrefs.port",
-                     Pref::new(self.port as i64));
+        prefs.insert("marionette.defaultPrefs.port", Pref::new(self.port as i64));
 
         prefs.insert_slice(&FIREFOX_REQUIRED_PREFERENCES[..]);
         if !custom_profile {
@@ -323,6 +367,10 @@ impl MarionetteHandler {
                 prefs.insert_slice(&NON_E10S_PREFERENCES[..]);
             }
         };
+        if let Some(ref l) = self.log_level {
+            prefs.insert("marionette.logging", Pref::new(l.to_string()));
+        };
+
         try!(prefs.write());
         Ok(())
     }