vrsh 0.1.2

A simple shell written for my own learning.
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

use crate::shell::built_ins::errors::BuiltInError;
use crate::shell::common::search_path::is_valid_program_name;
use crate::shell::common::types::{CmdPart, Redirect};
use std::fs::File;
use std::process::{Child, Command, Stdio};

pub fn execute_command(
    part: CmdPart,
    output: Option<Stdio>,
    index: usize,
) -> Result<Child, BuiltInError> {
    let mut redirect_in: Option<String> = None;
    let mut redirect_out: Option<String> = None;
    for redirect in part.redirects.iter() {
        match redirect {
            Redirect::In(val) => redirect_in = Some(val.clone()),
            Redirect::Out(val) => redirect_out = Some(val.clone()),
        }
    }

    let cmd_out = if let Some(file) = redirect_out {
        create_redirect_file(file)?
    } else {
        match output {
            None => Stdio::piped(),
            Some(out) => out,
        }
    };

    let cmd_in = if let Some(file) = redirect_in {
        open_redirect_file(file)?
    } else if index == 0 {
        Stdio::inherit()
    } else {
        Stdio::piped()
    };

    return run_command(part, cmd_out, cmd_in);
}

fn create_redirect_file(file: String) -> Result<Stdio, BuiltInError> {
    let val = File::create(file)?;
    Ok(Stdio::from(val))
}

fn open_redirect_file(file: String) -> Result<Stdio, BuiltInError> {
    let val = File::open(file)?;
    Ok(Stdio::from(val))
}

fn run_command(part: CmdPart, output: Stdio, input: Stdio) -> Result<Child, BuiltInError> {
    if is_valid_program_name(&part.cmd) == false {
        return Err(BuiltInError::NoSuchProgram(part.cmd.clone()));
    }

    return match Command::new(&part.cmd)
        .args(
            part.args
                .iter()
                .map(|v| v.to_string())
                .collect::<Vec<String>>(),
        )
        .stdout(output)
        .stdin(input)
        .spawn()
    {
        Ok(c) => Ok(c),
        Err(e) => Err(BuiltInError::FailedToSpawnChild(part.cmd, e)),
    };
}