about summary refs log tree commit diff
path: root/users/Profpatsch/execline/exec_helpers.rs
blob: 3e74ffc72210c539cb11f30fa3d3bb0908ae5ab8 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
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<u8>>, Vec<Vec<u8>>) {
    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 {
            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<Vec<u8>> = 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<Item = Arg>,
    Arg: AsRef<[u8]>,
    Env: IntoIterator<Item = (Key, Val)>,
    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::<Vec<Arg>>();
    let mut args = args.iter().map(|v| OsStr::from_bytes(v.as_ref()));
    let prog = args.nth(1).expect(&format!("{}: first argument must be an executable", current_prog_name));
    // TODO: same here
    let env = env_additions.into_iter().collect::<Vec<(Key, Val)>>();
    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: {:?}", err));
}

/// 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<S>(current_prog_name: &str, msg: S) -> !
where S: AsRef<str>
{
  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<S>(current_prog_name: &str, msg: S) -> !
where S: AsRef<str>
{
    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<S>(current_prog_name: &str, msg: S) -> !
where S: AsRef<str>
{
    die_with(101, current_prog_name, msg)
}

/// Exit 111 to signify a temporary error (such as resource exhaustion)
pub fn die_temporary<S>(current_prog_name: &str, msg: S) -> !
where S: AsRef<str>
{
    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<S>(current_prog_name: &str, msg: S) -> !
where S: AsRef<str>
{
    die_with(126, current_prog_name, msg)
}

/// Exit 127 to signify a missing executable.
pub fn die_missing_executable<S>(current_prog_name: &str, msg: S) -> !
where S: AsRef<str>
{
    die_with(127, current_prog_name, msg)
}

fn die_with<S>(status: i32, current_prog_name: &str, msg: S) -> !
    where S: AsRef<str>
{
    eprintln!("{}: {}", current_prog_name, msg.as_ref());
    std::process::exit(status)
}