flagon-io/g1t

public

Star 0

Commit

The runner's cancellation test no longer fails on a busy machine. It sent its log to an address that is not there (127.0.0.1:9), and once a step outlasted a batch of the log (1.5 s), each batch was tried three times with waits between, about 3 s, inside the loop that times the grace after SIGINT; two batches carried the step past the 8 s the test allows, and it read as SIGINT not ending the step. The tests now use an API with no address, which sends nothing, and the log keeps what it would have sent so the test still reads it all. Failing the same way on demand (cancelling at 1.6 s instead of 0.6 s) took 10.6 s before and passes in 1.8 s now.

Claude-Session:: https://claude.ai/code/session_01MQE64a4WNN14F8GELCiuc9

Claudeagent and Claudeagentcommitted 1d agoParent87b4b00Browse files

300	300		use std::process::Command;
301	301		use std::time::{Duration, Instant};
302	302
303		−	let api = Api { base: "http://127.0.0.1:9".into(), job: "job_1".into(), token: "t".into() };
304		−	let mut log = Log::new(api, Vec::new());
	303	+	// Offline: on a busy machine the step can outlast a batch of the log,
	304	+	// and sending it to an address that is not there held the loop for
	305	+	// seconds, past the grace this test measures.
	306	+	let mut log = Log::new(Api::offline(), Vec::new());
305	307		let mut command = Command::new("sh");
306	308		command.args(["-c", "trap 'echo cleaned up; exit 3' INT; echo started; while true; do sleep 0.1; done"]);
307	309		let began = Instant::now();

103	103		}
104	104		}
105	105
	106	+	/// An API with no address, which sends nothing: what the tests use, so
	107	+	/// a step's run is not held up by reports that go nowhere (each one
	108	+	/// tried three times, with waits between, over a second and a half).
	109	+	#[cfg(test)]
	110	+	pub(crate) fn offline() -> Api {
	111	+	Api { base: String::new(), job: "job_1".into(), token: "t".into() }
	112	+	}
	113	+
106	114		pub(crate) fn report(&self, report: Value) {
	115	+	// No address: nowhere to send it (Api::offline).
	116	+	if self.base.is_empty() {
	117	+	return;
	118	+	}
107	119		// A report that cannot be sent is tried a few times, then dropped:
108	120		// the job goes on, and g1t notices a silent job by itself.
109	121		for attempt in 0..3 {
⋯
135	147		last: Instant,
136	148		/// When anything was last sent, for the ping.
137	149		sent: Instant,
	150	+	/// Everything sent so far, so a test reads the whole log however its
	151	+	/// batches fell (`buffered`).
	152	+	#[cfg(test)]
	153	+	flushed: String,
138	154		}
139	155
140	156		impl Log {
⋯
148	164		buffer: String::new(),
149	165		last: Instant::now(),
150	166		sent: Instant::now(),
	167	+	#[cfg(test)]
	168	+	flushed: String::new(),
151	169		}
152	170		}
153	171
154		−	/// What waits to be sent.
	172	+	/// The log so far: what was sent and what waits to be.
155	173		#[cfg(all(test, unix))]
156	174		pub(crate) fn buffered(&self) -> String {
157		−	self.buffer.clone()
	175	+	format!("{}{}", self.flushed, self.buffer)
158	176		}
159	177
160	178		/// Starts writing to step `number` (0 for the job's setup).
⋯
210	228		}
211	229		self.sent = Instant::now();
212	230		let text = std::mem::take(&mut self.buffer);
	231	+	#[cfg(test)]
	232	+	self.flushed.push_str(&text);
213	233		self.api.report(json!({ "kind": "log", "step": self.step, "text": text }));
214	234		}
215	235
⋯
286	306		use super::*;
287	307
288	308		fn log(secrets: &[&str]) -> Log {
289		−	let api = Api { base: "http://127.0.0.1:9".into(), job: "job_1".into(), token: "t".into() };
290		−	Log::new(api, mask::all_variants(secrets.iter().copied()))
	309	+	Log::new(Api::offline(), mask::all_variants(secrets.iter().copied()))
291	310		}
292	311
293	312		#[test]