rskit-process 0.1.0-alpha.1

Process and subprocess execution with timeout and signal handling
Documentation 
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

//! Internal process signal definitions.

/// Process signal used by subprocess lifecycle helpers.
#[derive(Debug, Clone, Copy)]
pub(crate) enum ProcessSignal {
    /// Graceful interruption signal.
    Interrupt,
    /// Graceful termination signal.
    Terminate,
    /// Forceful termination signal.
    Kill,
}

impl ProcessSignal {
    /// Human-readable POSIX signal name.
    pub(crate) const fn name(self) -> &'static str {
        match self {
            Self::Interrupt => "SIGINT",
            Self::Terminate => "SIGTERM",
            Self::Kill => "SIGKILL",
        }
    }

    /// Platform signal value.
    #[cfg(unix)]
    pub(crate) const fn as_raw(self) -> i32 {
        match self {
            Self::Interrupt => libc::SIGINT,
            Self::Terminate => libc::SIGTERM,
            Self::Kill => libc::SIGKILL,
        }
    }

    /// Platform signal value placeholder for unsupported platforms.
    #[cfg(not(unix))]
    pub(crate) const fn as_raw(self) -> i32 {
        let _ = self;
        0
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn signal_names_and_raw_values_are_stable() {
        assert_eq!(ProcessSignal::Interrupt.name(), "SIGINT");
        assert_eq!(ProcessSignal::Terminate.name(), "SIGTERM");
        assert_eq!(ProcessSignal::Kill.name(), "SIGKILL");

        #[cfg(unix)]
        {
            assert_eq!(ProcessSignal::Interrupt.as_raw(), libc::SIGINT);
            assert_eq!(ProcessSignal::Terminate.as_raw(), libc::SIGTERM);
            assert_eq!(ProcessSignal::Kill.as_raw(), libc::SIGKILL);
        }
    }
}