runproclike 0.1.1

runproclike is a CLI utility that analyzes a running process by its PID and prints the command and its environment in a reproducible form.
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
95
96
97
98
99

use crate::executable::Executable;
use anyhow::anyhow;
use clap::{crate_name, crate_version, ArgAction, Parser};
use procfs::process::Process;

#[derive(Parser)]
#[command(version = crate_version!(), bin_name = crate_name!())]
pub struct CliArgs {
    #[arg(short, long, help = "PID of the process of interest")]
    pub pid: i32,

    #[arg(
    long,
    help = "print the command line of the process without the path, cwd, env, etc.",
    action = ArgAction::SetTrue,
    default_value = "false"
    )]
    pub command_only: bool,

    #[arg(
    long,
    help = "Omit comments from the output.",
    action = ArgAction::SetTrue,
    default_value = "false"
    )]
    pub omit_comments: bool,
}

impl CliArgs {
    fn validate(&self) -> anyhow::Result<()> {
        // check if pid exists
        let proc = Process::new(self.pid).or(Err(anyhow!("Invalid PID {}", self.pid)))?;
        proc.status().or(Err(anyhow!(
            "read: /proc/{}/status: Permission denied",
            self.pid
        )))?;

        proc.cmdline().or(Err(anyhow!(
            "read: /proc/{}/cmdline: Permission denied",
            self.pid
        )))?;

        proc.environ().or(Err(anyhow!(
            "read: /proc/{}/environ: Permission denied",
            self.pid
        )))?;

        Ok(())
    }
}
pub fn main() {
    // parsing arguments
    let args = CliArgs::parse();
    args.validate().expect("Failed to validate arguments");

    // extract info from process
    let executable = Executable::new(args);
    executable.extract_info();
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_validate_different_pid_fail() {
        let args = CliArgs {
            pid: 1,
            command_only: false,
            omit_comments: false,
        };
        let result = args.validate().unwrap_err();
        assert_eq!(
            result.to_string(),
            "read: /proc/1/environ: Permission denied"
        );
    }

    #[test]
    fn test_validate_invalid_pid_fail() {
        let args = CliArgs {
            pid: -1,
            command_only: false,
            omit_comments: false,
        };
        let result = args.validate().unwrap_err();
        assert_eq!(result.to_string(), "Invalid PID -1");
    }

    #[test]
    fn test_validate_valid_pid_success() {
        let args = CliArgs {
            pid: Process::myself().unwrap().pid() as i32,
            command_only: false,
            omit_comments: false,
        };
        let result = args.validate();
        assert!(result.is_ok());
    }
}