use std::os::unix::process::CommandExt; use std::ffi::OsStr; use std::os::unix::ffi::{OsStringExt, OsStrExt}; pub fn args_for_exec(current_prog_name: &str, no_of_positional_args: usize) -> (Vec>, Vec>) { let mut args = std::env::args_os(); // remove argv[0] let _ = args.nth(0); let mut args = args.map(|arg| arg.into_vec()); let mut pos_args = vec![]; // get positional args for i in 1..no_of_positional_args+1 { pos_args.push( args.nth(0).expect( &format!("{}: expects {} positional args, only got {}", current_prog_name, no_of_positional_args, i)) ); } // prog... is the rest of the iterator let prog : Vec> = args.collect(); (pos_args, prog) } pub fn exec_into_args<'a, 'b, Args, Arg, Env, Key, Val>(current_prog_name: &str, args: Args, env_additions: Env) -> ! where Args: IntoIterator, Arg: AsRef<[u8]>, Env: IntoIterator, Key: AsRef<[u8]>, Val: AsRef<[u8]>, { // TODO: is this possible without collecting into a Vec first, just leaving it an IntoIterator? let args = args.into_iter().collect::>(); let mut args = args.iter().map(|v| OsStr::from_bytes(v.as_ref())); let prog = args.nth(0).expect(&format!("{}: first argument must be an executable", current_prog_name)); // TODO: same here let env = env_additions.into_iter().collect::>(); let env = env.iter().map(|(k,v)| (OsStr::from_bytes(k.as_ref()), OsStr::from_bytes(v.as_ref()))); let err = std::process::Command::new(prog).args(args).envs(env).exec(); die_missing_executable(current_prog_name, format!("exec failed: {}, while trying to execing into {:?}", err, prog)); } /// Exit 1 to signify a generic expected error /// (e.g. something that sometimes just goes wrong, like a nix build). pub fn die_expected_error(current_prog_name: &str, msg: S) -> ! where S: AsRef { die_with(1, current_prog_name, msg) } /// Exit 100 to signify a user error (“the user is holding it wrong”). /// This is a permanent error, if the program is executed the same way /// it should crash with 100 again. pub fn die_user_error(current_prog_name: &str, msg: S) -> ! where S: AsRef { die_with(100, current_prog_name, msg) } /// Exit 101 to signify an unexpected crash (failing assertion or panic). /// This is the same exit code that `panic!()` emits. pub fn die_panic(current_prog_name: &str, msg: S) -> ! where S: AsRef { die_with(101, current_prog_name, msg) } /// Exit 111 to signify a temporary error (such as resource exhaustion) pub fn die_temporary(current_prog_name: &str, msg: S) -> ! where S: AsRef { die_with(111, current_prog_name, msg) } /// Exit 126 to signify an environment problem /// (the user has set up stuff incorrectly so the program cannot work) pub fn die_environment_problem(current_prog_name: &str, msg: S) -> ! where S: AsRef { die_with(126, current_prog_name, msg) } /// Exit 127 to signify a missing executable. pub fn die_missing_executable(current_prog_name: &str, msg: S) -> ! where S: AsRef { die_with(127, current_prog_name, msg) } fn die_with(status: i32, current_prog_name: &str, msg: S) -> ! where S: AsRef { eprintln!("{}: {}", current_prog_name, msg.as_ref()); std::process::exit(status) }