From ff6f36970c0fcf8508ce4974bec8a6b288234c10 Mon Sep 17 00:00:00 2001 From: John Coffey Date: Wed, 18 Nov 2026 18:26:08 -0700 Subject: [PATCH] Test: tracer_reload streams until the new file has events The path-change part sent a fixed 2000 events and moved the tracer 5 ms in. The stream finishes in a few tens of ms, so on a fast machine every event reached the old file before the reload ran and the test failed. The stream now runs until the new file has some of it (capped at 500,000), starts the move only once the old file has some, and checks every event it sent is in exactly one of the two files. Fixes #464 --- tests/src/system/tracer_reload.rs | 61 +++++++++++++++++++++---------- 1 file changed, 42 insertions(+), 19 deletions(-) diff --git a/tests/src/system/tracer_reload.rs b/tests/src/system/tracer_reload.rs index a2568ded..632ce04c 100644 --- a/tests/src/system/tracer_reload.rs +++ b/tests/src/system/tracer_reload.rs @@ -23,11 +23,18 @@ use registry::{ use serde_json::json; use std::{ path::{Path, PathBuf}, + sync::{ + Arc, + atomic::{AtomicBool, Ordering}, + }, time::{Duration, Instant}, }; use trc::{EventType, ServerEvent}; const PREFIX: &str = "tracer-reload"; +// Upper bound on the event stream, so a reload that never lands fails +// instead of filling the disk +const MAX_SEQ: usize = 500_000; #[tokio::test(flavor = "multi_thread")] pub async fn tracer_reload_tests() { @@ -100,16 +107,24 @@ async fn test_log_tracer_moves(test: &TestServer) { emit("marker-before"); wait_for(&old_file, "marker-before").await; - // Events keep coming while the path changes - let stream = tokio::spawn(async { - for i in 0..2000u32 { - emit(&format!("seq-{i:05}-end")); - if i % 50 == 0 { - tokio::time::sleep(Duration::from_millis(1)).await; + // Events keep coming while the path changes: the stream runs until the + // new file has some of it, so the switch always lands mid-stream (#464) + let stop = Arc::new(AtomicBool::new(false)); + let stream = tokio::spawn({ + let stop = stop.clone(); + async move { + let mut sent = 0usize; + while !stop.load(Ordering::Relaxed) && sent < MAX_SEQ { + emit(&format!("seq-{sent:06}-end")); + sent += 1; + if sent % 50 == 0 { + tokio::time::sleep(Duration::from_millis(1)).await; + } } + sent } }); - tokio::time::sleep(Duration::from_millis(5)).await; + wait_for(&old_file, "seq-").await; let response = admin .registry_update( ObjectType::Tracer, @@ -117,36 +132,44 @@ async fn test_log_tracer_moves(test: &TestServer) { ) .await; assert_applied(&response); - stream.await.unwrap(); + wait_for(&new_file, "seq-").await; + stop.store(true, Ordering::Relaxed); + let sent = stream.await.unwrap(); + assert!(sent < MAX_SEQ, "the reload never reached the new file"); // Once the reload has run, events go to the new file only tokio::time::sleep(Duration::from_millis(200)).await; emit("marker-after"); wait_for(&new_file, "marker-after").await; - wait_for(&new_file, "seq-01999-end").await; + wait_for(&new_file, &format!("seq-{:06}-end", sent - 1)).await; tokio::time::sleep(Duration::from_millis(200)).await; let old = read(&old_file); let new = read(&new_file); assert!(!old.contains("marker-after"), "old file still written to"); assert!(!new.contains("marker-before")); - // Every event written once, in one file or the other - let old_seq = count_seq(&old); - let new_seq = count_seq(&new); + // Every event written once, in one file or the other, and both files + // got part of the stream + let old_seq = count_seq(&old, sent); + let new_seq = count_seq(&new, sent); println!( - "{} events in the old file, {} in the new one", + "{sent} events sent: {} in the old file, {} in the new one", old_seq.iter().filter(|c| **c > 0).count(), new_seq.iter().filter(|c| **c > 0).count() ); - for i in 0..2000 { + for i in 0..sent { assert_eq!( old_seq[i] + new_seq[i], 1, - "seq-{i:05} written {} + {} times", + "seq-{i:06} written {} + {} times", old_seq[i], new_seq[i] ); } + assert!( + old_seq.iter().any(|c| *c > 0), + "no event of the stream reached the old file" + ); assert!( new_seq.iter().any(|c| *c > 0), "no event of the stream reached the new file" @@ -200,11 +223,11 @@ fn read(path: &Path) -> String { std::fs::read_to_string(path).unwrap_or_default() } -fn count_seq(text: &str) -> Vec { - let mut counts = vec![0u32; 2000]; +fn count_seq(text: &str, sent: usize) -> Vec { + let mut counts = vec![0u32; sent]; for part in text.split("seq-").skip(1) { - if let Some(n) = part.get(..5).and_then(|n| n.parse::().ok()) - && part[5..].starts_with("-end") + if let Some(n) = part.get(..6).and_then(|n| n.parse::().ok()) + && part[6..].starts_with("-end") { counts[n] += 1; } -- 2.54.0