vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
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();
}