rumia/src/exec.rs

use std::ffi::{CString};
use crate::log::logger;

pub fn shell_run_cmd(program: String) {
    let p = std::process::Command::new(program.clone()).spawn();
    let r = match p {
        Ok(mut ch) => {ch.wait()}
        Err(err) => {
            logger().warn("mgrsh", format!("failed exec {}: {:?}", program.as_str(), err).as_str());
            return;
        }
    };
    match r {
        Ok(ec) => {
            match ec.code() {
                None => {
                    println!("exit with no code.")
                }
                Some(c) => {
                    println!("exit with code {}.", c)
                }
            }
        }
        Err(err) => {
            println!("failed run command: {:?}.", err)
        }
    }
}

pub fn unix_execv(path: &str, args: Vec<String>) {
    let mut sv = Vec::<CString>::new();
    for i in args {
        let csi_r = CString::new(i.clone());
        let csi = match csi_r {
            Ok(v) => v,
            Err(err) => {
                logger().fatal("execv", format!("failed convert arg '{}' into CString: {:?}", i.as_str(), err).as_str());
                return;
            }
        };
        sv.push(csi);
    }
    let ss = sv.as_slice();
    let cstring_path_res = CString::new(path);
    let cstring_path = match cstring_path_res {
        Ok(v) => v,
        Err(err) => {
            logger().fatal("execv", format!("failed convert path into CString: {:?}", err).as_str());
            return;
        }
    };
    let exec_res = nix::unistd::execv(&cstring_path, ss);
    match exec_res {
        Ok(_) => {}
        Err(err) => {
            logger().fatal("execv", format!("failed execv: {:?}", err).as_str());
        }
    }
}