imag/libimagrt/src/runtime.rs

280 lines
8.8 KiB
Rust
Raw Normal View History

use std::path::PathBuf;
use std::process::Command;
use std::env;
2016-03-24 11:09:45 +00:00
use std::io::stderr;
use std::io::Write;
pub use clap::App;
use clap::{Arg, ArgMatches};
use log;
use log::LogLevelFilter;
use configuration::Configuration;
use error::RuntimeError;
use error::RuntimeErrorKind;
use logger::ImagLogger;
use libimagstore::store::Store;
pub struct Runtime<'a> {
rtp: PathBuf,
2016-03-05 12:01:09 +00:00
configuration: Option<Configuration>,
2016-02-20 20:15:09 +00:00
cli_matches: ArgMatches<'a>,
store: Store,
}
impl<'a> Runtime<'a> {
/**
* Gets the CLI spec for the program and retreives the config file path (or uses the default on
* in $HOME/.imag/config, $XDG_CONFIG_DIR/imag/config or from env("$IMAG_CONFIG")
* and builds the Runtime object with it.
*
* The cli_spec object should be initially build with the ::get_default_cli_builder() function.
*
*/
2016-02-20 20:15:09 +00:00
pub fn new(cli_spec: App<'a, 'a>) -> Result<Runtime<'a>, RuntimeError> {
2016-01-29 19:36:37 +00:00
use std::env;
use std::error::Error;
2016-01-29 19:36:37 +00:00
2016-03-24 11:09:45 +00:00
use libimagstore::hook::position::HookPosition;
use libimagstore::error::StoreErrorKind;
2016-03-24 11:09:45 +00:00
use libimagstorestdhook::debug::DebugHook;
use libimagutil::trace::trace_error;
use libimagutil::trace::trace_error_dbg;
2016-03-24 11:09:45 +00:00
2016-03-05 12:01:09 +00:00
use configuration::error::ConfigErrorKind;
let matches = cli_spec.get_matches();
let is_debugging = matches.is_present("debugging");
let is_verbose = matches.is_present("verbosity");
Runtime::init_logger(is_debugging, is_verbose);
2016-01-29 19:36:37 +00:00
let rtp : PathBuf = matches.value_of("runtimepath")
.map(PathBuf::from)
.unwrap_or_else(|| {
env::var("HOME")
.map(PathBuf::from)
.map(|mut p| { p.push(".imag"); p})
.unwrap_or_else(|_| {
panic!("You seem to be $HOME-less. Please get a $HOME before using this software. We are sorry for you and hope you have some accommodation anyways.");
})
});
let storepath = matches.value_of("storepath")
.map(PathBuf::from)
.unwrap_or({
let mut spath = rtp.clone();
spath.push("store");
spath
});
let cfg = Configuration::new(&rtp);
2016-03-05 12:01:09 +00:00
let cfg = if cfg.is_err() {
let e = cfg.err().unwrap();
if e.kind() != ConfigErrorKind::NoConfigFileFound {
let cause : Option<Box<Error>> = Some(Box::new(e));
return Err(RuntimeError::new(RuntimeErrorKind::Instantiate, cause));
} else {
2016-03-24 11:09:45 +00:00
trace_error(&e);
2016-03-05 12:01:09 +00:00
None
}
} else {
Some(cfg.unwrap())
};
2016-03-05 17:42:59 +00:00
let store_config = {
match &cfg {
&Some(ref c) => c.store_config().map(|c| c.clone()),
2016-03-24 11:09:45 +00:00
&None => None,
2016-03-05 17:42:59 +00:00
}
};
2016-03-24 11:09:45 +00:00
if is_debugging {
write!(stderr(), "Config: {:?}\n", cfg);
write!(stderr(), "Store-config: {:?}\n", store_config);
}
Store::new(storepath, store_config).map(|mut store| {
// If we are debugging, generate hooks for all positions
if is_debugging {
let hooks = vec![
(DebugHook::new(HookPosition::PreCreate), HookPosition::PreCreate),
(DebugHook::new(HookPosition::PostCreate), HookPosition::PostCreate),
(DebugHook::new(HookPosition::PreRetrieve), HookPosition::PreRetrieve),
(DebugHook::new(HookPosition::PostRetrieve), HookPosition::PostRetrieve),
(DebugHook::new(HookPosition::PreUpdate), HookPosition::PreUpdate),
(DebugHook::new(HookPosition::PostUpdate), HookPosition::PostUpdate),
(DebugHook::new(HookPosition::PreDelete), HookPosition::PreDelete),
(DebugHook::new(HookPosition::PostDelete), HookPosition::PostDelete),
];
// Put all debug hooks into the aspect "debug".
// If it fails, trace the error and warn, but continue.
for (hook, position) in hooks {
if let Err(e) = store.register_hook(position, &String::from("debug"), Box::new(hook)) {
if e.err_type() == StoreErrorKind::HookRegisterError {
trace_error_dbg(&e);
warn!("Registering debug hook with store failed");
} else {
trace_error(&e);
};
2016-03-24 11:09:45 +00:00
}
}
}
Runtime {
cli_matches: matches,
configuration: cfg,
rtp: rtp,
store: store,
}
})
.map_err(|e| {
RuntimeError::new(RuntimeErrorKind::Instantiate, Some(Box::new(e)))
})
}
/**
2016-01-21 20:24:20 +00:00
* Get a commandline-interface builder object from `clap`
*
* This commandline interface builder object already contains some predefined interface flags:
* * -v | --verbose for verbosity
* * --debug for debugging
* * -c <file> | --config <file> for alternative configuration file
* * -r <path> | --rtp <path> for alternative runtimepath
* * --store <path> for alternative store path
* Each has the appropriate help text included.
*
* The `appname` shall be "imag-<command>".
*/
pub fn get_default_cli_builder(appname: &'a str,
version: &'a str,
about: &'a str)
2016-02-20 20:15:09 +00:00
-> App<'a, 'a>
{
App::new(appname)
.version(version)
.author("Matthias Beyer <mail@beyermatthias.de>")
.about(about)
.arg(Arg::with_name("verbosity")
.short("v")
.long("verbose")
.help("Enables verbosity")
.required(false)
.takes_value(false))
.arg(Arg::with_name("debugging")
.long("debug")
.help("Enables debugging output")
.required(false)
.takes_value(false))
.arg(Arg::with_name("config")
.long("config")
.help("Path to alternative config file")
.required(false)
.takes_value(true))
.arg(Arg::with_name("runtimepath")
.long("rtp")
.help("Alternative runtimepath")
.required(false)
.takes_value(true))
.arg(Arg::with_name("storepath")
.long("store")
.help("Alternative storepath. Must be specified as full path, can be outside of the RTP")
.required(false)
.takes_value(true))
.arg(Arg::with_name("editor")
.long("editor")
.help("Set editor")
.required(false)
.takes_value(true))
}
2016-01-21 20:24:20 +00:00
/**
* Initialize the internal logger
*/
fn init_logger(is_debugging: bool, is_verbose: bool) {
let lvl = if is_debugging {
LogLevelFilter::Debug
} else if is_verbose {
LogLevelFilter::Info
} else {
LogLevelFilter::Error
};
log::set_logger(|max_log_lvl| {
max_log_lvl.set(lvl);
debug!("Init logger with {}", lvl);
Box::new(ImagLogger::new(lvl.to_log_level().unwrap()))
})
.map_err(|_| {
panic!("Could not setup logger");
})
.ok();
}
2016-01-21 20:24:20 +00:00
/**
* Get the verbosity flag value
*/
pub fn is_verbose(&self) -> bool {
self.cli_matches.is_present("verbosity")
}
2016-01-21 20:24:20 +00:00
/**
* Get the debugging flag value
*/
pub fn is_debugging(&self) -> bool {
self.cli_matches.is_present("debugging")
}
2016-01-21 20:24:20 +00:00
/**
* Get the runtimepath
*/
pub fn rtp(&self) -> &PathBuf {
&self.rtp
}
2016-01-21 20:24:20 +00:00
/**
* Get the commandline interface matches
*/
pub fn cli(&self) -> &ArgMatches {
&self.cli_matches
}
2016-03-26 18:50:13 +00:00
/**
* Get the configuration object
*/
pub fn config(&self) -> Option<&Configuration> {
self.configuration.as_ref()
}
2016-01-21 20:24:20 +00:00
/**
* Get the store object
*/
pub fn store(&self) -> &Store {
&self.store
}
pub fn editor(&self) -> Option<Command> {
self.cli()
.value_of("editor")
.map(String::from)
.or({
match &self.configuration {
&Some(ref c) => c.editor().map(|s| s.clone()),
_ => None,
}
})
.or(env::var("EDITOR").ok())
.map(Command::new)
}
}