use std::process::{Child, Command, ExitStatus};
use std::time::Duration;
use serde::{Deserialize, Serialize};
use sysprims_core::schema::TERMINATE_TREE_RESULT_V1;
use sysprims_core::time::now_rfc3339;
use sysprims_core::{get_platform, SysprimsError, SysprimsResult};
use sysprims_proc::wait_pid;
pub mod managed;
#[cfg(unix)]
mod unix;
#[cfg(windows)]
mod windows;
pub use managed::{
close as containment_close, identity as containment_identity, poll as containment_poll,
spawn as containment_spawn, terminate as containment_terminate, wait as containment_wait,
ManagedSnapshot, ManagedSpawnRequest,
};
pub use sysprims_signal::{SIGKILL, SIGTERM};
#[cfg(windows)]
pub use windows::{PreparedWindowsJob, WindowsJobReceipt};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum GroupingMode {
#[default]
GroupByDefault,
Foreground,
}
#[derive(Debug, Clone)]
pub struct TimeoutConfig {
pub signal: i32,
pub kill_after: Duration,
pub grouping: GroupingMode,
pub preserve_status: bool,
}
impl Default for TimeoutConfig {
fn default() -> Self {
Self {
signal: SIGTERM,
kill_after: Duration::from_secs(10),
grouping: GroupingMode::GroupByDefault,
preserve_status: false,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum TreeKillReliability {
Guaranteed,
Unproven,
BestEffort,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ContainmentBoundaryStrength {
KernelEnforcedJob,
CooperativeGroup,
Unknown,
}
pub(crate) const MAX_COMPLETION_OBSERVED_PIDS: usize = 4096;
pub(crate) const MAX_COMPLETION_OBSERVATION_RETRIES: usize = 3;
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ContainmentObservation {
LinuxProcfsProcessGroup,
MacosLibprocProcessGroup,
WindowsJobProcessIdList,
UnsupportedPlatform,
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(tag = "status", rename_all = "snake_case")]
pub enum ContainmentCompletionEvidence {
Empty { observation: ContainmentObservation },
Survivors {
observation: ContainmentObservation,
observed_count: u32,
survivor_pids: Vec<u32>,
},
Unknown { observation: ContainmentObservation },
}
pub(crate) fn unknown_completion(
observation: ContainmentObservation,
) -> ContainmentCompletionEvidence {
ContainmentCompletionEvidence::Unknown { observation }
}
pub(crate) fn completion_from_pids(
observation: ContainmentObservation,
mut pids: Vec<u32>,
) -> ContainmentCompletionEvidence {
if pids.len() >= MAX_COMPLETION_OBSERVED_PIDS
|| pids
.iter()
.any(|pid| *pid == 0 || *pid > sysprims_signal::MAX_SAFE_PID)
{
return unknown_completion(observation);
}
let observed_count = pids.len();
pids.sort_unstable();
pids.dedup();
if pids.len() != observed_count {
return unknown_completion(observation);
}
if pids.is_empty() {
ContainmentCompletionEvidence::Empty { observation }
} else {
ContainmentCompletionEvidence::Survivors {
observation,
observed_count: pids.len() as u32,
survivor_pids: pids,
}
}
}
impl TreeKillReliability {
pub fn as_str(self) -> &'static str {
match self {
Self::Guaranteed => "guaranteed",
Self::Unproven => "unproven",
Self::BestEffort => "best_effort",
}
}
}
impl ContainmentBoundaryStrength {
pub fn as_str(self) -> &'static str {
match self {
Self::KernelEnforcedJob => "kernel_enforced_job",
Self::CooperativeGroup => "cooperative_group",
Self::Unknown => "unknown",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct ContainmentIdentity {
pub pid: u32,
pub start_time_unix_ms: u64,
pub exe_path: String,
}
pub trait ContainmentChild {
fn process_id(&self) -> Option<u32>;
fn try_wait(&mut self) -> std::io::Result<bool>;
#[cfg(windows)]
fn raw_process_handle(&self) -> Option<std::os::windows::io::RawHandle>;
}
impl ContainmentChild for Child {
fn process_id(&self) -> Option<u32> {
Some(self.id())
}
fn try_wait(&mut self) -> std::io::Result<bool> {
Child::try_wait(self).map(|status| status.is_some())
}
#[cfg(windows)]
fn raw_process_handle(&self) -> Option<std::os::windows::io::RawHandle> {
use std::os::windows::io::AsRawHandle;
Some(self.as_raw_handle())
}
}
pub struct ContainmentAdoptionError<C> {
pub error: SysprimsError,
pub child: C,
}
impl<C> std::fmt::Debug for ContainmentAdoptionError<C> {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_struct("ContainmentAdoptionError")
.field("error", &self.error)
.finish_non_exhaustive()
}
}
impl<C> std::fmt::Display for ContainmentAdoptionError<C> {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.error.fmt(formatter)
}
}
impl<C> std::error::Error for ContainmentAdoptionError<C> {}
#[derive(Debug)]
pub enum ContainmentSpawnError {
Spawn(SysprimsError),
Adoption(SysprimsError),
}
impl std::fmt::Display for ContainmentSpawnError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Spawn(error) => error.fmt(formatter),
Self::Adoption(error) => error.fmt(formatter),
}
}
}
impl std::error::Error for ContainmentSpawnError {}
pub struct ContainmentGuard<C: ContainmentChild> {
child: Option<C>,
identity: ContainmentIdentity,
reliability: TreeKillReliability,
boundary_strength: ContainmentBoundaryStrength,
finalized: bool,
#[cfg(unix)]
pgid: u32,
#[cfg(unix)]
session_id: u32,
#[cfg(unix)]
session_receipt: Option<sysprims_session::UnixSessionReceipt>,
#[cfg(windows)]
job: std::os::windows::io::OwnedHandle,
}
impl<C: ContainmentChild> ContainmentGuard<C> {
pub fn identity(&self) -> &ContainmentIdentity {
&self.identity
}
pub fn tree_kill_reliability(&self) -> TreeKillReliability {
self.reliability
}
pub fn boundary_strength(&self) -> ContainmentBoundaryStrength {
self.boundary_strength
}
pub fn into_child(mut self) -> Result<C, Self> {
if self.finalized {
Ok(self
.child
.take()
.expect("finalized guard retains its child"))
} else {
Err(self)
}
}
pub fn try_complete(
&mut self,
config: TerminateTreeConfig,
) -> SysprimsResult<Option<ContainmentOutcome>> {
if self.finalized {
return Err(SysprimsError::invalid_argument(
"containment guard has already been finalized",
));
}
#[cfg(unix)]
if !unix::contained_child_has_exited(self)? {
return Ok(None);
}
#[cfg(windows)]
if !windows::contained_child_has_exited(self)? {
return Ok(None);
}
self.terminate(config).map(Some)
}
pub fn terminate(&mut self, config: TerminateTreeConfig) -> SysprimsResult<ContainmentOutcome> {
if self.finalized {
return Err(SysprimsError::invalid_argument(
"containment guard has already been finalized",
));
}
#[cfg(unix)]
return unix::terminate_contained_impl(self, config);
#[cfg(windows)]
return windows::terminate_contained_impl(self, config);
}
}
impl<C: ContainmentChild> Drop for ContainmentGuard<C> {
fn drop(&mut self) {
if self.finalized || self.child.is_none() {
return;
}
#[cfg(unix)]
unix::drop_contained_impl(self);
#[cfg(windows)]
windows::drop_contained_impl(self);
}
}
#[derive(Debug, Clone, Serialize)]
pub struct ContainmentOutcome {
pub identity: ContainmentIdentity,
#[serde(skip_serializing_if = "Option::is_none")]
pub pgid: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub signal_sent: Option<i32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub kill_signal: Option<i32>,
pub escalated: bool,
pub exited: bool,
pub timed_out: bool,
pub tree_kill_reliability: TreeKillReliability,
pub boundary_strength: ContainmentBoundaryStrength,
pub completion: ContainmentCompletionEvidence,
pub warnings: Vec<String>,
}
pub fn adopt_contained<C: ContainmentChild>(
child: C,
) -> Result<ContainmentGuard<C>, ContainmentAdoptionError<C>> {
#[cfg(unix)]
return unix::adopt_contained_impl(child);
#[cfg(windows)]
return windows::adopt_contained_impl(child);
}
#[cfg(unix)]
pub unsafe fn contain_acquired_session<C: ContainmentChild>(
child: C,
receipt: sysprims_session::UnixSessionReceipt,
) -> Result<ContainmentGuard<C>, ContainmentAdoptionError<C>> {
unix::contain_acquired_session_impl(child, receipt)
}
#[cfg(windows)]
pub unsafe fn contain_acquired_windows_job<C: ContainmentChild>(
child: C,
receipt: WindowsJobReceipt,
) -> Result<ContainmentGuard<C>, ContainmentAdoptionError<C>> {
windows::contain_acquired_windows_job_impl(child, receipt)
}
pub fn spawn_contained(command: Command) -> Result<ContainmentGuard<Child>, ContainmentSpawnError> {
#[cfg(unix)]
return unix::spawn_contained_impl(command);
#[cfg(windows)]
return windows::spawn_contained_impl(command);
}
fn capture_containment_identity(pid: u32) -> SysprimsResult<ContainmentIdentity> {
capture_containment_identity_with_mode(pid, ContainmentIdentityValidation::Strict)
}
#[cfg(unix)]
fn capture_receipt_bound_containment_identity(pid: u32) -> SysprimsResult<ContainmentIdentity> {
capture_containment_identity_with_mode(
pid,
ContainmentIdentityValidation::ReceiptBoundExecVolatile,
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ContainmentIdentityValidation {
Strict,
#[cfg(unix)]
ReceiptBoundExecVolatile,
}
fn capture_containment_identity_with_mode(
pid: u32,
mode: ContainmentIdentityValidation,
) -> SysprimsResult<ContainmentIdentity> {
if pid == 0 || pid > sysprims_signal::MAX_SAFE_PID {
return Err(SysprimsError::invalid_argument(format!(
"pid {pid} is outside the safe process identity range"
)));
}
let process = sysprims_proc::get_process(pid)?;
let start_time_unix_ms = process.start_time_unix_ms.ok_or_else(|| {
SysprimsError::system(
"process start time unavailable during containment acquisition",
0,
)
})?;
let exe_path = match (mode, process.exe_path.filter(|path| !path.is_empty())) {
(_, Some(path)) => path,
(ContainmentIdentityValidation::Strict, None) => {
return Err(SysprimsError::system(
"process executable unavailable during containment acquisition",
0,
));
}
#[cfg(unix)]
(ContainmentIdentityValidation::ReceiptBoundExecVolatile, None) => String::new(),
};
Ok(ContainmentIdentity {
pid,
start_time_unix_ms,
exe_path,
})
}
#[cfg(unix)]
fn verify_containment_identity(
expected: &ContainmentIdentity,
mode: ContainmentIdentityValidation,
) -> SysprimsResult<bool> {
let process = match sysprims_proc::get_process(expected.pid) {
Ok(process) => process,
Err(SysprimsError::NotFound { .. } | SysprimsError::PermissionDenied { .. }) => {
return Ok(false);
}
Err(error) => return Err(error),
};
verify_containment_identity_observation(
expected,
process.start_time_unix_ms,
process.exe_path.as_deref(),
mode,
)
}
#[cfg(unix)]
fn verify_containment_identity_observation(
expected: &ContainmentIdentity,
actual_start_time_unix_ms: Option<u64>,
actual_exe_path: Option<&str>,
mode: ContainmentIdentityValidation,
) -> SysprimsResult<bool> {
if actual_start_time_unix_ms.is_some_and(|actual| actual != expected.start_time_unix_ms) {
return Err(SysprimsError::invalid_argument(
"process identity changed; refusing containment operation",
));
}
match mode {
ContainmentIdentityValidation::Strict => {
if actual_exe_path.is_some_and(|actual| actual != expected.exe_path) {
return Err(SysprimsError::invalid_argument(
"process identity changed; refusing containment operation",
));
}
Ok(actual_start_time_unix_ms.is_some() && actual_exe_path.is_some())
}
ContainmentIdentityValidation::ReceiptBoundExecVolatile => {
Ok(actual_start_time_unix_ms.is_some())
}
}
}
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TerminateTreeConfig {
#[serde(default = "default_grace_timeout_ms")]
pub grace_timeout_ms: u64,
#[serde(default = "default_kill_timeout_ms")]
pub kill_timeout_ms: u64,
#[serde(default = "default_grace_signal")]
pub signal: i32,
#[serde(default = "default_kill_signal")]
pub kill_signal: i32,
}
fn default_grace_timeout_ms() -> u64 {
10_000
}
fn default_kill_timeout_ms() -> u64 {
2_000
}
fn default_grace_signal() -> i32 {
SIGTERM
}
fn default_kill_signal() -> i32 {
SIGKILL
}
impl Default for TerminateTreeConfig {
fn default() -> Self {
Self {
grace_timeout_ms: default_grace_timeout_ms(),
kill_timeout_ms: default_kill_timeout_ms(),
signal: default_grace_signal(),
kill_signal: default_kill_signal(),
}
}
}
#[derive(Debug, Clone, Serialize)]
pub struct TerminateTreeResult {
pub schema_id: &'static str,
pub timestamp: String,
pub platform: &'static str,
pub pid: u32,
#[serde(skip_serializing_if = "Option::is_none")]
pub pgid: Option<u32>,
pub signal_sent: i32,
#[serde(skip_serializing_if = "Option::is_none")]
pub kill_signal: Option<i32>,
pub escalated: bool,
pub exited: bool,
pub timed_out: bool,
pub tree_kill_reliability: String,
pub warnings: Vec<String>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SpawnInGroupConfig {
pub argv: Vec<String>,
#[serde(default)]
pub cwd: Option<String>,
#[serde(default)]
pub env: Option<std::collections::BTreeMap<String, String>>,
}
#[derive(Debug, Clone, Serialize)]
pub struct SpawnInGroupResult {
pub schema_id: &'static str,
pub timestamp: String,
pub platform: &'static str,
pub pid: u32,
#[serde(skip_serializing_if = "Option::is_none")]
pub pgid: Option<u32>,
pub tree_kill_reliability: String,
pub warnings: Vec<String>,
}
pub fn spawn_in_group(config: SpawnInGroupConfig) -> SysprimsResult<SpawnInGroupResult> {
if config.argv.is_empty() {
return Err(SysprimsError::invalid_argument("argv must not be empty"));
}
if config.argv[0].is_empty() {
return Err(SysprimsError::invalid_argument(
"argv[0] (command) must not be empty",
));
}
#[cfg(unix)]
return unix::spawn_in_group_impl(config);
#[cfg(windows)]
return windows::spawn_in_group_impl(config);
}
pub fn terminate_tree(
pid: u32,
config: TerminateTreeConfig,
) -> SysprimsResult<TerminateTreeResult> {
if pid == 0 {
return Err(SysprimsError::invalid_argument("pid must be > 0"));
}
if pid > sysprims_signal::MAX_SAFE_PID {
return Err(SysprimsError::invalid_argument(format!(
"pid {} exceeds maximum safe value {}",
pid,
sysprims_signal::MAX_SAFE_PID
)));
}
managed::validate_terminate_tree_config(&config)?;
let mut warnings: Vec<String> = Vec::new();
let pgid: Option<u32> = None;
let reliability = TreeKillReliability::BestEffort;
#[cfg(windows)]
warnings.push(
"Windows PID termination is best-effort; use an owned containment guard for Job Objects"
.to_string(),
);
#[cfg(unix)]
warnings.push(
"PID-only termination has no sealed group capability; signaling the target PID only"
.to_string(),
);
sysprims_signal::kill(pid, config.signal)?;
let grace = Duration::from_millis(config.grace_timeout_ms);
let grace_wait = wait_pid(pid, grace)?;
if grace_wait.exited {
return Ok(TerminateTreeResult {
schema_id: TERMINATE_TREE_RESULT_V1,
timestamp: now_rfc3339(),
platform: get_platform(),
pid,
pgid,
signal_sent: config.signal,
kill_signal: None,
escalated: false,
exited: true,
timed_out: false,
tree_kill_reliability: reliability.as_str().to_string(),
warnings,
});
}
sysprims_signal::kill(pid, config.kill_signal)?;
let kill_wait = wait_pid(pid, Duration::from_millis(config.kill_timeout_ms))?;
let mut exited = kill_wait.exited;
let mut timed_out = kill_wait.timed_out;
if timed_out {
match sysprims_proc::get_process(pid) {
Ok(_) => {
}
Err(SysprimsError::NotFound { .. }) => {
exited = true;
timed_out = false;
warnings.push("PID no longer found after timeout; treating as exited".to_string());
}
Err(SysprimsError::PermissionDenied { .. }) => {
warnings.push("Permission denied while confirming exit after timeout".to_string());
}
Err(e) => {
warnings.push(format!("Failed to confirm exit after timeout: {}", e));
}
}
}
Ok(TerminateTreeResult {
schema_id: TERMINATE_TREE_RESULT_V1,
timestamp: now_rfc3339(),
platform: get_platform(),
pid,
pgid,
signal_sent: config.signal,
kill_signal: Some(config.kill_signal),
escalated: true,
exited,
timed_out,
tree_kill_reliability: reliability.as_str().to_string(),
warnings,
})
}
#[derive(Debug)]
pub enum TimeoutOutcome {
Completed {
exit_status: ExitStatus,
},
TimedOut {
signal_sent: i32,
escalated: bool,
tree_kill_reliability: TreeKillReliability,
},
}
pub fn run_with_timeout(
command: &str,
args: &[&str],
timeout: Duration,
config: TimeoutConfig,
) -> SysprimsResult<TimeoutOutcome> {
#[cfg(unix)]
return unix::run_with_timeout_impl(command, args, timeout, &config);
#[cfg(windows)]
return windows::run_with_timeout_impl(command, args, timeout, &config);
}
pub fn run_with_timeout_default(
command: &str,
args: &[&str],
timeout: Duration,
) -> SysprimsResult<TimeoutOutcome> {
run_with_timeout(command, args, timeout, TimeoutConfig::default())
}
#[cfg(test)]
mod tests {
use super::*;
use std::process::{Command, Stdio};
struct ChildWithoutPid;
impl ContainmentChild for ChildWithoutPid {
fn process_id(&self) -> Option<u32> {
None
}
fn try_wait(&mut self) -> std::io::Result<bool> {
Ok(false)
}
#[cfg(windows)]
fn raw_process_handle(&self) -> Option<std::os::windows::io::RawHandle> {
None
}
}
#[test]
fn default_config_uses_sigterm() {
let config = TimeoutConfig::default();
assert_eq!(config.signal, SIGTERM);
}
#[test]
fn default_config_uses_group_by_default() {
let config = TimeoutConfig::default();
assert_eq!(config.grouping, GroupingMode::GroupByDefault);
}
#[test]
fn default_config_kill_after_is_10_seconds() {
let config = TimeoutConfig::default();
assert_eq!(config.kill_after, Duration::from_secs(10));
}
#[test]
fn default_config_does_not_preserve_status() {
let config = TimeoutConfig::default();
assert!(!config.preserve_status);
}
#[test]
fn reliability_strings_include_unproven() {
assert_eq!(TreeKillReliability::Guaranteed.as_str(), "guaranteed");
assert_eq!(TreeKillReliability::Unproven.as_str(), "unproven");
assert_eq!(TreeKillReliability::BestEffort.as_str(), "best_effort");
}
#[test]
fn boundary_strength_strings_are_independent() {
assert_eq!(
ContainmentBoundaryStrength::KernelEnforcedJob.as_str(),
"kernel_enforced_job"
);
assert_eq!(
ContainmentBoundaryStrength::CooperativeGroup.as_str(),
"cooperative_group"
);
assert_eq!(ContainmentBoundaryStrength::Unknown.as_str(), "unknown");
}
#[test]
#[cfg(unix)]
fn receipt_bound_identity_treats_executable_as_observational() {
let expected = ContainmentIdentity {
pid: 42,
start_time_unix_ms: 1_000,
exe_path: "/before-exec".to_string(),
};
assert!(verify_containment_identity_observation(
&expected,
Some(1_000),
Some("/after-two-execs"),
ContainmentIdentityValidation::ReceiptBoundExecVolatile,
)
.unwrap());
assert!(verify_containment_identity_observation(
&expected,
Some(1_000),
None,
ContainmentIdentityValidation::ReceiptBoundExecVolatile,
)
.unwrap());
}
#[test]
#[cfg(unix)]
fn receipt_bound_identity_requires_matching_observable_start_time() {
let expected = ContainmentIdentity {
pid: 42,
start_time_unix_ms: 1_000,
exe_path: "/before-exec".to_string(),
};
assert!(!verify_containment_identity_observation(
&expected,
None,
Some("/after-exec"),
ContainmentIdentityValidation::ReceiptBoundExecVolatile,
)
.unwrap());
assert!(matches!(
verify_containment_identity_observation(
&expected,
Some(2_000),
Some("/after-exec"),
ContainmentIdentityValidation::ReceiptBoundExecVolatile,
),
Err(SysprimsError::InvalidArgument { .. })
));
}
#[test]
#[cfg(unix)]
fn adopted_identity_keeps_strict_executable_validation() {
let expected = ContainmentIdentity {
pid: 42,
start_time_unix_ms: 1_000,
exe_path: "/before-exec".to_string(),
};
assert!(matches!(
verify_containment_identity_observation(
&expected,
Some(1_000),
Some("/after-exec"),
ContainmentIdentityValidation::Strict,
),
Err(SysprimsError::InvalidArgument { .. })
));
assert!(!verify_containment_identity_observation(
&expected,
Some(1_000),
None,
ContainmentIdentityValidation::Strict,
)
.unwrap());
}
#[test]
fn completion_evidence_sorts_unique_safe_pids() {
assert_eq!(
completion_from_pids(
ContainmentObservation::LinuxProcfsProcessGroup,
vec![42, 7, 19],
),
ContainmentCompletionEvidence::Survivors {
observation: ContainmentObservation::LinuxProcfsProcessGroup,
observed_count: 3,
survivor_pids: vec![7, 19, 42],
}
);
}
#[test]
fn duplicate_completion_evidence_is_unknown() {
assert_eq!(
completion_from_pids(ContainmentObservation::LinuxProcfsProcessGroup, vec![7, 7],),
ContainmentCompletionEvidence::Unknown {
observation: ContainmentObservation::LinuxProcfsProcessGroup,
}
);
}
#[test]
fn completion_evidence_at_pid_limit_is_unknown() {
let pids = (2..2 + MAX_COMPLETION_OBSERVED_PIDS as u32).collect();
assert_eq!(
completion_from_pids(ContainmentObservation::LinuxProcfsProcessGroup, pids),
ContainmentCompletionEvidence::Unknown {
observation: ContainmentObservation::LinuxProcfsProcessGroup,
}
);
}
#[test]
fn completion_evidence_serializes_as_a_tagged_receipt() {
let value = serde_json::to_value(ContainmentCompletionEvidence::Survivors {
observation: ContainmentObservation::MacosLibprocProcessGroup,
observed_count: 2,
survivor_pids: vec![17, 23],
})
.expect("completion evidence should serialize");
assert_eq!(
value,
serde_json::json!({
"status": "survivors",
"observation": "macos_libproc_process_group",
"observed_count": 2,
"survivor_pids": [17, 23],
})
);
}
#[test]
fn failed_adoption_returns_child_ownership() {
let error = match adopt_contained(ChildWithoutPid) {
Ok(_) => panic!("adoption without a pid must fail"),
Err(error) => error,
};
assert!(matches!(error.error, SysprimsError::InvalidArgument { .. }));
assert!(error.child.process_id().is_none());
}
#[test]
fn terminate_tree_rejects_pid_zero() {
let err = terminate_tree(0, TerminateTreeConfig::default()).unwrap_err();
assert!(matches!(err, SysprimsError::InvalidArgument { .. }));
}
#[test]
#[cfg(unix)]
fn terminate_tree_kills_spawned_child() {
let mut child = Command::new("sleep")
.arg("60")
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
.expect("Failed to spawn sleep process");
let pid = child.id();
let result = terminate_tree(
pid,
TerminateTreeConfig {
grace_timeout_ms: 100,
kill_timeout_ms: 5000,
..TerminateTreeConfig::default()
},
)
.expect("terminate_tree should succeed");
assert_eq!(result.pid, pid);
assert!(
result.exited,
"expected child to be exited, got: {result:?}"
);
assert!(!result.timed_out, "unexpected timeout: {result:?}");
assert_eq!(result.tree_kill_reliability, "best_effort");
assert_eq!(result.pgid, None);
let _ = child.wait();
}
#[test]
#[cfg(windows)]
fn terminate_tree_kills_spawned_child() {
let mut child = Command::new("cmd")
.args(["/C", "ping -n 60 127.0.0.1 >NUL"])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
.expect("Failed to spawn ping sleep process");
let pid = child.id();
let result = terminate_tree(
pid,
TerminateTreeConfig {
grace_timeout_ms: 100,
kill_timeout_ms: 5000,
..TerminateTreeConfig::default()
},
)
.expect("terminate_tree should succeed");
assert_eq!(result.pid, pid);
let _ = child.wait();
}
}