use crate::{Error, Runtime, signal::lock};
use std::{
sync::{atomic::Ordering, mpsc},
thread,
time::{Duration, Instant},
};
#[test]
fn premature_coordinator_exit_retains_undrained_runtime_ownership() {
const CHILD: &str = "VTHREAD_UNDRAINED_COORDINATOR_CHILD";
if std::env::var_os(CHILD).is_none() {
let started = Instant::now();
let output = std::process::Command::new(std::env::current_exe().unwrap())
.args(["--exact", "lifecycle_owner::lifecycle_failure_test::premature_coordinator_exit_retains_undrained_runtime_ownership", "--nocapture"])
.env(CHILD, "1").output().unwrap();
let elapsed = started.elapsed();
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
output.status.success() && stdout.contains("1 passed"),
"isolated coordinator failure; status={:?}; elapsed={elapsed:?}\nstdout:\n{stdout}\nstderr:\n{stderr}",
output.status,
);
return;
}
let (finished, watchdog) = mpsc::sync_channel(1);
let watcher = thread::spawn(move || {
if watchdog.recv_timeout(Duration::from_secs(3)).is_err() {
std::process::exit(26);
}
});
let runtime = Runtime::new().unwrap();
let id = runtime.id();
runtime
.shared
.fail_coordinator_before_drain
.store(true, Ordering::Relaxed);
assert!(matches!(runtime.shutdown(), Err(Error::LifecycleFailed(_))));
drop(runtime);
assert!(matches!(Runtime::new(), Err(Error::LifecycleFailed(_))));
let owner = lock(super::OWNER.get().unwrap());
let slots = lock(&owner.as_ref().unwrap().state.slots);
let retained = slots
.entries
.iter()
.find(|entry| entry.shared.id == id)
.unwrap();
assert!(
retained.worker.joined(),
"coordinator exit itself was not joined"
);
assert!(
!retained
.resources
.drained(&retained.shared, retained.worker.joined())
);
assert_eq!(
retained.resources.workers.counts(),
(1, 0),
"carrier join handles were dropped during coordinator unwind"
);
assert_ne!(
retained.shared.shutdown_phase(),
crate::ShutdownPhase::Complete
);
finished.send(()).unwrap();
watcher.join().unwrap();
}