use std::collections::{BTreeSet, HashMap, HashSet};
use std::future::Future;
use std::sync::{Arc, Mutex as StdMutex, OnceLock, Weak};
use std::time::Duration;
use netstat2::{
AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo, SocketInfo, TcpState, get_sockets_info,
};
use regex::Regex;
use sha2::{Digest, Sha256};
use sysinfo::{Pid, ProcessesToUpdate, Signal, System};
use crate::model::{
ActionReceipt, ActionResult, Execution, PortInfo, ProcessController, ProcessDossier,
ProcessEvent, ProcessEventQuery, ProcessFile, ProcessIdentity, ProcessInfo, ProcessInsight,
ProcessPredicate, ProcessProbe, ProcessQuery, ProcessSelection, ProcessWait, ProfileSelection,
now_ms,
};
use crate::store::Store;
tokio::task_local! {
static EXECUTION_ID: String;
static WORKSPACE_CWD: String;
static VERBOSITY: String;
static PROFILE_SELECTION: ProfileSelection;
static HOOK_DEPTH: u32;
static DECIDER_DEPTH: u32;
}
static MUTATION_LOCKS: OnceLock<StdMutex<HashMap<String, Weak<tokio::sync::Mutex<()>>>>> =
OnceLock::new();
pub struct ProcessManager {
system: System,
store: OnceLock<Result<Arc<Store>, String>>,
full_refreshed_at: Option<std::time::Instant>,
pid_refreshed_at: HashMap<u32, std::time::Instant>,
}
impl Default for ProcessManager {
fn default() -> Self {
Self::new()
}
}
impl ProcessManager {
pub fn new() -> Self {
Self {
system: System::new(),
store: OnceLock::new(),
full_refreshed_at: None,
pid_refreshed_at: HashMap::new(),
}
}
pub fn with_store(store: Arc<Store>) -> Self {
let state = OnceLock::new();
let _ = state.set(Ok(store));
Self {
system: System::new(),
store: state,
full_refreshed_at: None,
pid_refreshed_at: HashMap::new(),
}
}
pub fn list(
&mut self,
selector: Option<&str>,
sort: &str,
limit: usize,
) -> Result<Vec<ProcessInfo>, String> {
let selector = selector.unwrap_or("all");
self.refresh_selector(selector);
let selection = self.resolve(selector)?;
let selected = selection
.processes
.iter()
.map(|identity| identity.pid)
.collect::<BTreeSet<_>>();
let mut processes = self
.system
.processes()
.values()
.filter(|process| selected.contains(&process.pid().as_u32()))
.map(process_info)
.collect::<Vec<_>>();
match sort {
"pid" => processes.sort_by_key(|process| process.identity.pid),
"name" => processes.sort_by(|left, right| {
left.identity
.name
.to_lowercase()
.cmp(&right.identity.name.to_lowercase())
}),
"memory" => {
processes.sort_by_key(|process| std::cmp::Reverse(process.memory_bytes));
}
"runtime" => {
processes.sort_by_key(|process| std::cmp::Reverse(process.runtime_seconds));
}
"cpu" => processes.sort_by(|left, right| {
right
.cpu_percent
.total_cmp(&left.cpu_percent)
.then_with(|| left.identity.pid.cmp(&right.identity.pid))
}),
value => return Err(format!("Unknown sort \"{value}\"")),
}
processes.truncate(limit);
Ok(processes)
}
pub fn query(&mut self, query: &ProcessQuery, agent: bool) -> Result<Vec<ProcessInfo>, String> {
self.refresh_all();
let store = self.store()?;
let all = prepare_predicates(&query.all, &store)?;
let any = prepare_predicates(&query.any, &store)?;
let not = prepare_predicates(&query.not, &store)?;
let mut processes = self
.system
.processes()
.values()
.map(process_info)
.filter(|process| {
all.iter().all(|predicate| predicate.matches(process))
&& (any.is_empty() || any.iter().any(|predicate| predicate.matches(process)))
&& !not.iter().any(|predicate| predicate.matches(process))
})
.collect::<Vec<_>>();
sort_processes(&mut processes, &query.sort)?;
processes.truncate(query.limit);
store.record_processes(
&processes,
"process.query",
"observed",
None,
&controller(agent),
"observed",
None,
&serde_json::to_value(query).map_err(|error| error.to_string())?,
)?;
Ok(processes)
}
pub fn probe(&mut self, target: &str, agent: bool) -> Result<ProcessProbe, String> {
let processes = if target.contains('@') {
let dossier = self.store()?.process_dossier(target, 1)?;
let identity = dossier.context.latest.identity;
identity_for_pid(identity.pid)
.ok()
.filter(|current| current == &identity)
.into_iter()
.collect()
} else {
self.refresh_selector_force(target);
self.resolve(target)?.processes
};
let snapshots = self.snapshots(&processes);
self.record(
&snapshots,
"process.probe",
"observed",
Some(target),
agent,
"observed",
None,
&serde_json::json!({ "exists": !processes.is_empty() }),
)?;
Ok(ProcessProbe {
target: target.to_string(),
exists: !processes.is_empty(),
processes,
observed_at: now_ms(),
})
}
pub fn files(&mut self, target: &str, agent: bool) -> Result<Vec<ProcessFile>, String> {
self.refresh_selector(target);
let selection = self.resolve(target)?;
let snapshots = self.snapshots(&selection.processes);
let mut files = Vec::new();
for identity in &selection.processes {
files.extend(process_files(identity)?);
}
self.record(
&snapshots,
"process.files",
"observed",
Some(target),
agent,
"observed",
None,
&serde_json::json!({ "files": files.len() }),
)?;
Ok(files)
}
pub fn insight(
&mut self,
kind: &str,
target: &str,
event_limit: usize,
agent: bool,
) -> Result<ProcessInsight, String> {
if !matches!(kind, "why" | "impact" | "owner" | "related" | "changed") {
return Err(format!("Unknown process insight \"{kind}\""));
}
let mut processes = if target.contains('@') {
vec![
self.store()?
.process_dossier(target, event_limit)?
.context
.latest,
]
} else if matches!(kind, "impact" | "related") {
self.tree(target)?
} else {
self.list(Some(target), "pid", usize::MAX)?
};
processes.sort_by_key(|process| process.identity.pid);
processes.dedup_by(|left, right| left.identity == right.identity);
let keys = processes
.iter()
.map(|process| process_context_key(&process.identity))
.collect::<HashSet<_>>();
let store = self.store()?;
let executions = store
.list_execution_records()?
.into_iter()
.filter(|execution| {
execution.attempts.iter().any(|attempt| {
attempt
.processes
.iter()
.any(|identity| keys.contains(&process_context_key(identity)))
})
})
.collect::<Vec<Execution>>();
let execution_ids = executions
.iter()
.map(|execution| execution.id.as_str())
.collect::<HashSet<_>>();
let leases = store
.list_leases(false)?
.into_iter()
.filter(|lease| {
execution_ids.contains(lease.owner_id.as_str())
|| lease.resources.iter().any(|resource| {
resource
.strip_prefix("process/")
.is_some_and(|key| keys.contains(key))
})
})
.collect::<Vec<_>>();
let lease_ids = leases
.iter()
.map(|lease| lease.id.as_str())
.collect::<HashSet<_>>();
let reservations = store
.list_reservations(false)?
.into_iter()
.filter(|reservation| lease_ids.contains(reservation.lease_id.as_str()))
.collect::<Vec<_>>();
let mut events = Vec::new();
for key in &keys {
events.extend(store.causal_events_for_subject(key, event_limit)?);
}
events.sort_by_key(|event| std::cmp::Reverse(event.sequence));
events.truncate(event_limit);
self.record(
&processes,
&format!("process.{kind}"),
"observed",
Some(target),
agent,
"observed",
None,
&serde_json::json!({ "event_limit": event_limit }),
)?;
Ok(ProcessInsight {
kind: kind.to_string(),
target: target.to_string(),
processes,
executions,
leases,
reservations,
events,
limitations: vec![
"apoc reports recorded process, execution, lease, reservation, and process-tree relationships only."
.to_string(),
"Unrecorded semantic dependencies are not inferred.".to_string(),
],
})
}
#[allow(clippy::too_many_arguments)]
pub fn record(
&self,
processes: &[ProcessInfo],
operation: &str,
phase: &str,
selector: Option<&str>,
agent: bool,
origin: &str,
managed_execution_id: Option<&str>,
details: &serde_json::Value,
) -> Result<Vec<ProcessEvent>, String> {
self.record_with_controller(
processes,
operation,
phase,
selector,
&controller(agent),
origin,
managed_execution_id,
details,
)
}
#[allow(clippy::too_many_arguments)]
pub fn record_with_controller(
&self,
processes: &[ProcessInfo],
operation: &str,
phase: &str,
selector: Option<&str>,
controller: &ProcessController,
origin: &str,
managed_execution_id: Option<&str>,
details: &serde_json::Value,
) -> Result<Vec<ProcessEvent>, String> {
self.store()?.record_processes(
processes,
operation,
phase,
selector,
controller,
origin,
managed_execution_id,
details,
)
}
pub fn dossiers(
&mut self,
target: &str,
event_limit: usize,
agent: bool,
) -> Result<Vec<ProcessDossier>, String> {
let store = self.store()?;
if target.contains('@') {
let dossier = store.process_dossier(target, event_limit)?;
store.record_processes(
std::slice::from_ref(&dossier.context.latest),
"process.context",
"observed",
Some(target),
&controller(agent),
&dossier.context.origin,
dossier.context.execution_id.as_deref(),
&serde_json::json!({ "event_limit": event_limit }),
)?;
return store
.process_dossier(target, event_limit)
.map(|dossier| vec![dossier]);
}
self.refresh_selector(target);
let selection = self.resolve(target)?;
if selection.processes.is_empty()
&& let Some(pid) = selector_pid(target)
{
let dossiers = store.process_dossiers_for_pid(pid, event_limit)?;
for dossier in &dossiers {
store.record_processes(
std::slice::from_ref(&dossier.context.latest),
"process.context",
"observed",
Some(target),
&controller(agent),
&dossier.context.origin,
dossier.context.execution_id.as_deref(),
&serde_json::json!({ "event_limit": event_limit }),
)?;
}
return dossiers
.into_iter()
.map(|dossier| store.process_dossier(&dossier.context.key, event_limit))
.collect();
}
let snapshots = self.snapshots(&selection.processes);
store.record_processes(
&snapshots,
"process.context",
"observed",
Some(target),
&controller(agent),
"observed",
None,
&serde_json::json!({ "event_limit": event_limit }),
)?;
selection
.processes
.iter()
.map(|identity| store.process_dossier(&process_context_key(identity), event_limit))
.collect()
}
pub fn snapshots(&self, identities: &[ProcessIdentity]) -> Vec<ProcessInfo> {
identities
.iter()
.filter_map(|identity| {
self.system
.process(Pid::from_u32(identity.pid))
.filter(|process| process.start_time() == identity.started_at)
.map(process_info)
})
.collect()
}
pub fn snapshots_for_pids(&mut self, pids: &[u32]) -> Vec<ProcessInfo> {
let pids = pids
.iter()
.copied()
.collect::<BTreeSet<_>>()
.into_iter()
.map(Pid::from_u32)
.collect::<Vec<_>>();
if pids.is_empty() {
return Vec::new();
}
self.system
.refresh_processes(ProcessesToUpdate::Some(&pids), true);
pids.iter()
.filter_map(|pid| self.system.process(*pid).map(process_info))
.collect()
}
pub fn get(&mut self, selector: &str) -> Result<ProcessInfo, String> {
self.refresh_selector(selector);
let selection = self.resolve(selector)?;
if selection.processes.len() != 1 {
return Err(format!(
"Selector \"{selector}\" resolved to {} processes; expected exactly one",
selection.processes.len()
));
}
let identity = &selection.processes[0];
self.system
.process(Pid::from_u32(identity.pid))
.filter(|process| process.start_time() == identity.started_at)
.map(process_info)
.ok_or_else(|| format!("Process {} is no longer running", identity.pid))
}
pub fn resolve(&self, selector: &str) -> Result<ProcessSelection, String> {
let mut identities = if selector == "all" {
self.system
.processes()
.values()
.map(process_identity)
.collect::<Vec<_>>()
} else if let Some(value) = selector.strip_prefix("pid:") {
let pid = value
.parse::<u32>()
.map_err(|_| format!("Invalid PID selector \"{selector}\""))?;
self.system
.process(Pid::from_u32(pid))
.map(process_identity)
.into_iter()
.collect()
} else if let Some(value) = selector.strip_prefix("name:") {
self.system
.processes()
.values()
.filter(|process| process.name().to_string_lossy() == value)
.map(process_identity)
.collect()
} else if let Some(value) = selector.strip_prefix("match:") {
let regex = Regex::new(value).map_err(|error| error.to_string())?;
self.system
.processes()
.values()
.filter(|process| {
regex.is_match(&process.name().to_string_lossy())
|| regex.is_match(&command_line(process))
})
.map(process_identity)
.collect()
} else if let Some(value) = selector.strip_prefix("pgid:") {
let pgid = value
.parse::<i32>()
.map_err(|_| format!("Invalid process-group selector \"{selector}\""))?;
self.system
.processes()
.values()
.filter(|process| process_group(process.pid().as_u32()) == Some(pgid as u32))
.map(process_identity)
.collect()
} else if let Some(value) = selector.strip_prefix("port:") {
let (port, protocol) = parse_port_selector(value)?;
let pids = port_owners(port, protocol.as_deref())?
.into_iter()
.flat_map(|socket| socket.pids)
.collect::<BTreeSet<_>>();
self.system
.processes()
.values()
.filter(|process| pids.contains(&process.pid().as_u32()))
.map(process_identity)
.collect()
} else if let Ok(pid) = selector.parse::<u32>() {
self.system
.process(Pid::from_u32(pid))
.map(process_identity)
.into_iter()
.collect()
} else {
return Err(format!(
"Unknown selector \"{selector}\"; use pid:, name:, match:, pgid:, port:, or all"
));
};
identities.sort_by_key(|identity| identity.pid);
let resolved_at = now_ms();
let bytes = serde_json::to_vec(&identities).map_err(|error| error.to_string())?;
Ok(ProcessSelection {
id: format!("{:x}", Sha256::digest(bytes)),
selector: selector.to_string(),
resolved_at,
processes: identities,
})
}
pub fn select(&mut self, selector: &str) -> Result<ProcessSelection, String> {
self.refresh_selector(selector);
self.resolve(selector)
}
pub fn tree(&mut self, selector: &str) -> Result<Vec<ProcessInfo>, String> {
self.refresh_all();
let roots = self.resolve(selector)?;
let mut children = HashMap::<u32, Vec<u32>>::new();
for process in self.system.processes().values() {
if let Some(parent) = process.parent() {
children
.entry(parent.as_u32())
.or_default()
.push(process.pid().as_u32());
}
}
for values in children.values_mut() {
values.sort_unstable();
}
let mut seen = BTreeSet::new();
let mut ordered = Vec::new();
for root in roots.processes {
append_tree(root.pid, &self.system, &children, &mut seen, &mut ordered);
}
Ok(ordered)
}
pub(crate) fn trees_for_identities(
&mut self,
roots: &[ProcessIdentity],
) -> Vec<(ProcessIdentity, Vec<ProcessInfo>)> {
self.refresh_all();
let mut children = HashMap::<u32, Vec<u32>>::new();
for process in self.system.processes().values() {
if let Some(parent) = process.parent() {
children
.entry(parent.as_u32())
.or_default()
.push(process.pid().as_u32());
}
}
for values in children.values_mut() {
values.sort_unstable();
}
roots
.iter()
.filter_map(|captured| {
let process = self.system.process(Pid::from_u32(captured.pid))?;
let current = process_identity(process);
if !same_process(captured, ¤t) {
return None;
}
let mut seen = BTreeSet::new();
let mut processes = Vec::new();
append_tree(
captured.pid,
&self.system,
&children,
&mut seen,
&mut processes,
);
if let Some(root) = processes.first_mut() {
root.identity = captured.clone();
}
Some((captured.clone(), processes))
})
.collect()
}
pub(crate) fn infos_for_identities(
&mut self,
identities: &[ProcessIdentity],
) -> Vec<ProcessInfo> {
let pids = identities
.iter()
.map(|identity| Pid::from_u32(identity.pid))
.collect::<Vec<_>>();
if !pids.is_empty() {
self.system
.refresh_processes(ProcessesToUpdate::Some(&pids), true);
let refreshed_at = std::time::Instant::now();
for identity in identities {
self.pid_refreshed_at.insert(identity.pid, refreshed_at);
}
}
identities
.iter()
.filter_map(|captured| {
let process = self.system.process(Pid::from_u32(captured.pid))?;
same_process(captured, &process_identity(process)).then(|| {
let mut info = process_info(process);
info.identity = captured.clone();
info
})
})
.collect()
}
pub async fn signal(
&mut self,
selector: &str,
signal: Signal,
agent: bool,
idempotency_key: Option<&str>,
allow_empty: bool,
) -> Result<ActionReceipt, String> {
let store = self.store()?;
let id = idempotency_key
.map(ToString::to_string)
.unwrap_or_else(|| uuid::Uuid::now_v7().to_string());
if let Some(receipt) = store.get_receipt::<ActionReceipt>(&id)? {
return Ok(receipt);
}
self.refresh_selector_force(selector);
let selection = self.resolve(selector)?;
if selection.processes.is_empty() && !allow_empty {
return Err(format!(
"Selector \"{selector}\" resolved to no current processes; pass --allow-empty to accept a no-op"
));
}
let _guards = lock_processes(&selection.processes).await;
if let Some(receipt) = store.get_receipt::<ActionReceipt>(&id)? {
return Ok(receipt);
}
let started_at = now_ms();
let action = signal_name(signal).to_string();
let snapshots = self.snapshots(&selection.processes);
let controller = controller(agent);
store.record_processes(
&snapshots,
"process.signal",
"intent",
Some(selector),
&controller,
"observed",
None,
&serde_json::json!({
"signal": action,
"idempotency_key": id
}),
)?;
let results = self.apply_signal(selection.processes, signal, &action);
let completed_at = now_ms();
let receipt = ActionReceipt {
id,
selector: selector.to_string(),
action,
started_at,
completed_at,
results,
};
store.put_receipt(&receipt.id, "process_signal", &receipt)?;
let details = receipt
.results
.iter()
.map(|result| serde_json::to_value(result).map_err(|error| error.to_string()))
.collect::<Result<Vec<_>, _>>()?;
store.record_processes_with_details(
&snapshots,
"process.signal",
"result",
Some(selector),
&controller,
"observed",
None,
&details,
)?;
Ok(receipt)
}
pub async fn stop(
&mut self,
selector: &str,
timeout: Duration,
force: bool,
agent: bool,
idempotency_key: Option<&str>,
allow_empty: bool,
) -> Result<ActionReceipt, String> {
let store = self.store()?;
let id = idempotency_key
.map(ToString::to_string)
.unwrap_or_else(|| uuid::Uuid::now_v7().to_string());
if let Some(receipt) = store.get_receipt::<ActionReceipt>(&id)? {
return Ok(receipt);
}
self.refresh_selector_force(selector);
let selection = self.resolve(selector)?;
if selection.processes.is_empty() && !allow_empty {
return Err(format!(
"Selector \"{selector}\" resolved to no current processes; pass --allow-empty to accept a no-op"
));
}
let _guards = lock_processes(&selection.processes).await;
if let Some(receipt) = store.get_receipt::<ActionReceipt>(&id)? {
return Ok(receipt);
}
let snapshots = self.snapshots(&selection.processes);
let controller = controller(agent);
store.record_processes(
&snapshots,
"process.stop",
"intent",
Some(selector),
&controller,
"observed",
None,
&serde_json::json!({
"timeout_ms": timeout.as_millis(),
"force": force,
"idempotency_key": id
}),
)?;
let started_at = now_ms();
let mut receipt = ActionReceipt {
id,
selector: selector.to_string(),
action: "terminate".to_string(),
started_at,
completed_at: started_at,
results: self.apply_signal(selection.processes, Signal::Term, "terminate"),
};
let deadline = tokio::time::Instant::now() + timeout;
loop {
let pids = receipt
.results
.iter()
.map(|result| Pid::from_u32(result.process.pid))
.collect::<Vec<_>>();
self.system
.refresh_processes(ProcessesToUpdate::Some(&pids), true);
let mut alive = false;
for result in &mut receipt.results {
let running = self
.system
.process(Pid::from_u32(result.process.pid))
.is_some_and(|process| process.start_time() == result.process.started_at)
&& identity_for_pid(result.process.pid)
.is_ok_and(|current| same_process(¤t, &result.process));
result.exited = !running;
alive |= running;
}
if !alive || tokio::time::Instant::now() >= deadline {
break;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
if force {
for result in &mut receipt.results {
if result.exited {
continue;
}
if let Some(process) = self.system.process(Pid::from_u32(result.process.pid))
&& process.start_time() == result.process.started_at
&& identity_for_pid(result.process.pid)
.is_ok_and(|current| same_process(¤t, &result.process))
{
result.applied = process.kill();
result.action = "kill".to_string();
}
}
}
receipt.action = if force {
"stop_or_kill".to_string()
} else {
"stop".to_string()
};
receipt.completed_at = now_ms();
store.put_receipt(&receipt.id, "process_stop", &receipt)?;
let details = receipt
.results
.iter()
.map(|result| serde_json::to_value(result).map_err(|error| error.to_string()))
.collect::<Result<Vec<_>, _>>()?;
store.record_processes_with_details(
&snapshots,
"process.stop",
"result",
Some(selector),
&controller,
"observed",
None,
&details,
)?;
Ok(receipt)
}
fn apply_signal(
&self,
identities: Vec<ProcessIdentity>,
signal: Signal,
action: &str,
) -> Vec<ActionResult> {
identities
.into_iter()
.map(|identity| {
match self
.system
.process(Pid::from_u32(identity.pid))
.filter(|process| process.start_time() == identity.started_at)
.filter(|_| {
identity_for_pid(identity.pid)
.is_ok_and(|current| same_process(¤t, &identity))
}) {
Some(process) => match process.kill_with(signal) {
Some(true) => ActionResult {
process: identity,
action: action.to_string(),
applied: true,
exited: false,
error: None,
},
Some(false) => ActionResult {
process: identity,
action: action.to_string(),
applied: false,
exited: false,
error: Some("The operating system rejected the signal".to_string()),
},
None => ActionResult {
process: identity,
action: action.to_string(),
applied: false,
exited: false,
error: Some("The signal is unavailable on this platform".to_string()),
},
},
None => ActionResult {
process: identity,
action: action.to_string(),
applied: false,
exited: true,
error: None,
},
}
})
.collect()
}
fn store(&self) -> Result<Arc<Store>, String> {
self.store
.get_or_init(|| Store::open_default().map(Arc::new))
.as_ref()
.cloned()
.map_err(Clone::clone)
}
fn refresh_selector(&mut self, selector: &str) {
if let Some(pid) = selector_pid(selector) {
if self
.pid_refreshed_at
.get(&pid)
.is_some_and(|at| at.elapsed() < Duration::from_millis(25))
{
return;
}
self.system
.refresh_processes(ProcessesToUpdate::Some(&[Pid::from_u32(pid)]), true);
self.pid_refreshed_at.insert(pid, std::time::Instant::now());
} else {
self.refresh_all();
}
}
fn refresh_selector_force(&mut self, selector: &str) {
if let Some(pid) = selector_pid(selector) {
self.system
.refresh_processes(ProcessesToUpdate::Some(&[Pid::from_u32(pid)]), true);
self.pid_refreshed_at.insert(pid, std::time::Instant::now());
} else {
self.system.refresh_processes(ProcessesToUpdate::All, true);
self.full_refreshed_at = Some(std::time::Instant::now());
}
}
fn refresh_all(&mut self) {
if self
.full_refreshed_at
.is_some_and(|at| at.elapsed() < Duration::from_millis(50))
{
return;
}
self.system.refresh_processes(ProcessesToUpdate::All, true);
self.full_refreshed_at = Some(std::time::Instant::now());
}
}
pub fn port_owners(port: u16, protocol: Option<&str>) -> Result<Vec<PortInfo>, String> {
Ok(sockets(protocol, false, usize::MAX)?
.into_iter()
.filter(|socket| socket.port == port)
.collect())
}
pub fn sockets(
protocol: Option<&str>,
listening: bool,
limit: usize,
) -> Result<Vec<PortInfo>, String> {
let protocols = match protocol {
Some("tcp") => ProtocolFlags::TCP,
Some("udp") => ProtocolFlags::UDP,
Some(value) => return Err(format!("Unsupported protocol \"{value}\"")),
None => ProtocolFlags::TCP | ProtocolFlags::UDP,
};
let sockets = get_sockets_info(
AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6,
protocols,
)
.map_err(|error| error.to_string())?;
let mut found = sockets
.into_iter()
.filter(|socket| {
!listening
|| matches!(
socket.protocol_socket_info,
ProtocolSocketInfo::Tcp(ref info) if info.state == TcpState::Listen
)
})
.map(socket_info)
.collect::<Vec<_>>();
found.sort_by(|left, right| {
left.port
.cmp(&right.port)
.then_with(|| left.protocol.cmp(&right.protocol))
.then_with(|| left.address.cmp(&right.address))
});
found.truncate(limit);
Ok(found)
}
pub async fn wait_for(
selector: &str,
condition: &str,
interval: Duration,
timeout: Duration,
agent: bool,
) -> Result<ProcessWait, String> {
wait_for_with_manager(
ProcessManager::new(),
selector,
condition,
interval,
timeout,
agent,
)
.await
}
async fn wait_for_with_manager(
mut manager: ProcessManager,
selector: &str,
condition: &str,
interval: Duration,
timeout: Duration,
agent: bool,
) -> Result<ProcessWait, String> {
if !matches!(condition, "exists" | "exit") {
return Err(format!(
"Unknown process wait condition \"{condition}\"; use exists or exit"
));
}
let started = tokio::time::Instant::now();
manager.refresh_selector(selector);
let initial = manager.resolve(selector)?.processes;
let initial_snapshots = manager.snapshots(&initial);
manager.record(
&initial_snapshots,
"process.wait",
"intent",
Some(selector),
agent,
"observed",
None,
&serde_json::json!({
"condition": condition,
"interval_ms": interval.as_millis(),
"timeout_ms": timeout.as_millis()
}),
)?;
loop {
if condition == "exit" && !initial.is_empty() {
let pids = initial
.iter()
.map(|identity| Pid::from_u32(identity.pid))
.collect::<Vec<_>>();
manager
.system
.refresh_processes(ProcessesToUpdate::Some(&pids), true);
} else {
manager.refresh_selector(selector);
}
let processes = if condition == "exit" {
initial
.iter()
.filter(|identity| {
manager
.system
.process(Pid::from_u32(identity.pid))
.is_some_and(|process| process.start_time() == identity.started_at)
})
.cloned()
.collect::<Vec<_>>()
} else {
manager.resolve(selector)?.processes
};
let satisfied = if condition == "exit" {
processes.is_empty()
} else {
!processes.is_empty()
};
if satisfied || started.elapsed() >= timeout {
let snapshots = if condition == "exit" {
initial_snapshots.clone()
} else {
manager.snapshots(&processes)
};
manager.record(
&snapshots,
"process.wait",
"result",
Some(selector),
agent,
"observed",
None,
&serde_json::json!({
"condition": condition,
"satisfied": satisfied,
"elapsed_ms": started.elapsed().as_millis(),
"remaining": processes.len()
}),
)?;
return Ok(ProcessWait {
selector: selector.to_string(),
condition: condition.to_string(),
satisfied,
elapsed_ms: started.elapsed().as_millis() as u64,
processes,
});
}
tokio::time::sleep(interval).await;
}
}
pub fn identity_for_pid(pid: u32) -> Result<ProcessIdentity, String> {
let mut system = System::new();
system.refresh_processes(ProcessesToUpdate::Some(&[Pid::from_u32(pid)]), true);
system
.process(Pid::from_u32(pid))
.map(process_identity)
.ok_or_else(|| format!("Process {pid} was not visible after spawn"))
}
#[cfg(target_os = "macos")]
pub fn identity_for_spawn(pid: u32, executable: &str) -> Result<ProcessIdentity, String> {
let mut info = unsafe { std::mem::zeroed::<libc::proc_bsdinfo>() };
let size = std::mem::size_of::<libc::proc_bsdinfo>();
let read = unsafe {
libc::proc_pidinfo(
pid as i32,
libc::PROC_PIDTBSDINFO,
0,
std::ptr::addr_of_mut!(info).cast(),
size as i32,
)
};
if read != size as i32 {
return Err(format!("Process {pid} was not visible after spawn"));
}
let path = std::path::Path::new(executable);
Ok(ProcessIdentity {
boot_id: boot_id(),
pid,
ppid: Some(info.pbi_ppid),
pgid: Some(info.pbi_pgid),
started_at: info.pbi_start_tvsec,
started_at_ns: info
.pbi_start_tvsec
.saturating_mul(1_000_000_000)
.saturating_add(info.pbi_start_tvusec.saturating_mul(1_000)),
name: path
.file_name()
.unwrap_or(path.as_os_str())
.to_string_lossy()
.into_owned(),
executable: path.is_absolute().then(|| executable.to_string()),
})
}
#[cfg(not(target_os = "macos"))]
pub fn identity_for_spawn(pid: u32, _executable: &str) -> Result<ProcessIdentity, String> {
identity_for_pid(pid)
}
pub fn process_info_for_pid(pid: u32) -> Result<ProcessInfo, String> {
let mut system = System::new();
system.refresh_processes(ProcessesToUpdate::Some(&[Pid::from_u32(pid)]), true);
system
.process(Pid::from_u32(pid))
.map(process_info)
.ok_or_else(|| format!("Process {pid} was not visible after spawn"))
}
pub fn process_context_key(identity: &ProcessIdentity) -> String {
format!(
"{}:{}@{}",
identity.boot_id, identity.pid, identity.started_at_ns
)
}
pub(crate) fn controller(agent: bool) -> ProcessController {
let execution_id = EXECUTION_ID.try_with(ToString::to_string).ok();
let mut controller = ProcessController::capture(agent || execution_id.is_some(), execution_id);
if let Ok(cwd) = WORKSPACE_CWD.try_with(ToString::to_string) {
controller.cwd = Some(cwd);
}
if let Some(verbosity) = request_verbosity() {
controller.verbosity = Some(verbosity);
}
controller.profile_selection = PROFILE_SELECTION.try_with(Clone::clone).ok();
controller.hook_depth = HOOK_DEPTH.try_with(|depth| *depth).unwrap_or_default();
controller.decider_depth = DECIDER_DEPTH.try_with(|depth| *depth).unwrap_or_default();
controller
}
pub(crate) async fn with_request_verbosity<T>(
verbosity: String,
future: impl Future<Output = T>,
) -> T {
VERBOSITY.scope(verbosity, future).await
}
pub(crate) async fn with_execution_id<T>(
execution_id: String,
future: impl Future<Output = T>,
) -> T {
EXECUTION_ID.scope(execution_id, future).await
}
pub(crate) async fn with_execution_context<T>(
execution_id: String,
cwd: Option<String>,
verbosity: Option<String>,
profile_selection: Option<ProfileSelection>,
hook_depth: u32,
decider_depth: u32,
future: impl Future<Output = T>,
) -> T {
EXECUTION_ID
.scope(execution_id, async {
let future = async {
match verbosity {
Some(level) => VERBOSITY.scope(level, future).await,
None => future.await,
}
};
let future = async {
match cwd {
Some(cwd) => WORKSPACE_CWD.scope(cwd, future).await,
None => future.await,
}
};
let future = async {
match profile_selection {
Some(selection) => PROFILE_SELECTION.scope(selection, future).await,
None => future.await,
}
};
HOOK_DEPTH
.scope(hook_depth, DECIDER_DEPTH.scope(decider_depth, future))
.await
})
.await
}
pub(crate) fn request_verbosity() -> Option<String> {
VERBOSITY.try_with(ToString::to_string).ok()
}
fn socket_info(socket: SocketInfo) -> PortInfo {
let mut pids = socket.associated_pids;
pids.sort_unstable();
pids.dedup();
match socket.protocol_socket_info {
ProtocolSocketInfo::Tcp(info) => PortInfo {
protocol: "tcp".to_string(),
address: info.local_addr.to_string(),
port: info.local_port,
state: Some(info.state.to_string().to_lowercase()),
pids,
},
ProtocolSocketInfo::Udp(info) => PortInfo {
protocol: "udp".to_string(),
address: info.local_addr.to_string(),
port: info.local_port,
state: None,
pids,
},
}
}
pub fn parse_signal(value: &str) -> Result<Signal, String> {
match value.trim_start_matches('-').to_ascii_uppercase().as_str() {
"1" | "HUP" | "SIGHUP" => Ok(Signal::Hangup),
"2" | "INT" | "SIGINT" => Ok(Signal::Interrupt),
"3" | "QUIT" | "SIGQUIT" => Ok(Signal::Quit),
"9" | "KILL" | "SIGKILL" => Ok(Signal::Kill),
"10" | "USR1" | "SIGUSR1" => Ok(Signal::User1),
"12" | "USR2" | "SIGUSR2" => Ok(Signal::User2),
"15" | "TERM" | "SIGTERM" => Ok(Signal::Term),
"18" | "CONT" | "SIGCONT" => Ok(Signal::Continue),
"19" | "STOP" | "SIGSTOP" => Ok(Signal::Stop),
value => Err(format!("Unsupported signal \"{value}\"")),
}
}
fn process_identity(process: &sysinfo::Process) -> ProcessIdentity {
let pid = process.pid().as_u32();
let started_at = process.start_time();
ProcessIdentity {
boot_id: boot_id(),
pid,
ppid: process.parent().map(Pid::as_u32),
pgid: process_group(pid),
started_at,
started_at_ns: process_start_ns(pid, started_at),
name: process.name().to_string_lossy().into_owned(),
executable: process
.exe()
.map(|path| path.to_string_lossy().into_owned()),
}
}
fn boot_id() -> String {
format!("boot-{}", System::boot_time())
}
#[cfg(target_os = "macos")]
fn process_start_ns(pid: u32, fallback_seconds: u64) -> u64 {
let mut info = unsafe { std::mem::zeroed::<libc::proc_bsdinfo>() };
let size = std::mem::size_of::<libc::proc_bsdinfo>();
let read = unsafe {
libc::proc_pidinfo(
pid as i32,
libc::PROC_PIDTBSDINFO,
0,
std::ptr::addr_of_mut!(info).cast(),
size as i32,
)
};
if read == size as i32 {
return info
.pbi_start_tvsec
.saturating_mul(1_000_000_000)
.saturating_add(info.pbi_start_tvusec.saturating_mul(1_000));
}
fallback_seconds.saturating_mul(1_000_000_000)
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn proc_stat_start_ns(stat: &str, ticks_per_second: u64) -> Option<u64> {
if ticks_per_second == 0 {
return None;
}
let fields = stat.rsplit_once(')')?.1;
let ticks = fields.split_whitespace().nth(19)?.parse::<u64>().ok()?;
let seconds = ticks / ticks_per_second;
let remainder = ticks % ticks_per_second;
Some(
seconds
.saturating_mul(1_000_000_000)
.saturating_add(remainder.saturating_mul(1_000_000_000) / ticks_per_second),
)
}
#[cfg(target_os = "linux")]
fn process_start_ns(pid: u32, fallback_seconds: u64) -> u64 {
let ticks_per_second = u64::try_from(unsafe { libc::sysconf(libc::_SC_CLK_TCK) }).unwrap_or(0);
let since_boot = std::fs::read_to_string(format!("/proc/{pid}/stat"))
.ok()
.and_then(|stat| proc_stat_start_ns(&stat, ticks_per_second));
match since_boot {
Some(since_boot) => System::boot_time()
.saturating_mul(1_000_000_000)
.saturating_add(since_boot),
None => fallback_seconds.saturating_mul(1_000_000_000),
}
}
#[cfg(not(any(target_os = "macos", target_os = "linux")))]
fn process_start_ns(_pid: u32, fallback_seconds: u64) -> u64 {
fallback_seconds.saturating_mul(1_000_000_000)
}
fn process_info(process: &sysinfo::Process) -> ProcessInfo {
let disk = process.disk_usage();
ProcessInfo {
identity: process_identity(process),
status: format!("{:?}", process.status()).to_lowercase(),
user_id: process.user_id().map(|id| (**id).to_string()),
effective_user_id: process.effective_user_id().map(|id| (**id).to_string()),
group_id: process.group_id().map(|group| group.to_string()),
session_id: process.session_id().map(Pid::as_u32),
cpu_percent: process.cpu_usage(),
cpu_time_ms: process.accumulated_cpu_time(),
memory_bytes: process.memory(),
virtual_memory_bytes: process.virtual_memory(),
runtime_seconds: process.run_time(),
command: process
.cmd()
.iter()
.map(|part| part.to_string_lossy().into_owned())
.collect(),
cwd: process
.cwd()
.map(|path| path.to_string_lossy().into_owned()),
disk_read_bytes: disk.total_read_bytes,
disk_written_bytes: disk.total_written_bytes,
}
}
struct PreparedPredicate {
value: ProcessPredicate,
name_regex: Option<Regex>,
argv_regex: Option<Regex>,
ledger_keys: Option<HashSet<String>>,
port_pids: Option<HashSet<u32>>,
}
impl PreparedPredicate {
fn matches(&self, process: &ProcessInfo) -> bool {
let value = &self.value;
value.pid.is_none_or(|pid| process.identity.pid == pid)
&& value
.ppid
.is_none_or(|pid| process.identity.ppid == Some(pid))
&& value
.pgid
.is_none_or(|pid| process.identity.pgid == Some(pid))
&& value
.name
.as_ref()
.is_none_or(|name| &process.identity.name == name)
&& self
.name_regex
.as_ref()
.is_none_or(|regex| regex.is_match(&process.identity.name))
&& self
.argv_regex
.as_ref()
.is_none_or(|regex| regex.is_match(&process.command.join("\0")))
&& value.cwd_prefix.as_ref().is_none_or(|prefix| {
process
.cwd
.as_ref()
.is_some_and(|cwd| cwd.starts_with(prefix))
})
&& value
.status
.as_ref()
.is_none_or(|status| process.status.eq_ignore_ascii_case(status))
&& value
.user_id
.as_ref()
.is_none_or(|user| process.user_id.as_ref() == Some(user))
&& self
.ledger_keys
.as_ref()
.is_none_or(|keys| keys.contains(&process_context_key(&process.identity)))
&& self
.port_pids
.as_ref()
.is_none_or(|pids| pids.contains(&process.identity.pid))
}
}
fn prepare_predicates(
predicates: &[ProcessPredicate],
store: &Arc<Store>,
) -> Result<Vec<PreparedPredicate>, String> {
predicates
.iter()
.map(|value| {
let name_regex = value
.name_regex
.as_ref()
.map(|value| Regex::new(value).map_err(|error| error.to_string()))
.transpose()?;
let argv_regex = value
.argv_regex
.as_ref()
.map(|value| Regex::new(value).map_err(|error| error.to_string()))
.transpose()?;
let ledger_keys = if value.actor.is_some() || value.execution_id.is_some() {
Some(
store
.query_process_events(&ProcessEventQuery {
limit: 100_000,
actor: value.actor.clone(),
execution_id: value.execution_id.clone(),
..ProcessEventQuery::default()
})?
.into_iter()
.map(|event| event.process_key)
.collect(),
)
} else {
None
};
let port_pids = value
.port
.map(|port| {
port_owners(port, value.protocol.as_deref().or(Some("tcp"))).map(|ports| {
ports
.into_iter()
.flat_map(|port| port.pids)
.collect::<HashSet<_>>()
})
})
.transpose()?;
Ok(PreparedPredicate {
value: value.clone(),
name_regex,
argv_regex,
ledger_keys,
port_pids,
})
})
.collect()
}
fn sort_processes(processes: &mut [ProcessInfo], sort: &str) -> Result<(), String> {
match sort {
"pid" => processes.sort_by_key(|process| process.identity.pid),
"name" => processes.sort_by(|left, right| {
left.identity
.name
.to_lowercase()
.cmp(&right.identity.name.to_lowercase())
}),
"memory" => processes.sort_by_key(|process| std::cmp::Reverse(process.memory_bytes)),
"runtime" => processes.sort_by_key(|process| std::cmp::Reverse(process.runtime_seconds)),
"cpu" => processes.sort_by(|left, right| {
right
.cpu_percent
.total_cmp(&left.cpu_percent)
.then_with(|| left.identity.pid.cmp(&right.identity.pid))
}),
value => return Err(format!("Unknown sort \"{value}\"")),
}
Ok(())
}
#[cfg(target_os = "macos")]
fn process_files(identity: &ProcessIdentity) -> Result<Vec<ProcessFile>, String> {
if !identity_for_pid(identity.pid).is_ok_and(|current| same_process(¤t, identity)) {
return Ok(Vec::new());
}
let mut descriptors =
std::iter::repeat_with(|| unsafe { std::mem::zeroed::<libc::proc_fdinfo>() })
.take(4096)
.collect::<Vec<_>>();
let bytes = descriptors.len() * std::mem::size_of::<libc::proc_fdinfo>();
let read = unsafe {
libc::proc_pidinfo(
identity.pid as i32,
libc::PROC_PIDLISTFDS,
0,
descriptors.as_mut_ptr().cast(),
bytes as i32,
)
};
if read < 0 {
return Err(format!(
"Cannot inspect file descriptors for process {}",
identity.pid
));
}
descriptors.truncate(read as usize / std::mem::size_of::<libc::proc_fdinfo>());
let mut files = Vec::new();
for descriptor in descriptors {
if descriptor.proc_fdtype != libc::PROX_FDTYPE_VNODE as u32 {
continue;
}
let mut info = unsafe { std::mem::zeroed::<VnodeFdInfoWithPath>() };
let size = std::mem::size_of::<VnodeFdInfoWithPath>();
let read = unsafe {
libc::proc_pidfdinfo(
identity.pid as i32,
descriptor.proc_fd,
2,
std::ptr::addr_of_mut!(info).cast(),
size as i32,
)
};
if read != size as i32 {
continue;
}
let path = unsafe { std::ffi::CStr::from_ptr(info.pvip.vip_path.as_ptr()) }
.to_string_lossy()
.into_owned();
if path.is_empty() {
continue;
}
files.push(ProcessFile {
process: identity.clone(),
fd: descriptor.proc_fd,
kind: "vnode".to_string(),
path,
open_flags: info.pfi.fi_openflags,
offset: info.pfi.fi_offset,
});
}
files.sort_by_key(|file| file.fd);
Ok(files)
}
#[cfg(not(target_os = "macos"))]
fn process_files(_identity: &ProcessIdentity) -> Result<Vec<ProcessFile>, String> {
Err("Native open-file inspection is available on macOS in v1".to_string())
}
#[cfg(target_os = "macos")]
#[repr(C)]
struct ProcFileInfo {
fi_openflags: u32,
fi_status: u32,
fi_offset: libc::off_t,
fi_type: i32,
fi_guardflags: u32,
}
#[cfg(target_os = "macos")]
#[repr(C)]
struct VinfoStat {
vst_dev: u32,
vst_mode: u16,
vst_nlink: u16,
vst_ino: u64,
vst_uid: libc::uid_t,
vst_gid: libc::gid_t,
vst_atime: i64,
vst_atimensec: i64,
vst_mtime: i64,
vst_mtimensec: i64,
vst_ctime: i64,
vst_ctimensec: i64,
vst_birthtime: i64,
vst_birthtimensec: i64,
vst_size: libc::off_t,
vst_blocks: i64,
vst_blksize: i32,
vst_flags: u32,
vst_gen: u32,
vst_rdev: u32,
vst_qspare: [i64; 2],
}
#[cfg(target_os = "macos")]
#[repr(C)]
struct VnodeInfo {
vi_stat: VinfoStat,
vi_type: i32,
vi_pad: i32,
vi_fsid: libc::fsid_t,
}
#[cfg(target_os = "macos")]
#[repr(C)]
struct VnodeInfoPath {
vip_vi: VnodeInfo,
vip_path: [libc::c_char; libc::MAXPATHLEN as usize],
}
#[cfg(target_os = "macos")]
#[repr(C)]
struct VnodeFdInfoWithPath {
pfi: ProcFileInfo,
pvip: VnodeInfoPath,
}
async fn lock_processes(identities: &[ProcessIdentity]) -> Vec<tokio::sync::OwnedMutexGuard<()>> {
let mut keys = identities
.iter()
.map(process_context_key)
.collect::<Vec<_>>();
keys.sort();
keys.dedup();
let locks = {
let mut registry = MUTATION_LOCKS
.get_or_init(|| StdMutex::new(HashMap::new()))
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
registry.retain(|_, lock| lock.strong_count() > 0);
keys.into_iter()
.map(|key| {
if let Some(lock) = registry.get(&key).and_then(Weak::upgrade) {
return lock;
}
let lock = Arc::new(tokio::sync::Mutex::new(()));
registry.insert(key, Arc::downgrade(&lock));
lock
})
.collect::<Vec<_>>()
};
let mut guards = Vec::with_capacity(locks.len());
for lock in locks {
guards.push(lock.lock_owned().await);
}
guards
}
fn same_process(left: &ProcessIdentity, right: &ProcessIdentity) -> bool {
left.boot_id == right.boot_id
&& left.pid == right.pid
&& left.started_at_ns == right.started_at_ns
}
fn append_tree(
pid: u32,
system: &System,
children: &HashMap<u32, Vec<u32>>,
seen: &mut BTreeSet<u32>,
ordered: &mut Vec<ProcessInfo>,
) {
if !seen.insert(pid) {
return;
}
if let Some(process) = system.process(Pid::from_u32(pid)) {
ordered.push(process_info(process));
}
if let Some(descendants) = children.get(&pid) {
for child in descendants {
append_tree(*child, system, children, seen, ordered);
}
}
}
fn command_line(process: &sysinfo::Process) -> String {
process
.cmd()
.iter()
.map(|part| part.to_string_lossy())
.collect::<Vec<_>>()
.join(" ")
}
fn parse_port_selector(value: &str) -> Result<(u16, Option<String>), String> {
let mut parts = value.splitn(2, '/');
let port = parts
.next()
.unwrap_or_default()
.parse::<u16>()
.map_err(|_| format!("Invalid port selector \"port:{value}\""))?;
Ok((port, parts.next().map(str::to_ascii_lowercase)))
}
fn selector_pid(selector: &str) -> Option<u32> {
selector
.strip_prefix("pid:")
.unwrap_or(selector)
.parse::<u32>()
.ok()
}
fn signal_name(signal: Signal) -> &'static str {
match signal {
Signal::Hangup => "hangup",
Signal::Interrupt => "interrupt",
Signal::Quit => "quit",
Signal::Kill => "kill",
Signal::User1 => "user1",
Signal::User2 => "user2",
Signal::Term => "terminate",
Signal::Continue => "continue",
Signal::Stop => "pause",
_ => "signal",
}
}
fn process_group(pid: u32) -> Option<u32> {
let pgid = unsafe { libc::getpgid(pid as libc::pid_t) };
(pgid >= 0).then_some(pgid as u32)
}
#[cfg(test)]
mod tests {
use std::net::TcpListener;
use std::process::Child;
use super::*;
struct ChildGuard(Child);
impl Drop for ChildGuard {
fn drop(&mut self) {
let _ = self.0.kill();
let _ = self.0.wait();
}
}
#[test]
fn parses_supported_signals() {
assert_eq!(parse_signal("TERM").unwrap(), Signal::Term);
assert_eq!(parse_signal("SIGKILL").unwrap(), Signal::Kill);
assert!(parse_signal("THUNDERBOLT").is_err());
}
#[test]
fn parses_port_selectors() {
assert_eq!(
parse_port_selector("5173/tcp").unwrap(),
(5173, Some("tcp".to_string()))
);
assert_eq!(parse_port_selector("53").unwrap(), (53, None));
}
#[test]
fn resolves_current_process() {
let mut manager = ProcessManager::new();
let selection = manager
.select(&format!("pid:{}", std::process::id()))
.unwrap();
assert_eq!(selection.processes.len(), 1);
assert_eq!(selection.processes[0].pid, std::process::id());
}
#[test]
fn captured_tree_rejects_a_recycled_pid_identity() {
let current = identity_for_pid(std::process::id()).unwrap();
let mut recycled = current.clone();
recycled.started_at_ns = recycled.started_at_ns.saturating_add(1);
let mut manager = ProcessManager::new();
assert!(manager.trees_for_identities(&[recycled]).is_empty());
let trees = manager.trees_for_identities(std::slice::from_ref(¤t));
assert_eq!(trees.len(), 1);
assert_eq!(trees[0].0, current);
}
#[test]
fn finds_native_listening_socket_ownership() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let owners = port_owners(port, Some("tcp")).unwrap();
assert!(
owners
.iter()
.any(|socket| { socket.port == port && socket.pids.contains(&std::process::id()) })
);
}
#[cfg(target_os = "macos")]
#[test]
fn lists_native_open_files_for_an_exact_process() {
let file = tempfile::NamedTempFile::new().unwrap();
let expected = std::fs::canonicalize(file.path()).unwrap();
let identity = identity_for_pid(std::process::id()).unwrap();
let files = process_files(&identity).unwrap();
assert!(
files
.iter()
.any(|open| { std::fs::canonicalize(&open.path).ok().as_ref() == Some(&expected) }),
"{files:#?}"
);
}
#[test]
fn executes_structured_boolean_process_queries() {
let directory = tempfile::tempdir().unwrap();
let store = Arc::new(Store::open(directory.path().join("state.sqlite3")).unwrap());
let mut manager = ProcessManager::with_store(store);
let processes = manager
.query(
&ProcessQuery {
all: vec![ProcessPredicate {
pid: Some(std::process::id()),
..ProcessPredicate::default()
}],
any: Vec::new(),
not: vec![ProcessPredicate {
name: Some("definitely-not-apoc".to_string()),
..ProcessPredicate::default()
}],
sort: "pid".to_string(),
limit: 10,
},
true,
)
.unwrap();
assert_eq!(processes.len(), 1);
assert_eq!(processes[0].identity.pid, std::process::id());
}
#[tokio::test]
async fn waits_for_an_exact_process_identity_to_exit() {
let directory = tempfile::tempdir().unwrap();
let store = Arc::new(Store::open(directory.path().join("state.sqlite3")).unwrap());
let mut child = std::process::Command::new("/bin/sleep")
.arg("0.1")
.spawn()
.unwrap();
let pid = child.id();
let reaper = tokio::task::spawn_blocking(move || child.wait().unwrap());
let wait = wait_for_with_manager(
ProcessManager::with_store(store),
&format!("pid:{pid}"),
"exit",
Duration::from_millis(10),
Duration::from_secs(2),
true,
)
.await
.unwrap();
reaper.await.unwrap();
assert!(wait.satisfied);
assert!(wait.processes.is_empty());
}
#[tokio::test]
async fn safely_pauses_resumes_and_kills_one_exact_fixture() {
let directory = tempfile::tempdir().unwrap();
let store = Arc::new(Store::open(directory.path().join("state.sqlite3")).unwrap());
let mut child = ChildGuard(
std::process::Command::new("/bin/sleep")
.arg("30")
.spawn()
.unwrap(),
);
let selector = format!("pid:{}", child.0.id());
let mut manager = ProcessManager::with_store(store.clone());
let identity = manager.select(&selector).unwrap().processes.remove(0);
let paused = manager
.signal(&selector, Signal::Stop, true, None, false)
.await
.unwrap();
assert!(paused.results.iter().all(|result| result.applied));
let resumed = manager
.signal(&selector, Signal::Continue, true, None, false)
.await
.unwrap();
assert!(resumed.results.iter().all(|result| result.applied));
let killed = manager
.signal(&selector, Signal::Kill, true, None, false)
.await
.unwrap();
assert!(killed.results.iter().all(|result| result.applied));
let _ = child.0.wait();
let dossier = store
.process_dossier(&process_context_key(&identity), 20)
.unwrap();
assert_eq!(dossier.context.latest.identity, identity);
assert_eq!(dossier.context.observations, 6);
assert_eq!(dossier.events.len(), 6);
assert!(dossier.events.iter().all(|event| event.controller.agent));
assert!(dossier.events.iter().any(|event| event.phase == "intent"));
assert!(dossier.events.iter().any(|event| event.phase == "result"));
}
#[test]
fn proc_stat_start_time_resolves_below_one_second() {
let stat = format!(
"42 (my program) S 1 42 42 0 -1 0 0 0 0 0 {} 1234 rest ignored",
(0..8).map(|_| "0 ").collect::<String>()
);
assert_eq!(
proc_stat_start_ns(&stat, 100),
Some(12_340_000_000),
"1234 ticks at 100 Hz is 12.34 seconds since boot"
);
let tricky = stat.replace("(my program)", "(we(i)rd name)");
assert_eq!(proc_stat_start_ns(&tricky, 100), Some(12_340_000_000));
let later = stat.replace(" 1234 rest", " 1235 rest");
assert_ne!(
proc_stat_start_ns(&stat, 100),
proc_stat_start_ns(&later, 100),
"a one tick difference must survive the conversion"
);
}
#[test]
fn proc_stat_start_time_rejects_unusable_input() {
assert_eq!(proc_stat_start_ns("", 100), None);
assert_eq!(proc_stat_start_ns("42 (sleep) S 1 2 3", 100), None);
assert_eq!(
proc_stat_start_ns(
"42 (sleep) S 1 42 42 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7 x",
0
),
None,
"an unusable clock rate must not divide by zero"
);
let ticks = 10_u64 * 365 * 86_400 * 1000;
let huge = format!(
"42 (sleep) S 1 42 42 0 -1 0 0 0 0 0 {} {ticks} rest",
(0..8).map(|_| "0 ").collect::<String>()
);
assert!(
ticks.checked_mul(1_000_000_000).is_none(),
"the fixture must be large enough to overflow a naive conversion"
);
assert_eq!(
proc_stat_start_ns(&huge, 1000),
Some(ticks / 1000 * 1_000_000_000),
"a large tick count must convert exactly, not saturate"
);
}
#[tokio::test]
async fn a_recycled_pid_identity_never_authorizes_a_signal() {
let directory = tempfile::tempdir().unwrap();
let store = Arc::new(Store::open(directory.path().join("state.sqlite3")).unwrap());
let child = ChildGuard(
std::process::Command::new("/bin/sleep")
.arg("30")
.spawn()
.unwrap(),
);
let selector = format!("pid:{}", child.0.id());
let mut manager = ProcessManager::with_store(store);
let identity = manager.select(&selector).unwrap().processes.remove(0);
let mut recycled = identity.clone();
recycled.started_at_ns = recycled.started_at_ns.saturating_add(1);
assert_eq!(
recycled.started_at, identity.started_at,
"the fixture must keep second resolution identical to isolate the nanosecond guard"
);
let results = manager.apply_signal(vec![recycled], Signal::Kill, "kill");
assert_eq!(results.len(), 1);
assert!(
!results[0].applied,
"a recycled-PID identity must not deliver a signal"
);
assert!(
results[0].error.is_none(),
"refusing a recycled identity is a no-op, not an error"
);
manager.refresh_selector_force(&selector);
let survivor = manager.select(&selector).unwrap().processes;
assert_eq!(
survivor.first().map(|process| process.started_at_ns),
Some(identity.started_at_ns),
"the live process must survive a signal aimed at a recycled identity"
);
}
#[tokio::test]
async fn replays_idempotent_mutations_without_reapplying_them() {
let directory = tempfile::tempdir().unwrap();
let store = Arc::new(Store::open(directory.path().join("state.sqlite3")).unwrap());
let mut child = ChildGuard(
std::process::Command::new("/bin/sleep")
.arg("30")
.spawn()
.unwrap(),
);
let selector = format!("pid:{}", child.0.id());
let mut manager = ProcessManager::with_store(store.clone());
let mut concurrent = ProcessManager::with_store(store.clone());
let (first, replay) = tokio::join!(
manager.signal(&selector, Signal::Stop, true, Some("fixture/pause"), false),
concurrent.signal(&selector, Signal::Kill, true, Some("fixture/pause"), false)
);
let first = first.unwrap();
let replay = replay.unwrap();
assert_eq!(first.id, replay.id);
assert_eq!(replay.action, "pause");
assert!(identity_for_pid(child.0.id()).is_ok());
let events = store
.query_process_events(&ProcessEventQuery {
limit: 10,
operation: Some("process.signal".to_string()),
..ProcessEventQuery::default()
})
.unwrap();
assert_eq!(events.len(), 2);
manager
.signal(&selector, Signal::Continue, true, None, false)
.await
.unwrap();
manager
.signal(&selector, Signal::Kill, true, None, false)
.await
.unwrap();
let _ = child.0.wait();
}
#[tokio::test]
async fn rejects_empty_mutation_targets_unless_explicitly_allowed() {
let directory = tempfile::tempdir().unwrap();
let store = Arc::new(Store::open(directory.path().join("state.sqlite3")).unwrap());
let mut manager = ProcessManager::with_store(store);
let selector = "pid:4294967295";
let error = manager
.signal(selector, Signal::Term, true, None, false)
.await
.unwrap_err();
assert!(error.contains("resolved to no current processes"));
let receipt = manager
.signal(selector, Signal::Term, true, None, true)
.await
.unwrap();
assert!(receipt.results.is_empty());
}
#[tokio::test]
async fn orders_overlapping_mutations_without_blocking_disjoint_identities() {
let current = identity_for_pid(std::process::id()).unwrap();
let mut other = current.clone();
other.pid = other.pid.saturating_add(1);
other.started_at_ns = other.started_at_ns.saturating_add(1);
let held = lock_processes(std::slice::from_ref(¤t)).await;
let same = tokio::spawn({
let current = current.clone();
async move { lock_processes(&[current]).await }
});
let disjoint = tokio::spawn(async move { lock_processes(&[other]).await });
assert!(
tokio::time::timeout(Duration::from_millis(100), disjoint)
.await
.unwrap()
.is_ok()
);
assert!(
tokio::time::timeout(Duration::from_millis(20), async {
while !same.is_finished() {
tokio::task::yield_now().await;
}
})
.await
.is_err()
);
drop(held);
assert!(
tokio::time::timeout(Duration::from_millis(100), same)
.await
.unwrap()
.is_ok()
);
}
#[test]
fn covers_selector_sort_probe_and_process_helper_boundaries() {
let directory = tempfile::tempdir().unwrap();
let store = Arc::new(Store::open(directory.path().join("state.sqlite3")).unwrap());
let mut manager = ProcessManager::with_store(store.clone());
let pid = std::process::id();
let selector = format!("pid:{pid}");
let current = manager.get(&selector).unwrap();
for sort in ["pid", "name", "memory", "runtime", "cpu"] {
let listed = manager.list(Some(&selector), sort, 1).unwrap();
assert_eq!(
listed.first().map(|process| process.identity.pid),
Some(pid)
);
}
assert!(manager.list(Some(&selector), "unknown", 1).is_err());
assert_eq!(manager.list(Some(&selector), "pid", 0).unwrap().len(), 0);
for target in [
selector.clone(),
pid.to_string(),
format!("name:{}", current.identity.name),
format!("match:{}", regex::escape(¤t.identity.name)),
"all".to_string(),
] {
assert!(
manager
.select(&target)
.unwrap()
.processes
.iter()
.any(|identity| identity.pid == pid),
"{target}"
);
}
if let Some(pgid) = current.identity.pgid {
assert!(
manager
.select(&format!("pgid:{pgid}"))
.unwrap()
.processes
.iter()
.any(|identity| identity.pid == pid)
);
}
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
assert!(
manager
.select(&format!("port:{port}/TCP"))
.unwrap()
.processes
.iter()
.any(|identity| identity.pid == pid)
);
assert!(manager.select("pid:nope").is_err());
assert!(manager.select("pgid:nope").is_err());
assert!(manager.select("match:(").is_err());
assert!(manager.select("unknown-selector").is_err());
assert!(manager.get("all").is_err());
assert!(manager.snapshots_for_pids(&[]).is_empty());
assert_eq!(
manager
.snapshots_for_pids(&[pid, u32::MAX])
.first()
.map(|process| process.identity.pid),
Some(pid)
);
manager
.record(
std::slice::from_ref(¤t),
"process.test",
"observed",
Some(&selector),
true,
"observed",
None,
&serde_json::json!({}),
)
.unwrap();
let key = process_context_key(¤t.identity);
assert!(manager.probe(&selector, true).unwrap().exists);
assert!(manager.probe(&key, true).unwrap().exists);
let mut recycled = current.identity.clone();
recycled.started_at_ns = recycled.started_at_ns.saturating_add(1);
let recycled_key = process_context_key(&recycled);
store
.record_processes(
std::slice::from_ref(&ProcessInfo {
identity: recycled,
..current.clone()
}),
"process.test",
"observed",
None,
&controller(true),
"observed",
None,
&serde_json::json!({}),
)
.unwrap();
assert!(!manager.probe(&recycled_key, true).unwrap().exists);
assert_eq!(
parse_port_selector("443/TCP").unwrap(),
(443, Some("tcp".into()))
);
assert!(parse_port_selector("nope").is_err());
assert_eq!(selector_pid(&selector), Some(pid));
assert_eq!(selector_pid(&pid.to_string()), Some(pid));
assert_eq!(selector_pid("name:apoc"), None);
assert_eq!(process_group(pid), current.identity.pgid);
assert_eq!(process_group(u32::MAX), None);
assert!(same_process(¤t.identity, ¤t.identity));
assert!(!same_process(
¤t.identity,
&ProcessIdentity {
started_at_ns: current.identity.started_at_ns.saturating_add(1),
..current.identity.clone()
}
));
for (signal, expected) in [
(Signal::Hangup, "hangup"),
(Signal::Interrupt, "interrupt"),
(Signal::Quit, "quit"),
(Signal::Kill, "kill"),
(Signal::User1, "user1"),
(Signal::User2, "user2"),
(Signal::Term, "terminate"),
(Signal::Continue, "continue"),
(Signal::Stop, "pause"),
(Signal::Alarm, "signal"),
] {
assert_eq!(signal_name(signal), expected);
}
}
#[test]
fn covers_prepared_predicates_and_standalone_sorting() {
let directory = tempfile::tempdir().unwrap();
let store = Arc::new(Store::open(directory.path().join("state.sqlite3")).unwrap());
let mut process = process_info_for_pid(std::process::id()).unwrap();
process.identity.ppid = Some(41);
process.identity.pgid = Some(42);
process.identity.name = "Apoc Fixture".to_string();
process.command = vec!["apoc".to_string(), "fixture-value".to_string()];
process.cwd = Some("/fixture/workspace/repo".to_string());
process.status = "Running".to_string();
process.user_id = Some("501".to_string());
let key = process_context_key(&process.identity);
let predicate = PreparedPredicate {
value: ProcessPredicate {
pid: Some(process.identity.pid),
ppid: process.identity.ppid,
pgid: process.identity.pgid,
name: Some(process.identity.name.clone()),
name_regex: Some("^Apoc".to_string()),
argv_regex: Some("fixture-value$".to_string()),
cwd_prefix: Some("/fixture/workspace".to_string()),
status: Some("running".to_string()),
user_id: process.user_id.clone(),
port: None,
protocol: None,
actor: None,
execution_id: None,
},
name_regex: Some(Regex::new("^Apoc").unwrap()),
argv_regex: Some(Regex::new("fixture-value$").unwrap()),
ledger_keys: Some(HashSet::from([key])),
port_pids: Some(HashSet::from([process.identity.pid])),
};
assert!(predicate.matches(&process));
let mismatches = [
ProcessPredicate {
pid: Some(0),
..predicate.value.clone()
},
ProcessPredicate {
ppid: Some(0),
..predicate.value.clone()
},
ProcessPredicate {
pgid: Some(0),
..predicate.value.clone()
},
ProcessPredicate {
name: Some("other".into()),
..predicate.value.clone()
},
ProcessPredicate {
cwd_prefix: Some("/other".into()),
..predicate.value.clone()
},
ProcessPredicate {
status: Some("sleeping".into()),
..predicate.value.clone()
},
ProcessPredicate {
user_id: Some("0".into()),
..predicate.value.clone()
},
];
for value in mismatches {
assert!(
!PreparedPredicate {
value,
name_regex: predicate.name_regex.clone(),
argv_regex: predicate.argv_regex.clone(),
ledger_keys: predicate.ledger_keys.clone(),
port_pids: predicate.port_pids.clone(),
}
.matches(&process)
);
}
assert!(
!PreparedPredicate {
value: predicate.value.clone(),
name_regex: Some(Regex::new("^Other").unwrap()),
argv_regex: predicate.argv_regex.clone(),
ledger_keys: predicate.ledger_keys.clone(),
port_pids: predicate.port_pids.clone(),
}
.matches(&process)
);
assert!(
!PreparedPredicate {
value: predicate.value.clone(),
name_regex: predicate.name_regex.clone(),
argv_regex: Some(Regex::new("missing").unwrap()),
ledger_keys: predicate.ledger_keys.clone(),
port_pids: predicate.port_pids.clone(),
}
.matches(&process)
);
assert!(
!PreparedPredicate {
value: predicate.value.clone(),
name_regex: predicate.name_regex.clone(),
argv_regex: predicate.argv_regex.clone(),
ledger_keys: Some(HashSet::new()),
port_pids: predicate.port_pids.clone(),
}
.matches(&process)
);
assert!(
!PreparedPredicate {
value: predicate.value.clone(),
name_regex: predicate.name_regex.clone(),
argv_regex: predicate.argv_regex.clone(),
ledger_keys: predicate.ledger_keys.clone(),
port_pids: Some(HashSet::new()),
}
.matches(&process)
);
for field in ["name", "argv"] {
let invalid = if field == "name" {
ProcessPredicate {
name_regex: Some("(".into()),
..ProcessPredicate::default()
}
} else {
ProcessPredicate {
argv_regex: Some("(".into()),
..ProcessPredicate::default()
}
};
assert!(prepare_predicates(&[invalid], &store).is_err());
}
let mut fixture_controller = controller(true);
fixture_controller.actor = "fixture-actor".to_string();
fixture_controller.execution_id = Some("fixture-execution".to_string());
store
.record_processes(
std::slice::from_ref(&process),
"process.test",
"observed",
None,
&fixture_controller,
"managed",
Some("managed-execution"),
&serde_json::json!({}),
)
.unwrap();
let ledger = prepare_predicates(
&[ProcessPredicate {
actor: Some("fixture-actor".into()),
execution_id: Some("managed-execution".into()),
..ProcessPredicate::default()
}],
&store,
)
.unwrap();
assert!(ledger[0].matches(&process));
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let live = process_info_for_pid(std::process::id()).unwrap();
let port_predicate = prepare_predicates(
&[ProcessPredicate {
port: Some(port),
..ProcessPredicate::default()
}],
&store,
)
.unwrap();
assert!(port_predicate[0].matches(&live));
let mut left = process.clone();
left.identity.pid = 2;
left.identity.name = "Zulu".into();
left.memory_bytes = 10;
left.runtime_seconds = 20;
left.cpu_percent = 3.0;
let mut right = process;
right.identity.pid = 1;
right.identity.name = "alpha".into();
right.memory_bytes = 20;
right.runtime_seconds = 10;
right.cpu_percent = 3.0;
for (sort, expected_pid) in [
("pid", 1),
("name", 1),
("memory", 1),
("runtime", 2),
("cpu", 1),
] {
let mut values = vec![left.clone(), right.clone()];
sort_processes(&mut values, sort).unwrap();
assert_eq!(values[0].identity.pid, expected_pid, "{sort}");
}
assert!(sort_processes(&mut [left, right], "unknown").is_err());
}
}