469 lines
17 KiB
Rust
469 lines
17 KiB
Rust
//
|
|
// imag - the personal information management suite for the commandline
|
|
// Copyright (C) 2015, 2016 Matthias Beyer <mail@beyermatthias.de> and contributors
|
|
//
|
|
// This library is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public
|
|
// License as published by the Free Software Foundation; version
|
|
// 2.1 of the License.
|
|
//
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, write to the Free Software
|
|
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
//
|
|
|
|
use std::io::Write;
|
|
use std::io::stderr;
|
|
use std::collections::BTreeMap;
|
|
use std::sync::Arc;
|
|
use std::sync::Mutex;
|
|
use std::ops::Deref;
|
|
|
|
use configuration::Configuration;
|
|
use error::RuntimeErrorKind as EK;
|
|
use error::RuntimeError as RE;
|
|
use error::ResultExt;
|
|
use runtime::Runtime;
|
|
|
|
use clap::ArgMatches;
|
|
use log::{Log, LogLevel, LogRecord, LogMetadata};
|
|
use toml::Value;
|
|
use toml_query::read::TomlValueReadExt;
|
|
use handlebars::Handlebars;
|
|
|
|
type ModuleName = String;
|
|
type Result<T> = ::std::result::Result<T, RE>;
|
|
|
|
enum LogDestination {
|
|
Stderr,
|
|
File(Arc<Mutex<::std::fs::File>>),
|
|
}
|
|
|
|
impl Default for LogDestination {
|
|
fn default() -> LogDestination {
|
|
LogDestination::Stderr
|
|
}
|
|
}
|
|
|
|
struct ModuleSettings {
|
|
enabled: bool,
|
|
level: Option<LogLevel>,
|
|
|
|
#[allow(unused)]
|
|
destinations: Option<Vec<LogDestination>>,
|
|
}
|
|
|
|
/// Logger implementation for `log` crate.
|
|
pub struct ImagLogger {
|
|
global_loglevel : LogLevel,
|
|
|
|
#[allow(unused)]
|
|
global_destinations : Vec<LogDestination>,
|
|
// global_format_trace : ,
|
|
// global_format_debug : ,
|
|
// global_format_info : ,
|
|
// global_format_warn : ,
|
|
// global_format_error : ,
|
|
module_settings : BTreeMap<ModuleName, ModuleSettings>,
|
|
|
|
handlebars: Handlebars,
|
|
}
|
|
|
|
impl ImagLogger {
|
|
|
|
/// Create a new ImagLogger object with a certain level
|
|
pub fn new(matches: &ArgMatches, config: Option<&Configuration>) -> Result<ImagLogger> {
|
|
let mut handlebars = Handlebars::new();
|
|
|
|
handlebars.register_escape_fn(::handlebars::no_escape);
|
|
|
|
::libimaginteraction::format::register_all_color_helpers(&mut handlebars);
|
|
::libimaginteraction::format::register_all_format_helpers(&mut handlebars);
|
|
|
|
{
|
|
let fmt = try!(aggregate_global_format_trace(matches, config));
|
|
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
|
|
}
|
|
{
|
|
let fmt = try!(aggregate_global_format_info(matches, config));
|
|
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
|
|
}
|
|
{
|
|
let fmt = try!(aggregate_global_format_error(matches, config));
|
|
try!(handlebars.register_template_string("ERROR", fmt)); // name must be uppercase
|
|
}
|
|
|
|
Ok(ImagLogger {
|
|
global_loglevel : try!(aggregate_global_loglevel(matches, config)),
|
|
global_destinations : try!(aggregate_global_destinations(matches, config)),
|
|
module_settings : try!(aggregate_module_settings(matches, config)),
|
|
handlebars : handlebars,
|
|
})
|
|
}
|
|
|
|
pub fn global_loglevel(&self) -> LogLevel {
|
|
self.global_loglevel
|
|
}
|
|
|
|
}
|
|
|
|
impl Log for ImagLogger {
|
|
|
|
fn enabled(&self, metadata: &LogMetadata) -> bool {
|
|
metadata.level() <= self.global_loglevel
|
|
}
|
|
|
|
fn log(&self, record: &LogRecord) {
|
|
if record.location().module_path().starts_with("handlebars") {
|
|
// This is a ugly, yet necessary hack. When logging, we use handlebars for templating.
|
|
// But as the handlebars library itselfs logs via a normal logging macro ("debug!()"),
|
|
// we have a recursion in our chain.
|
|
//
|
|
// To prevent this recursion, we return here.
|
|
//
|
|
// (As of handlebars 0.29.0 - please check whether you can update handlebars if you see
|
|
// this. Hopefully the next version has a compiletime flag to disable logging)
|
|
return;
|
|
}
|
|
|
|
let mut data = BTreeMap::new();
|
|
|
|
{
|
|
data.insert("level", format!("{}", record.level()));
|
|
data.insert("module_path", String::from(record.location().module_path()));
|
|
data.insert("file", String::from(record.location().file()));
|
|
data.insert("line", format!("{}", record.location().line()));
|
|
data.insert("target", String::from(record.target()));
|
|
data.insert("message", format!("{}", record.args()));
|
|
}
|
|
|
|
let logtext = self
|
|
.handlebars
|
|
.render(&format!("{}", record.level()), &data)
|
|
.unwrap_or_else(|e| format!("Failed rendering logging data: {:?}\n", e));
|
|
|
|
let log_to_destination = |d: &LogDestination| match d {
|
|
&LogDestination::Stderr => {
|
|
let _ = write!(stderr(), "{}\n", logtext);
|
|
},
|
|
&LogDestination::File(ref arc_mutex_logdest) => {
|
|
// if there is an error in the lock, we cannot do anything. So we ignore it here.
|
|
let _ = arc_mutex_logdest
|
|
.deref()
|
|
.lock()
|
|
.map(|mut logdest| {
|
|
write!(logdest, "{}\n", logtext)
|
|
});
|
|
}
|
|
};
|
|
|
|
// hack to get the right target configuration.
|
|
// If there is no element here, we use the empty string which automatically drops through
|
|
// to the unwrap_or_else() case
|
|
let record_target = record
|
|
.target()
|
|
.split("::")
|
|
.next()
|
|
.unwrap_or("");
|
|
|
|
self.module_settings
|
|
.get(record_target)
|
|
.map(|module_setting| {
|
|
let set = module_setting.enabled &&
|
|
module_setting.level.unwrap_or(self.global_loglevel) >= record.level();
|
|
|
|
if set {
|
|
module_setting.destinations.as_ref().map(|destinations| for d in destinations {
|
|
// If there's an error, we cannot do anything, can we?
|
|
let _ = log_to_destination(&d);
|
|
});
|
|
|
|
for d in self.global_destinations.iter() {
|
|
// If there's an error, we cannot do anything, can we?
|
|
let _ = log_to_destination(&d);
|
|
}
|
|
}
|
|
})
|
|
.unwrap_or_else(|| {
|
|
if self.global_loglevel >= record.level() {
|
|
// Yes, we log
|
|
for d in self.global_destinations.iter() {
|
|
// If there's an error, we cannot do anything, can we?
|
|
let _ = log_to_destination(&d);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
fn match_log_level_str(s: &str) -> Result<LogLevel> {
|
|
match s {
|
|
"trace" => Ok(LogLevel::Trace),
|
|
"debug" => Ok(LogLevel::Debug),
|
|
"info" => Ok(LogLevel::Info),
|
|
"warn" => Ok(LogLevel::Warn),
|
|
"error" => Ok(LogLevel::Error),
|
|
_ => return Err(RE::from_kind(EK::InvalidLogLevelSpec)),
|
|
}
|
|
}
|
|
|
|
fn aggregate_global_loglevel(matches: &ArgMatches, config: Option<&Configuration>)
|
|
-> Result<LogLevel>
|
|
{
|
|
match config {
|
|
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)
|
|
}
|
|
|
|
matches
|
|
.value_of(Runtime::arg_verbosity_name())
|
|
.map(match_log_level_str)
|
|
.unwrap_or(Ok(LogLevel::Info))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn translate_destination(raw: &str) -> Result<LogDestination> {
|
|
use std::fs::OpenOptions;
|
|
|
|
match raw {
|
|
"-" => Ok(LogDestination::Stderr),
|
|
other => {
|
|
OpenOptions::new()
|
|
.append(true)
|
|
.create(true)
|
|
.open(other)
|
|
.map(Mutex::new)
|
|
.map(Arc::new)
|
|
.map(LogDestination::File)
|
|
.chain_err(|| EK::IOLogFileOpenError)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
fn translate_destinations(raw: &Vec<Value>) -> Result<Vec<LogDestination>> {
|
|
raw.iter()
|
|
.fold(Ok(vec![]), |acc, val| {
|
|
acc.and_then(|mut v| {
|
|
let dest = match *val {
|
|
Value::String(ref s) => try!(translate_destination(s)),
|
|
_ => {
|
|
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)
|
|
})
|
|
})
|
|
}
|
|
|
|
fn aggregate_global_destinations(matches: &ArgMatches, config: Option<&Configuration>)
|
|
-> Result<Vec<LogDestination>>
|
|
{
|
|
|
|
match config {
|
|
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
|
|
|
|
values.split(",")
|
|
.fold(Ok(vec![]), move |acc, dest| {
|
|
acc.and_then(|mut v| {
|
|
v.push(try!(translate_destination(dest)));
|
|
Ok(v)
|
|
})
|
|
})
|
|
} else {
|
|
Ok(vec![ LogDestination::default() ])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn aggregate_global_format(
|
|
read_str: &str,
|
|
cli_match_name: &str,
|
|
error_kind_if_missing: EK,
|
|
matches: &ArgMatches,
|
|
config: Option<&Configuration>
|
|
)
|
|
-> Result<String>
|
|
{
|
|
match config {
|
|
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))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn aggregate_global_format_trace(matches: &ArgMatches, config: Option<&Configuration>)
|
|
-> Result<String>
|
|
{
|
|
aggregate_global_format("imag.logging.format.trace",
|
|
Runtime::arg_override_trace_logging_format(),
|
|
EK::ConfigMissingLoggingFormatTrace,
|
|
matches,
|
|
config)
|
|
}
|
|
|
|
fn aggregate_global_format_debug(matches: &ArgMatches, config: Option<&Configuration>)
|
|
-> Result<String>
|
|
{
|
|
aggregate_global_format("imag.logging.format.debug",
|
|
Runtime::arg_override_debug_logging_format(),
|
|
EK::ConfigMissingLoggingFormatDebug,
|
|
matches,
|
|
config)
|
|
}
|
|
|
|
fn aggregate_global_format_info(matches: &ArgMatches, config: Option<&Configuration>)
|
|
-> Result<String>
|
|
{
|
|
aggregate_global_format("imag.logging.format.info",
|
|
Runtime::arg_override_info_logging_format(),
|
|
EK::ConfigMissingLoggingFormatInfo,
|
|
matches,
|
|
config)
|
|
}
|
|
|
|
fn aggregate_global_format_warn(matches: &ArgMatches, config: Option<&Configuration>)
|
|
-> Result<String>
|
|
{
|
|
aggregate_global_format("imag.logging.format.warn",
|
|
Runtime::arg_override_warn_logging_format(),
|
|
EK::ConfigMissingLoggingFormatWarn,
|
|
matches,
|
|
config)
|
|
}
|
|
|
|
fn aggregate_global_format_error(matches: &ArgMatches, config: Option<&Configuration>)
|
|
-> Result<String>
|
|
{
|
|
aggregate_global_format("imag.logging.format.error",
|
|
Runtime::arg_override_error_logging_format(),
|
|
EK::ConfigMissingLoggingFormatError,
|
|
matches,
|
|
config)
|
|
}
|
|
|
|
fn aggregate_module_settings(_matches: &ArgMatches, config: Option<&Configuration>)
|
|
-> Result<BTreeMap<ModuleName, ModuleSettings>>
|
|
{
|
|
match config {
|
|
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(_)) => {
|
|
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(_)) => {
|
|
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(_)) => {
|
|
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,
|
|
};
|
|
|
|
// 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(_)) => {
|
|
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();
|
|
write!(stderr(), "Will use global defaults").ok();
|
|
|
|
Ok(BTreeMap::new())
|
|
}
|
|
}
|
|
}
|
|
|