#![cfg(all(feature = "std", target_os = "linux"))]
use std::fs;
use std::path::PathBuf;
use std::sync::atomic::{AtomicU64, Ordering};
use zsys::linux::{Availability, Detail, DetailOptions, Processes, ScanMode};
static NEXT: AtomicU64 = AtomicU64::new(0);
struct Fixture(PathBuf);
impl Fixture {
fn new() -> Self {
let p =
std::env::temp_dir().join(format!("zsys-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
fs::create_dir_all(&p).unwrap();
Self(p)
}
fn process(&self, pid: u32, start: u64, user: u64) {
fs::create_dir_all(self.0.join(pid.to_string())).unwrap();
fs::write(
self.0.join(format!("{pid}/stat")),
format!("{pid} (test (worker)) S 1 0 0 0 0 0 0 0 0 0 {user} 0 0 0 20 0 2 0 {start} 8192 3\n"),
)
.unwrap();
fs::write(self.0.join(format!("{pid}/statm")), b"2 3 0 0 0 0 0\n").unwrap();
}
}
impl Drop for Fixture {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.0);
}
}
#[test]
fn lifecycle_reuse_and_inaccessible_records_are_not_conflated() {
let f = Fixture::new();
f.process(42, 100, 10);
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
assert_eq!(p.refresh().unwrap().added, 1);
let record = p.get(42).unwrap();
assert_eq!(record.memory_bytes, 12288);
assert_eq!(record.threads, 2);
assert_eq!(record.cpu_percent, None);
assert_eq!(record.name, b"test (worker)");
f.process(42, 100, 11);
assert_eq!(p.refresh().unwrap().reused, 0);
assert!(p.get(42).unwrap().cpu_percent.is_some());
f.process(42, 200, 0);
assert_eq!(p.refresh().unwrap().reused, 1);
assert_eq!(p.get(42).unwrap().cpu_percent, None);
fs::remove_file(f.0.join("42/stat")).unwrap();
assert_eq!(p.refresh().unwrap().failed, 1);
assert_eq!(p.get(42).unwrap().availability, Availability::Vanished);
assert_eq!(p.get(42).unwrap().memory_bytes, 12288);
fs::remove_dir_all(f.0.join("42")).unwrap();
assert_eq!(p.refresh().unwrap().removed, 1);
assert!(p.is_empty());
}
#[test]
fn native_and_std_enumerators_agree() {
let f = Fixture::new();
f.process(7, 10, 1);
f.process(900, 20, 2);
fs::create_dir(f.0.join("not-a-pid")).unwrap();
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
p.set_scan_mode(ScanMode::Std);
assert_eq!(p.refresh().unwrap().added, 2);
if cfg!(any(target_arch = "x86_64", target_arch = "aarch64")) {
p.set_scan_mode(ScanMode::Native);
assert_eq!(p.refresh().unwrap().updated, 2);
assert_eq!(p.len(), 2);
}
}
#[test]
fn targeted_refresh_does_not_remove_other_processes() {
let f = Fixture::new();
f.process(1, 10, 1);
f.process(2, 20, 1);
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
p.refresh().unwrap();
fs::remove_dir_all(f.0.join("2")).unwrap();
p.refresh_pid(1).unwrap();
assert!(p.get(2).is_some());
assert!(p.refresh_pid(2).is_err());
assert!(p.get(2).is_none());
}
#[test]
fn real_process_details_preserve_identity() {
let mut p = Processes::new().unwrap();
let pid = std::process::id();
let id = p.refresh_pid(pid).unwrap().id;
let details = p.details(pid, DetailOptions::all()).unwrap();
assert_eq!(details.id, id);
assert!(matches!(details.executable, Detail::Value(_)));
assert!(matches!(details.command_line, Detail::Value(_)));
assert!(matches!(details.user_ids, Detail::Value(_)));
}
#[test]
fn collectors_are_send_and_sync() {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<Processes>();
let threads: Vec<_> = (0..4)
.map(|_| {
std::thread::spawn(|| {
let mut p = Processes::new().unwrap();
for _ in 0..20 {
p.refresh_pid(std::process::id()).unwrap();
}
})
})
.collect();
for thread in threads {
thread.join().unwrap();
}
}
#[test]
fn repeated_refresh_and_child_exit() {
let mut p = Processes::new().unwrap();
let mut child = std::process::Command::new("sleep").arg("60").spawn().unwrap();
let pid = child.id();
let result = p.refresh_pid(pid).map(|p| p.id.pid);
let _ = child.kill();
let _ = child.wait();
assert_eq!(result.unwrap(), pid);
for _ in 0..100 {
p.refresh_pid(std::process::id()).unwrap();
}
assert!(p.refresh_pid(pid).is_err());
assert!(p.get(pid).is_none());
}
#[test]
fn enumeration_preserves_samples_and_deduplicates_numeric_names() {
let f = Fixture::new();
f.process(7, 10, 1);
f.process(900, 20, 2);
fs::create_dir(f.0.join("0007")).unwrap();
fs::create_dir(f.0.join("4294967296")).unwrap();
fs::create_dir(f.0.join("0")).unwrap();
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
assert_eq!(p.enumerate_pids().unwrap(), [7, 900]);
assert!(p.is_empty());
p.refresh_pid(7).unwrap();
let timestamp = p.get(7).unwrap().sampled_at_ns;
p.enumerate_pids().unwrap();
assert_eq!(p.get(7).unwrap().sampled_at_ns, timestamp);
assert!(p.get(900).is_none());
}
#[test]
fn failed_enumeration_keeps_existing_table() {
let f = Fixture::new();
f.process(7, 10, 1);
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
p.set_scan_mode(ScanMode::Std);
p.refresh().unwrap();
let moved = f.0.with_extension("moved");
fs::rename(&f.0, &moved).unwrap();
let result = p.refresh();
fs::rename(&moved, &f.0).unwrap();
assert!(result.is_err());
assert_eq!(p.len(), 1);
assert_eq!(p.get(7).unwrap().id.start_time_ticks, 10);
}
#[test]
fn invalid_sample_preserves_data_and_resets_cpu_baseline() {
let f = Fixture::new();
f.process(42, 100, 10);
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
p.refresh().unwrap();
fs::write(f.0.join("42/stat"), b"42 (truncated)").unwrap();
assert_eq!(p.refresh().unwrap().failed, 1);
let old = p.get(42).unwrap();
assert_eq!(old.availability, Availability::Invalid);
assert_eq!(old.counters.user_ticks, 10);
assert_eq!(old.cpu_percent, None);
f.process(42, 100, 20);
p.refresh().unwrap();
assert_eq!(p.get(42).unwrap().availability, Availability::Fresh);
assert_eq!(p.get(42).unwrap().cpu_percent, None);
p.refresh().unwrap();
assert_eq!(p.get(42).unwrap().cpu_percent, Some(0.0));
}
#[test]
fn details_preserve_bytes_and_report_each_requested_field() {
use std::os::unix::fs::symlink;
let f = Fixture::new();
f.process(42, 100, 10);
fs::write(f.0.join("42/cmdline"), b"hello\0\0\xffarg\0").unwrap();
fs::write(f.0.join("42/status"), b"Uid:\t1\t2\t3\t4\nGid:\t5\t6\t7\t8\n").unwrap();
symlink("/fixture/executable", f.0.join("42/exe")).unwrap();
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
let no_details = p.details(42, DetailOptions::default()).unwrap();
assert!(matches!(no_details.command_line, Detail::NotRequested));
assert!(matches!(no_details.executable, Detail::NotRequested));
assert!(matches!(no_details.user_ids, Detail::NotRequested));
let details = p.details(42, DetailOptions::all()).unwrap();
assert!(matches!(details.command_line, Detail::Value(v) if v == b"hello\0\0\xffarg\0"));
assert!(matches!(details.executable, Detail::Value(v) if v == std::path::Path::new("/fixture/executable")));
assert!(matches!(details.user_ids, Detail::Value([1, 2, 3, 4])));
assert!(matches!(details.group_ids, Detail::Value([5, 6, 7, 8])));
fs::remove_file(f.0.join("42/exe")).unwrap();
assert!(matches!(
p.details(42, DetailOptions::all()).unwrap().executable,
Detail::Unavailable(std::io::ErrorKind::NotFound)
));
}
#[test]
fn details_reject_a_mismatched_stat_identity() {
let f = Fixture::new();
f.process(42, 100, 10);
let bytes = fs::read_to_string(f.0.join("42/stat")).unwrap().replacen("42", "43", 1);
fs::write(f.0.join("42/stat"), bytes).unwrap();
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
assert!(p.details(42, DetailOptions::default()).is_err());
assert!(p.refresh_pid(42).is_err());
}
#[test]
fn permission_loss_retains_explicitly_stale_data() {
use std::os::unix::fs::PermissionsExt;
let f = Fixture::new();
f.process(42, 100, 10);
let path = f.0.join("42/stat");
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
p.refresh().unwrap();
fs::set_permissions(&path, fs::Permissions::from_mode(0o0)).unwrap();
if fs::File::open(&path).is_err_and(|e| e.kind() == std::io::ErrorKind::PermissionDenied) {
assert_eq!(p.refresh().unwrap().failed, 1);
let stale = p.get(42).unwrap();
assert_eq!(stale.availability, Availability::Inaccessible);
assert_eq!(stale.counters.user_ticks, 10);
assert_eq!(stale.cpu_percent, None);
}
fs::set_permissions(&path, fs::Permissions::from_mode(0o600)).unwrap();
p.refresh().unwrap();
assert_eq!(p.get(42).unwrap().availability, Availability::Fresh);
}
#[test]
fn rapid_creation_and_exit_do_not_leave_records() {
let mut p = Processes::new().unwrap();
for _ in 0..32 {
let mut child = std::process::Command::new("true").spawn().unwrap();
let pid = child.id();
let _ = p.refresh_pid(pid);
child.wait().unwrap();
assert!(p.refresh_pid(pid).is_err());
assert!(p.get(pid).is_none());
}
}
#[test]
fn resident_memory_uses_statm_and_preserves_raw_stat_counter() {
let f = Fixture::new();
f.process(42, 100, 10);
fs::write(f.0.join("42/statm"), b"20 7 0 0 0 0 0\n").unwrap();
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
let process = p.refresh_pid(42).unwrap();
assert_eq!(process.memory_bytes, 7 * 4096);
assert_eq!(process.counters.resident_pages, 3);
}
#[test]
fn failed_statm_read_preserves_last_good_record() {
let f = Fixture::new();
f.process(42, 100, 10);
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
p.refresh().unwrap();
for input in [b"2 bad\n".as_slice(), b"2\n", b"2 18446744073709551615\n"] {
fs::write(f.0.join("42/statm"), input).unwrap();
assert_eq!(p.refresh().unwrap().failed, 1);
assert_eq!(p.get(42).unwrap().availability, Availability::Invalid);
assert_eq!(p.get(42).unwrap().memory_bytes, 3 * 4096);
}
fs::remove_file(f.0.join("42/statm")).unwrap();
assert_eq!(p.refresh().unwrap().failed, 1);
assert_eq!(p.get(42).unwrap().availability, Availability::Vanished);
f.process(42, 100, 20);
assert_eq!(p.refresh().unwrap().failed, 0);
assert_eq!(p.get(42).unwrap().cpu_percent, None);
}
#[test]
fn statm_permission_loss_is_reported_without_fake_zero_memory() {
use std::os::unix::fs::PermissionsExt;
let f = Fixture::new();
f.process(42, 100, 10);
let path = f.0.join("42/statm");
let mut p = Processes::with_parameters(&f.0, 100, 4096).unwrap();
p.refresh().unwrap();
fs::set_permissions(&path, fs::Permissions::from_mode(0o0)).unwrap();
if fs::File::open(&path).is_err_and(|e| e.kind() == std::io::ErrorKind::PermissionDenied) {
assert!(p.refresh_pid(42).is_err());
assert_eq!(p.get(42).unwrap().availability, Availability::Inaccessible);
assert_eq!(p.get(42).unwrap().memory_bytes, 3 * 4096);
}
fs::set_permissions(&path, fs::Permissions::from_mode(0o600)).unwrap();
assert_eq!(p.refresh_pid(42).unwrap().availability, Availability::Fresh);
}