prefork 0.6.0

A library for forking processes
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
71
72
73
74

use std::{collections::HashSet, hash::BuildHasher};

use crate::{error::Result, ForkErr};
use log::{debug, info, warn};
use nix::{
    sys::{
        signal::{kill, Signal},
        wait::{waitpid, WaitPidFlag, WaitStatus},
    },
    unistd::Pid,
};

/// Poll for child processes to change status.
///
/// This function will exit once there are no more status changes to report.
///
/// This function can be useful after sending a signal to one
/// or more children because it will remove any dead children from `pids`.
pub fn wait_process<H>(pids: &mut HashSet<Pid, H>)
where
    H: BuildHasher,
{
    while let Ok(status) = waitpid(None, Some(WaitPidFlag::WNOHANG)) {
        match status {
            WaitStatus::Exited(pid, exit_code) => {
                info!("Child {pid} exited with status {exit_code}");
                pids.remove(&pid);
            }
            WaitStatus::Signaled(pid, signal, ..) => {
                info!("Child {pid} killed by signal {signal}");
                pids.remove(&pid);
            }
            WaitStatus::StillAlive => break,
            _ => {
                info!("waitpid got status {status:?}");
            }
        }
    }
}

/// Kill the given processes
/// # Errors
/// If a process cannot be killed, the pid is returned as part of the
/// `ForkErr::KillAll` error.
pub fn kill_all<H>(pids: HashSet<Pid, H>) -> Result<()>
where
    H: BuildHasher,
{
    kill_all_with(pids, Signal::SIGKILL)
}

/// Sending specified signal to given processes
/// # Errors
/// If cannot send a signal to a process, the pid is returned as part of the
/// `ForkErr::KillAll` error.
pub fn kill_all_with<H>(pids: HashSet<Pid, H>, signal: Signal) -> Result<()>
where
    H: BuildHasher,
{
    let mut failures = Vec::new();
    for pid in pids {
        if let Err(err) = kill(pid, signal) {
            warn!("Kill failed: {err}");
            failures.push(pid.into());
        } else {
            debug!("Reaped {pid}");
        }
    }
    if failures.is_empty() {
        Ok(())
    } else {
        Err(ForkErr::KillAll(failures))
    }
}