neva 0.3.2

MCP SDK for Rust
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
60
61
62
63
64
65
66
67
68
69
70

//! Linux-specific implementation details

use nix::{
    sys::signal::{Signal, killpg},
    unistd::Pid,
};
use tokio::process::{Child, Command};

/// Process group wrapper for automatic handle closing
pub(super) struct Job(i32);

impl Job {
    /// Creates and returns a new child process ['Child'] and ['Job'] - process group wrapper
    pub(super) fn new(command: &str, args: &Vec<&str>) -> std::io::Result<(Job, Child)> {
        let (job_handle, child) = create_process_group(command, args)?;
        let job = Self(job_handle);
        Ok((job, child))
    }
}

impl Drop for Job {
    fn drop(&mut self) {
        let _ = killpg(Pid::from_raw(self.0), Signal::SIGTERM);
    }
}

/// Creates a process in a new group with automatic termination
#[inline]
pub(super) fn create_process_group(
    command: &str,
    args: &Vec<&str>,
) -> std::io::Result<(i32, Child)> {
    let child = Command::new(command)
        .args(args)
        .stdin(std::process::Stdio::piped())
        .stdout(std::process::Stdio::piped())
        .process_group(0)
        .spawn()?;

    let group_pid = child.id().expect("Failed to get process id");

    Ok((group_pid as i32, child))
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::time::Duration;
    use tokio::process::Command;

    #[tokio::test]
    async fn it_tests_process_group_kill() {
        let (job, _) = create_process_group("sh", &vec!["-c", "sleep 300 & sleep 300"]).unwrap();

        let job = Job(job);

        tokio::time::sleep(Duration::from_millis(100)).await;

        drop(job);

        let output = Command::new("pgrep")
            .arg("-f")
            .arg("sleep 300")
            .output()
            .await
            .unwrap();

        assert!(output.stdout.is_empty(), "Processes still running");
    }
}