matthiasbeyer/imag
1
0
Fork 0
Code Releases Activity

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

Browse source 
libimagrt: error optimizations
This commit is contained in:
Matthias Beyer 2017-09-09 23:32:08 +02:00 committed by GitHub
commit baf8eda571
2 changed files with 96 additions and 95 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
lib/core/libimagrt/src/error.rs
View file

@ -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 {
description("Error while reading the configuration")
display("Error while reading the configuration")
}
ConfigTypeError {
ConfigTypeError(path: String, should_be_type: &'static str) {
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")

167
lib/core/libimagrt/src/logger.rs
View file

@ -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
.chain_err(|| EK::TemplateStringRegistrationError));
try!(handlebars.register_template_string("TRACE", fmt)); // name must be uppercase
}
{
let fmt = try!(aggregate_global_format_debug(matches, config));
try!(handlebars.register_template_string("DEBUG", fmt) // name must be uppercase
.chain_err(|| EK::TemplateStringRegistrationError));
try!(handlebars.register_template_string("DEBUG", fmt)); // name must be uppercase
}
{
let fmt = try!(aggregate_global_format_info(matches, config));
try!(handlebars.register_template_string("INFO", fmt) // name must be uppercase
.chain_err(|| EK::TemplateStringRegistrationError));
try!(handlebars.register_template_string("INFO", fmt)); // name must be uppercase
}
{
let fmt = try!(aggregate_global_format_warn(matches, config));
try!(handlebars.register_template_string("WARN", fmt) // name must be uppercase
.chain_err(|| EK::TemplateStringRegistrationError));
try!(handlebars.register_template_string("WARN", fmt)); // name must be uppercase
}
{
let fmt = try!(aggregate_global_format_error(matches, config));
try!(handlebars.register_template_string("ERROR", fmt) // name must be uppercase
.chain_err(|| EK::TemplateStringRegistrationError));
try!(handlebars.register_template_string("ERROR", fmt)); // name must be uppercase
}
Ok(ImagLogger {
@ -200,15 +195,16 @@ fn aggregate_global_loglevel(matches: &ArgMatches, config: Option<&Configuration
-> Result<LogLevel>
{
match config {
Some(cfg) => match cfg
.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(None) => Err(RE::from_kind(EK::GlobalLogLevelConfigMissing)),
Err(e) => Err(e)
Some(cfg) => match cfg.read("imag.logging.level") {
Ok(Some(&Value::String(ref s))) => match_log_level_str(s),
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).map_err(From::from),
},
None => {
if matches.is_present(Runtime::arg_debugging_name()) {
return Ok(LogLevel::Debug)
@ -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,15 +258,16 @@ fn aggregate_global_destinations(matches: &ArgMatches, config: Option<&Configura
{
match config {
Some(cfg) => match cfg
.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(None) => Err(RE::from_kind(EK::GlobalDestinationConfigMissing)),
Err(e) => Err(e)
Some(cfg) => match cfg.read("imag.logging.destinations") {
Ok(Some(&Value::Array(ref a))) => translate_destinations(a),
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).map_err(From::from),
},
None => {
if let Some(values) = matches.value_of(Runtime::arg_logdest_name()) {
// parse logdest specification from commandline
@ -296,15 +297,12 @@ fn aggregate_global_format(
-> Result<String>
{
match config {
Some(cfg) => match cfg
.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(None) => Err(RE::from_kind(error_kind_if_missing)),
Err(e) => Err(e)
},
Some(cfg) => match cfg.read(read_str) {
Ok(Some(&Value::String(ref s))) => Ok(s.clone()),
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).map_err(From::from),
},
None => match matches.value_of(cli_match_name).map(String::from) {
Some(s) => Ok(s),
None => Err(RE::from_kind(error_kind_if_missing))
@ -366,55 +364,68 @@ fn aggregate_module_settings(_matches: &ArgMatches, config: Option<&Configuratio
-> Result<BTreeMap<ModuleName, ModuleSettings>>
{
match config {
Some(cfg) => match cfg
.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();
Some(cfg) => match cfg.read("imag.logging.modules") {
Ok(Some(&Value::Table(ref t))) => {
// translate the module settings from the table `t`
let mut settings = BTreeMap::new();
for (module_name, v) in t {
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)),
Err(e) => Err(e).chain_err(|| EK::TomlReadError),
});
for (module_name, v) in t {
let destinations = try!(match v.read("destinations") {
Ok(Some(&Value::Array(ref a))) => translate_destinations(a).map(Some),
Ok(None) => Ok(None),
Ok(Some(_)) => {
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)),
Err(e) => Err(e).chain_err(|| EK::TomlReadError),
});
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(_)) => {
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)),
Err(e) => Err(e).chain_err(|| EK::TomlReadError),
});
let enabled = try!(match v.read("enabled") {
Ok(Some(&Value::Boolean(b))) => Ok(b),
Ok(None) => Ok(false),
Ok(Some(_)) => {
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 {
enabled: enabled,
level: level,
destinations: destinations,
};
let module_settings = ModuleSettings {
enabled: enabled,
level: level,
destinations: destinations,
};
// We don't care whether there was a value, we override it.
let _ = settings.insert(module_name.to_owned(), module_settings);
}
// We don't care whether there was a value, we override it.
let _ = settings.insert(module_name.to_owned(), module_settings);
}
Ok(settings)
},
Ok(Some(_)) => Err(RE::from_kind(EK::ConfigTypeError)),
Ok(None) => {
// No modules configured. This is okay!
Ok(BTreeMap::new())
},
Err(e) => Err(e),
Ok(settings)
},
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).map_err(From::from),
},
None => {
write!(stderr(), "No Configuration.").ok();
write!(stderr(), "cannot find module-settings for logging.").ok();