matthiasbeyer/imag
1
0
Fork 0
Code Releases Activity

Remove calls to exit() and replace them with error propagation up to main()

Browse source 
Signed-off-by: Matthias Beyer <mail@beyermatthias.de>
This commit is contained in:
Matthias Beyer 2019-10-19 08:54:57 +02:00
parent 19f6391d8a
commit e259015a61
2 changed files with 143 additions and 195 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
bin/core/imag/Cargo.toml
View file

@ -20,7 +20,6 @@ libimagerror = { version = "0.10.0", path = "../../../lib/core/libimagerror"
libimagstore = { version = "0.10.0", path = "../../../lib/core/libimagstore" }
libimagentrytag = { version = "0.10.0", path = "../../../lib/entry/libimagentrytag" }
libimagutil = { version = "0.10.0", path = "../../../lib/etc/libimagutil" }
failure = "0.1.5"
log = "0.4.6"
# Build time dependencies for cli completion
@ -61,6 +60,7 @@ walkdir = "2.2.8"
log = "0.4.6"
toml = "0.5.1"
toml-query = "0.9.2"
failure = "0.1.5"
libimagerror = { version = "0.10.0", path = "../../../lib/core/libimagerror" }
libimagstore = { version = "0.10.0", path = "../../../lib/core/libimagstore" }

150
bin/core/imag/src/main.rs
View file

@ -36,6 +36,7 @@
extern crate clap;
#[macro_use] extern crate log;
#[macro_use] extern crate failure;
extern crate walkdir;
extern crate toml;
extern crate toml_query;
@ -44,11 +45,10 @@ extern crate toml_query;
extern crate libimagerror;
use std::env;
use std::process::exit;
use std::process::Command;
use std::process::Stdio;
use std::io::ErrorKind;
use std::io::{stdout, Stdout, Write};
use std::io::{stdout, Write};
use std::collections::BTreeMap;
use std::path::PathBuf;
@ -56,12 +56,13 @@ use walkdir::WalkDir;
use clap::{Arg, ArgMatches, AppSettings, SubCommand};
use toml::Value;
use toml_query::read::TomlValueReadExt;
use failure::Error;
use failure::ResultExt;
use failure::err_msg;
use failure::Fallible as Result;
use libimagrt::runtime::Runtime;
use libimagrt::spec::CliSpec;
use libimagerror::io::ToExitCode;
use libimagerror::exit::ExitUnwrap;
use libimagerror::trace::trace_error;
use libimagrt::configuration::InternalConfiguration;
/// Returns the helptext, putting the Strings in cmds as possible
@ -107,16 +108,8 @@ fn help_text(cmds: Vec<String>) -> String {
}
/// Returns the list of imag-* executables found in $PATH
fn get_commands(out: &mut Stdout) -> Vec<String> {
let mut v = match env::var("PATH") {
Err(e) => {
writeln!(out, "PATH error: {:?}", e)
.to_exit_code()
.unwrap_or_exit();
exit(1)
},
Ok(path) => path
fn get_commands() -> Result<Vec<String>> {
let mut v = env::var("PATH")?
.split(':')
.flat_map(|elem| {
WalkDir::new(elem)
@ -126,7 +119,7 @@ fn get_commands(out: &mut Stdout) -> Vec<String> {
Ok(ref p) => p.file_name().to_str().map_or(false, |f| f.starts_with("imag-")),
Err(_) => false,
})
.filter_map(Result::ok)
.filter_map(|r| r.ok())
.filter_map(|path| path
.file_name()
.to_str()
@ -140,21 +133,19 @@ fn get_commands(out: &mut Stdout) -> Vec<String> {
} else {
true
})
.collect::<Vec<String>>()
};
.collect::<Vec<String>>();
v.sort();
v
Ok(v)
}
fn main() {
fn main() -> Result<()> {
// Initialize the Runtime and build the CLI
let appname = "imag";
let version = make_imag_version!();
let about = "imag - the PIM suite for the commandline";
let mut out = stdout();
let commands = get_commands(&mut out);
let commands = get_commands()?;
let helptext = help_text(commands.clone());
let mut app = Runtime::get_default_cli_builder(appname, &version, about)
.settings(&[AppSettings::AllowExternalSubcommands, AppSettings::ArgRequiredElseHelp])
@ -175,39 +166,24 @@ fn main() {
let long_help = {
let mut v = vec![];
if let Err(e) = app.write_long_help(&mut v) {
eprintln!("Error: {:?}", e);
exit(1);
}
String::from_utf8(v).unwrap_or_else(|_| { eprintln!("UTF8 Error"); exit(1) })
app.write_long_help(&mut v)?;
String::from_utf8(v).map_err(|_| err_msg("UTF8 Error"))?
};
{
let print_help = app.clone().get_matches().subcommand_name().map(|h| h == "help").unwrap_or(false);
if print_help {
writeln!(out, "{}", long_help)
.to_exit_code()
.unwrap_or_exit();
exit(0)
}
}
let mut out = stdout();
if print_help {
writeln!(out, "{}", long_help).map_err(Error::from)
} else {
let enable_logging = app.enable_logging();
let matches = app.matches();
let rtp = ::libimagrt::runtime::get_rtp_match(&matches)
.unwrap_or_else(|e| {
trace_error(&e);
exit(1)
});
let rtp = ::libimagrt::runtime::get_rtp_match(&matches)?;
let configpath = matches
.value_of("config")
.map_or_else(|| rtp.clone(), PathBuf::from);
debug!("Config path = {:?}", configpath);
let config = ::libimagrt::configuration::fetch_config(&configpath)
.unwrap_or_else(|e| {
trace_error(&e);
exit(1)
});
let config = ::libimagrt::configuration::fetch_config(&configpath)?;
if enable_logging {
Runtime::init_logger(&matches, config.as_ref())
@ -219,12 +195,8 @@ fn main() {
if matches.is_present("version") {
debug!("Showing version");
writeln!(out, "imag {}", env!("CARGO_PKG_VERSION"))
.to_exit_code()
.unwrap_or_exit();
exit(0);
}
writeln!(out, "imag {}", env!("CARGO_PKG_VERSION")).map_err(Error::from)
} else {
if matches.is_present("versions") {
debug!("Showing versions");
commands
@ -245,29 +217,14 @@ fn main() {
Err(e) => format!("Failed calling imag-{} -> {:?}", command, e),
}
})
.fold((), |_, line| {
.fold(Ok(()), |_, line| {
// The amount of newlines may differ depending on the subprocess
writeln!(out, "{}", line.trim())
.to_exit_code()
.unwrap_or_exit();
});
exit(0);
}
let aliases = match fetch_aliases(config.as_ref()) {
Ok(aliases) => aliases,
Err(e) => {
writeln!(out, "Error while fetching aliases from configuration file")
.to_exit_code()
.unwrap_or_exit();
debug!("Error = {:?}", e);
writeln!(out, "Aborting")
.to_exit_code()
.unwrap_or_exit();
exit(1);
}
};
writeln!(out, "{}", line.trim()).map_err(Error::from)
})
} else {
let aliases = fetch_aliases(config.as_ref())
.map_err(Error::from)
.context("Error while fetching aliases from configuration file")?;
// Matches any subcommand given, except calling for example 'imag --versions', as this option
// does not exit. There's nothing to do in such a case
@ -297,52 +254,43 @@ fn main() {
.spawn()
.and_then(|mut c| c.wait())
{
Ok(exit_status) => {
if !exit_status.success() {
Ok(exit_status) => if !exit_status.success() {
debug!("imag-{} exited with non-zero exit code: {:?}", subcommand, exit_status);
eprintln!("imag-{} exited with non-zero exit code", subcommand);
exit(exit_status.code().unwrap_or(1));
}
Err(format_err!("imag-{} exited with non-zero exit code", subcommand))
} else {
debug!("Successful exit!");
Ok(())
},
Err(e) => {
debug!("Error calling the subcommand");
match e.kind() {
ErrorKind::NotFound => {
writeln!(out, "No such command: 'imag-{}'", subcommand)
.to_exit_code()
.unwrap_or_exit();
writeln!(out, "See 'imag --help' for available subcommands")
.to_exit_code()
.unwrap_or_exit();
exit(1);
writeln!(out, "No such command: 'imag-{}'", subcommand)?;
writeln!(out, "See 'imag --help' for available subcommands").map_err(Error::from)
},
ErrorKind::PermissionDenied => {
writeln!(out, "No permission to execute: 'imag-{}'", subcommand)
.to_exit_code()
.unwrap_or_exit();
exit(1);
writeln!(out, "No permission to execute: 'imag-{}'", subcommand).map_err(Error::from)
},
_ => {
writeln!(out, "Error spawning: {:?}", e)
.to_exit_code()
.unwrap_or_exit();
exit(1);
_ => writeln!(out, "Error spawning: {:?}", e).map_err(Error::from),
}
}
}
} else {
Ok(())
}
}
}
}
}
fn fetch_aliases(config: Option<&Value>) -> Result<BTreeMap<String, String>, String> {
let cfg = config.ok_or_else(|| String::from("No configuration found"))?;
fn fetch_aliases(config: Option<&Value>) -> Result<BTreeMap<String, String>> {
let cfg = config.ok_or_else(|| err_msg("No configuration found"))?;
let value = cfg
.read("imag.aliases")
.map_err(|_| String::from("Reading from config failed"));
.map_err(|_| err_msg("Reading from config failed"))?;
match value? {
match value {
None => Ok(BTreeMap::new()),
Some(&Value::Table(ref tbl)) => {
let mut alias_mappings = BTreeMap::new();
@ -359,7 +307,7 @@ fn fetch_aliases(config: Option<&Value>) -> Result<BTreeMap<String, String>, Str
alias_mappings.insert(s.clone(), k.clone());
},
_ => {
let e = format!("Not all values are a String in 'imag.aliases.{}'", k);
let e = format_err!("Not all values are a String in 'imag.aliases.{}'", k);
return Err(e);
}
}
@ -367,7 +315,7 @@ fn fetch_aliases(config: Option<&Value>) -> Result<BTreeMap<String, String>, Str
},
_ => {
let msg = format!("Type Error: 'imag.aliases.{}' is not a table or string", k);
let msg = format_err!("Type Error: 'imag.aliases.{}' is not a table or string", k);
return Err(msg);
},
}
@ -376,7 +324,7 @@ fn fetch_aliases(config: Option<&Value>) -> Result<BTreeMap<String, String>, Str
Ok(alias_mappings)
},
Some(_) => Err(String::from("Type Error: 'imag.aliases' is not a table")),
Some(_) => Err(err_msg("Type Error: 'imag.aliases' is not a table")),
}
}