Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
44 changes: 31 additions & 13 deletions crates/pet-core/src/cache.rs
Original file line number Diff line number Diff line change
Expand Up @@ -28,6 +28,8 @@ pub struct LocatorCache<K, V> {
struct InFlightEntry<V> {
result: Mutex<Option<InFlightResult<V>>>,
changed: Condvar,
#[cfg(test)]
waiting: std::sync::atomic::AtomicBool,
}

#[derive(Clone)]
Expand All @@ -52,6 +54,8 @@ impl<V> InFlightEntry<V> {
Self {
result: Mutex::new(None),
changed: Condvar::new(),
#[cfg(test)]
waiting: std::sync::atomic::AtomicBool::new(false),
}
}
}
Expand Down Expand Up @@ -233,6 +237,10 @@ impl<K: Eq + Hash, V: Clone> LocatorCache<K, V> {
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
while result.is_none() {
#[cfg(test)]
entry
.waiting
.store(true, std::sync::atomic::Ordering::Release);
result = entry
.changed
.wait(result)
Expand Down Expand Up @@ -313,7 +321,15 @@ mod tests {
mpsc, Arc, Barrier, Mutex,
};
use std::thread;
use std::time::Duration;
use std::time::{Duration, Instant};

fn wait_for_pending<V>(entry: &InFlightEntry<V>) {
let deadline = Instant::now() + Duration::from_secs(5);
while !entry.waiting.load(Ordering::Acquire) {
assert!(Instant::now() < deadline, "cache waiter did not block");
thread::yield_now();
}
}

#[test]
fn test_cache_get_and_insert() {
Expand Down Expand Up @@ -379,6 +395,8 @@ mod tests {

barrier.wait();
started_rx.recv_timeout(Duration::from_secs(5)).unwrap();
let entry = cache.in_flight.lock().unwrap().get("key").unwrap().clone();
wait_for_pending(&entry);
assert_eq!(calls.load(Ordering::SeqCst), 1);
assert!(started_rx.try_recv().is_err());

Expand All @@ -397,21 +415,20 @@ mod tests {

#[test]
fn test_cache_get_or_insert_with_shares_concurrent_none_result() {
let entry = Arc::new(InFlightEntry::new());
let cache: LocatorCache<String, i32> = LocatorCache::new();
let InFlightClaim::Owner(owner) = cache.claim_in_flight(&"key".to_string()) else {
panic!("new cache unexpectedly has an in-flight owner");
};
let entry = owner.entry.clone();
let waiter_entry = entry.clone();
let waiter =
thread::spawn(move || LocatorCache::<String, i32>::wait_for_in_flight(waiter_entry));

*entry
.result
.lock()
.expect("locator cache in-flight result lock poisoned") =
Some(InFlightResult::Value(None));
entry.changed.notify_all();
wait_for_pending(&entry);
owner.complete(None);

assert_eq!(waiter.join().unwrap(), None);

let cache: LocatorCache<String, i32> = LocatorCache::new();
assert_eq!(cache.get_or_insert_with("key".to_string(), || None), None);
assert!(!cache.contains_key(&"key".to_string()));

Expand Down Expand Up @@ -452,12 +469,13 @@ mod tests {
in_flight: &in_flight,
};

let waiter_entry = entry.clone();
let waiter =
thread::spawn(move || LocatorCache::<String, i32>::wait_for_in_flight(waiter_entry));
wait_for_pending(&entry);
drop(owner);

let waiter_result =
std::panic::catch_unwind(|| LocatorCache::<String, i32>::wait_for_in_flight(entry));

assert!(waiter_result.is_err());
assert!(waiter.join().is_err());
assert!(in_flight.lock().unwrap().is_empty());
}

Expand Down
39 changes: 31 additions & 8 deletions crates/pet-jsonrpc/src/output.rs
Original file line number Diff line number Diff line change
Expand Up @@ -101,9 +101,22 @@ impl Output {
ready: Condvar::new(),
});
let writer_shared = Arc::clone(&shared);
#[cfg(test)]
let (waiting_tx, waiting_rx) = std::sync::mpsc::sync_channel(1);
thread::Builder::new()
.name("pet-jsonrpc-output".to_string())
.spawn(move || writer_loop(writer, writer_shared))?;
.spawn(move || {
writer_loop(
writer,
writer_shared,
#[cfg(test)]
waiting_tx,
)
})?;
#[cfg(test)]
waiting_rx
.recv_timeout(std::time::Duration::from_secs(5))
.expect("test writer did not reach its empty-queue wait");

Ok(Self {
shared,
Expand Down Expand Up @@ -209,7 +222,13 @@ impl Output {
}
}

fn writer_loop(mut writer: impl Write, shared: Arc<Shared>) {
fn writer_loop(
mut writer: impl Write,
shared: Arc<Shared>,
#[cfg(test)] waiting: std::sync::mpsc::SyncSender<()>,
) {
#[cfg(test)]
let mut waiting = Some(waiting);
loop {
let frame = {
let mut state = shared
Expand All @@ -224,6 +243,10 @@ fn writer_loop(mut writer: impl Write, shared: Arc<Shared>) {
if !state.accepting {
return;
}
#[cfg(test)]
if let Some(waiting) = waiting.take() {
waiting.send(()).expect("test writer observer dropped");
}
state = shared
.ready
.wait(state)
Expand Down Expand Up @@ -562,11 +585,11 @@ mod tests {

impl Write for BlockingWriter {
fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
let (released, ready) = &*self.release;
let mut released = released.lock().expect("release lock poisoned");
if let Some(entered) = self.entered.take() {
entered.send(()).expect("blocked writer observer dropped");
}
let (released, ready) = &*self.release;
let mut released = released.lock().expect("release lock poisoned");
while !*released {
released = ready.wait(released).expect("release lock poisoned");
}
Expand Down Expand Up @@ -616,13 +639,13 @@ mod tests {

impl Write for DelayedFailingWriter {
fn write(&mut self, _bytes: &[u8]) -> io::Result<usize> {
let (released, ready) = &*self.release;
let mut released = released.lock().expect("release lock poisoned");
self.entered
.take()
.expect("writer entered more than once")
.send(())
.expect("writer observer dropped");
let (released, ready) = &*self.release;
let mut released = released.lock().expect("release lock poisoned");
while !*released {
released = ready.wait(released).expect("release lock poisoned");
}
Expand Down Expand Up @@ -1088,11 +1111,11 @@ mod tests {
where
S: Serializer,
{
let (released, ready) = &*self.release;
let mut released = released.lock().expect("release lock poisoned");
self.entered
.send(())
.expect("serialization observer dropped");
let (released, ready) = &*self.release;
let mut released = released.lock().expect("release lock poisoned");
while !*released {
released = ready.wait(released).expect("release lock poisoned");
}
Expand Down
35 changes: 29 additions & 6 deletions crates/pet-python-utils/src/process.rs
Original file line number Diff line number Diff line change
Expand Up @@ -670,7 +670,7 @@ mod tests {
struct ReleaseDescendant(tempfile::TempDir);

impl ReleaseDescendant {
fn assert_terminated(&self) {
fn assert_terminated(&self, mut waiting: Option<std::sync::mpsc::SyncSender<()>>) {
assert!(
self.0.path().join("ready").exists(),
"descendant never started"
Expand All @@ -681,6 +681,9 @@ mod tests {
match lease.try_lock() {
Ok(()) => break,
Err(fs::TryLockError::WouldBlock) => {
if let Some(waiting) = waiting.take() {
waiting.send(()).expect("lease wait observer dropped");
}
assert!(
started.elapsed() < CLEANUP_TIMEOUT,
"descendant still holds its lease"
Expand All @@ -697,6 +700,26 @@ mod tests {
}
}

#[test]
fn termination_check_waits_for_the_descendant_lease() {
use std::sync::{mpsc, Arc};

let directory = Arc::new(ReleaseDescendant(tempfile::tempdir().unwrap()));
let lease = fs::File::create(directory.0.path().join("lease")).unwrap();
lease.lock().unwrap();
fs::write(directory.0.path().join("ready"), b"ready").unwrap();
let (waiting_tx, waiting_rx) = mpsc::sync_channel(1);
let waiting_directory = directory.clone();
let waiter = thread::spawn(move || waiting_directory.assert_terminated(Some(waiting_tx)));

waiting_rx
.recv_timeout(CLEANUP_TIMEOUT)
.expect("termination check did not observe the held lease");
assert!(!waiter.is_finished());
lease.unlock().unwrap();
waiter.join().unwrap();
}

impl ReleaseDescendant {
fn release(&self) -> io::Result<()> {
fs::write(self.0.path().join("release"), b"release")?;
Expand Down Expand Up @@ -748,7 +771,7 @@ mod tests {
Some(if mode == "tree-nonzero" { 23 } else { 0 })
);
assert!(started.elapsed() < Duration::from_secs(5));
directory.assert_terminated();
directory.assert_terminated(None);
assert_child_reaped(fs::read_to_string(pid).unwrap().parse().unwrap());
}
}
Expand All @@ -768,7 +791,7 @@ mod tests {
assert!(matches!(error, ProcessError::OutputLimit(4096)), "{error}");
}
assert!(started.elapsed() < Duration::from_secs(5));
directory.assert_terminated();
directory.assert_terminated(None);
}
}

Expand Down Expand Up @@ -802,7 +825,7 @@ mod tests {
.unwrap()
.status
.success());
directory.assert_terminated();
directory.assert_terminated(None);
}

#[cfg(windows)]
Expand Down Expand Up @@ -906,7 +929,7 @@ mod tests {
.unwrap()
.status
.success());
owned.assert_terminated();
owned.assert_terminated(None);
assert!(unrelated.0.try_wait().unwrap().is_none());
let lease = fs::File::open(directory.path().join("lease")).unwrap();
assert!(matches!(
Expand Down Expand Up @@ -1187,7 +1210,7 @@ mod tests {
assert!(matches!(error, ProcessError::Cancelled), "{error}");
});

owned.assert_terminated();
owned.assert_terminated(None);
assert_child_reaped(fs::read_to_string(root_pid).unwrap().parse().unwrap());
assert!(unrelated.0.try_wait().unwrap().is_none());
let lease = fs::File::open(unrelated_directory.path().join("lease")).unwrap();
Expand Down
Loading
Loading