Merge pull request #1063 from matthiasbeyer/libimagrt/error-opt

libimagrt: error optimizations

lib/core/libimagrt/src/error.rs

@@ -22,6 +22,11 @@ error_chain! {
         RuntimeError, RuntimeErrorKind, ResultExt, Result;
     }
 
+    foreign_links {
+        TomlError(::toml_query::error::Error);
+        HandlebarsTemplateError(::handlebars::TemplateError);
+    }
+
     errors {
         Instantiate {
             description("Could not instantiate")
@@ -43,14 +48,9 @@ error_chain! {
             display("IO Error: Could not open logfile")
         }
 
-        ConfigReadError {
+        ConfigTypeError(path: String, should_be_type: &'static str) {
-            description("Error while reading the configuration")
-            display("Error while reading the configuration")
-        }
-
-        ConfigTypeError {
             description("Error while reading the configuration: Type Error")
-            display("Error while reading the configuration: Type Error")
+            display("Type Error: '{}' should be '{}'", path, should_be_type)
         }
 
         GlobalLogLevelConfigMissing {
@@ -68,16 +68,6 @@ error_chain! {
             display("Invalid log level specification: Only 'trace', 'debug', 'info', 'warn', 'error' are allowed")
         }
 
-        TomlReadError {
-            description("Error while reading in TOML document")
-            display("Error while reading in TOML document")
-        }
-
-        TemplateStringRegistrationError {
-            description("Error while registering logging template string")
-            display("Error while registering logging template string")
-        }
-
         ConfigMissingLoggingFormatTrace {
             description("Missing config for logging format for trace logging")
             display("Missing config for logging format for trace logging")

lib/core/libimagrt/src/logger.rs

@@ -93,28 +93,23 @@ impl ImagLogger {
 
         {
             let fmt = try!(aggregate_global_format_trace(matches, config));
-            try!(handlebars.register_template_string("TRACE", fmt) // name must be uppercase
+            try!(handlebars.register_template_string("TRACE", fmt)); // name must be uppercase
-                .chain_err(|| EK::TemplateStringRegistrationError));
         }
         {
             let fmt = try!(aggregate_global_format_debug(matches, config));
-            try!(handlebars.register_template_string("DEBUG", fmt) // name must be uppercase
+            try!(handlebars.register_template_string("DEBUG", fmt)); // name must be uppercase
-                .chain_err(|| EK::TemplateStringRegistrationError));
         }
         {
             let fmt = try!(aggregate_global_format_info(matches, config));
-            try!(handlebars.register_template_string("INFO", fmt) // name must be uppercase
+            try!(handlebars.register_template_string("INFO", fmt)); // name must be uppercase
-                .chain_err(|| EK::TemplateStringRegistrationError));
         }
         {
             let fmt = try!(aggregate_global_format_warn(matches, config));
-            try!(handlebars.register_template_string("WARN", fmt) // name must be uppercase
+            try!(handlebars.register_template_string("WARN", fmt)); // name must be uppercase
-                .chain_err(|| EK::TemplateStringRegistrationError));
         }
         {
             let fmt = try!(aggregate_global_format_error(matches, config));
-            try!(handlebars.register_template_string("ERROR", fmt) // name must be uppercase
+            try!(handlebars.register_template_string("ERROR", fmt)); // name must be uppercase
-                .chain_err(|| EK::TemplateStringRegistrationError));
         }
 
         Ok(ImagLogger {
@@ -200,14 +195,15 @@ fn aggregate_global_loglevel(matches: &ArgMatches, config: Option<&Configuration
     -> Result<LogLevel>
 {
     match config {
-        Some(cfg) => match cfg
+        Some(cfg) => match cfg.read("imag.logging.level") {
-            .read("imag.logging.level")
-            .chain_err(|| EK::ConfigReadError)
-            {
             Ok(Some(&Value::String(ref s))) => match_log_level_str(s),
-                Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
+            Ok(Some(_)) => {
+                let path = "imag.logging.level".to_owned();
+                let ty   = "String";
+                Err(RE::from_kind(EK::ConfigTypeError(path, ty)))
+            },
             Ok(None)    => Err(RE::from_kind(EK::GlobalLogLevelConfigMissing)),
-                Err(e)      => Err(e)
+            Err(e)      => Err(e).map_err(From::from),
         },
         None => {
             if matches.is_present(Runtime::arg_debugging_name()) {
@@ -245,7 +241,11 @@ fn translate_destinations(raw: &Vec<Value>) -> Result<Vec<LogDestination>> {
             acc.and_then(|mut v| {
                 let dest = match *val {
                     Value::String(ref s) => try!(translate_destination(s)),
-                    _ => return Err(RE::from_kind(EK::ConfigTypeError)),
+                    _ => {
+                        let path = "imag.logging.modules.<mod>.destinations".to_owned();
+                        let ty   = "Array<String>";
+                        return Err(RE::from_kind(EK::ConfigTypeError(path, ty)))
+                    },
                 };
                 v.push(dest);
                 Ok(v)
@@ -258,14 +258,15 @@ fn aggregate_global_destinations(matches: &ArgMatches, config: Option<&Configura
 {
 
     match config {
-        Some(cfg) => match cfg
+        Some(cfg) => match cfg.read("imag.logging.destinations") {
-            .read("imag.logging.destinations")
-            .chain_err(|| EK::ConfigReadError)
-            {
             Ok(Some(&Value::Array(ref a))) => translate_destinations(a),
-                Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
+            Ok(Some(_)) => {
+                let path = "imag.logging.destinations".to_owned();
+                let ty   = "Array";
+                Err(RE::from_kind(EK::ConfigTypeError(path, ty)))
+            },
             Ok(None)    => Err(RE::from_kind(EK::GlobalDestinationConfigMissing)),
-                Err(e)      => Err(e)
+            Err(e)      => Err(e).map_err(From::from),
         },
         None => {
             if let Some(values) = matches.value_of(Runtime::arg_logdest_name()) {
@@ -296,14 +297,11 @@ fn aggregate_global_format(
 -> Result<String>
 {
     match config {
-        Some(cfg) => match cfg
+        Some(cfg) => match cfg.read(read_str) {
-            .read(read_str)
-            .chain_err(|| EK::ConfigReadError)
-            {
             Ok(Some(&Value::String(ref s))) => Ok(s.clone()),
-                Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
+            Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError(read_str.to_owned(), "String"))),
             Ok(None)    => Err(RE::from_kind(error_kind_if_missing)),
-                Err(e)      => Err(e)
+            Err(e)      => Err(e).map_err(From::from),
         },
         None => match matches.value_of(cli_match_name).map(String::from) {
             Some(s) => Ok(s),
@@ -366,10 +364,7 @@ fn aggregate_module_settings(_matches: &ArgMatches, config: Option<&Configuratio
     -> Result<BTreeMap<ModuleName, ModuleSettings>>
 {
     match config {
-        Some(cfg) => match cfg
+        Some(cfg) => match cfg.read("imag.logging.modules") {
-            .read("imag.logging.modules")
-            .chain_err(|| EK::ConfigReadError)
-            {
             Ok(Some(&Value::Table(ref t))) => {
                 // translate the module settings from the table `t`
                 let mut settings = BTreeMap::new();
@@ -378,22 +373,34 @@ fn aggregate_module_settings(_matches: &ArgMatches, config: Option<&Configuratio
                     let destinations = try!(match v.read("destinations") {
                         Ok(Some(&Value::Array(ref a))) => translate_destinations(a).map(Some),
                         Ok(None)    => Ok(None),
-                            Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
+                        Ok(Some(_)) => {
-                            Err(e)      => Err(e).chain_err(|| EK::TomlReadError),
+                            let path = "imag.logging.modules.<mod>.destinations".to_owned();
+                            let ty = "Array";
+                            Err(RE::from_kind(EK::ConfigTypeError(path, ty)))
+                        },
+                        Err(e)      => Err(e).map_err(From::from),
                     });
 
                     let level = try!(match v.read("level") {
                         Ok(Some(&Value::String(ref s))) => match_log_level_str(s).map(Some),
                         Ok(None)    => Ok(None),
-                            Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
+                        Ok(Some(_)) => {
-                            Err(e)      => Err(e).chain_err(|| EK::TomlReadError),
+                            let path = "imag.logging.modules.<mod>.level".to_owned();
+                            let ty = "String";
+                            Err(RE::from_kind(EK::ConfigTypeError(path, ty)))
+                        },
+                        Err(e)      => Err(e).map_err(From::from),
                     });
 
                     let enabled = try!(match v.read("enabled") {
                         Ok(Some(&Value::Boolean(b))) => Ok(b),
                         Ok(None)    => Ok(false),
-                            Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
+                        Ok(Some(_)) => {
-                            Err(e)      => Err(e).chain_err(|| EK::TomlReadError),
+                            let path = "imag.logging.modules.<mod>.enabled".to_owned();
+                            let ty = "Boolean";
+                            Err(RE::from_kind(EK::ConfigTypeError(path, ty)))
+                        },
+                        Err(e)      => Err(e).map_err(From::from),
                     });
 
                     let module_settings = ModuleSettings {
@@ -408,12 +415,16 @@ fn aggregate_module_settings(_matches: &ArgMatches, config: Option<&Configuratio
 
                 Ok(settings)
             },
-                Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
+            Ok(Some(_)) => {
+                let path = "imag.logging.modules".to_owned();
+                let ty = "Table";
+                Err(RE::from_kind(EK::ConfigTypeError(path, ty)))
+            },
             Ok(None)    => {
                 // No modules configured. This is okay!
                 Ok(BTreeMap::new())
             },
-                Err(e)      => Err(e),
+            Err(e) => Err(e).map_err(From::from),
         },
         None => {
             write!(stderr(), "No Configuration.").ok();