Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

wait for supervisor readiness in provider tests (#3419)

kt593e2f07693e
diff --git a/crates/pa-daemon/tests/provider_failure_e2e.rs b/crates/pa-daemon/tests/provider_failure_e2e.rs
index c39b39f69a..394694564f 100644
--- a/crates/pa-daemon/tests/provider_failure_e2e.rs
+++ b/crates/pa-daemon/tests/provider_failure_e2e.rs
@@ -33,8 +33,8 @@ use serde_json::{json, Value};
struct Supervisor {
child: Child,
- #[allow(dead_code)]
socket: PathBuf,
+ stderr_path: PathBuf,
}
impl Drop for Supervisor {
@@ -202,6 +202,8 @@ fn serve(
#[allow(clippy::zombie_processes)]
fn spawn_supervisor(socket: &Path, agent_dir: &Path) -> Supervisor {
std::fs::create_dir_all(agent_dir).expect("agent dir");
+ let stderr_path = agent_dir.join("supervisor-stderr.log");
+ let stderr = std::fs::File::create(&stderr_path).expect("capture supervisor stderr");
let child = Command::new(env!("CARGO_BIN_EXE_pa-daemon"))
.arg("supervisor")
.arg("--socket")
@@ -210,7 +212,7 @@ fn spawn_supervisor(socket: &Path, agent_dir: &Path) -> Supervisor {
.arg(agent_dir)
.stdin(Stdio::null())
.stdout(Stdio::null())
- .stderr(Stdio::null())
+ .stderr(Stdio::from(stderr))
.env_remove("PRIME_API_KEY")
.env_remove("PRIME_AGENT_CODING_AGENT_DIR")
// A supervisor killed at teardown must not leak session workers: the supervisor-lost
@@ -221,17 +223,50 @@ fn spawn_supervisor(socket: &Path, agent_dir: &Path) -> Supervisor {
)
.spawn()
.expect("spawn pa-daemon supervisor");
+ Supervisor {
+ child,
+ socket: socket.to_path_buf(),
+ stderr_path,
+ }
+}
+
+// Socket presence precedes listen readiness; return the connection itself so
+// callers do not race a second connect after a successful probe.
+fn connect_when_ready(
+ socket: &Path,
+ mut exit_status: impl FnMut() -> std::io::Result<Option<std::process::ExitStatus>>,
+ mut on_pending: impl FnMut(),
+) -> std::io::Result<std::os::unix::net::UnixStream> {
let deadline = Instant::now() + Duration::from_secs(10);
- while Instant::now() < deadline {
- if socket.exists() {
- return Supervisor {
- child,
- socket: socket.to_path_buf(),
- };
+ loop {
+ if let Some(status) = exit_status()? {
+ return Err(std::io::Error::other(format!(
+ "supervisor exited during startup: {status}"
+ )));
+ }
+ match std::os::unix::net::UnixStream::connect(socket) {
+ Ok(stream) => return Ok(stream),
+ // On macOS/BSD, connect to a bound-but-not-yet-listening unix socket
+ // fails with EINVAL; treat it as pending, like NotFound/ConnectionRefused.
+ Err(error)
+ if matches!(
+ error.kind(),
+ std::io::ErrorKind::NotFound
+ | std::io::ErrorKind::ConnectionRefused
+ | std::io::ErrorKind::InvalidInput
+ ) =>
+ {
+ if Instant::now() >= deadline {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::TimedOut,
+ format!("supervisor readiness timed out: {error}"),
+ ));
+ }
+ on_pending();
+ }
+ Err(error) => return Err(error),
}
- std::thread::sleep(Duration::from_millis(20));
}
- panic!("supervisor socket never appeared");
}
/// One client connection: request/response plus the session events that stream while a response is
@@ -243,8 +278,19 @@ struct Client {
}
impl Client {
- fn connect(socket: &Path) -> Client {
- let stream = std::os::unix::net::UnixStream::connect(socket).expect("connect");
+ fn connect(supervisor: &mut Supervisor) -> Client {
+ let stream = connect_when_ready(
+ &supervisor.socket,
+ || supervisor.child.try_wait(),
+ || std::thread::sleep(Duration::from_millis(20)),
+ )
+ .unwrap_or_else(|error| {
+ let mut stderr = String::new();
+ if let Ok(file) = std::fs::File::open(&supervisor.stderr_path) {
+ let _ = file.take(16 * 1024).read_to_string(&mut stderr);
+ }
+ panic!("supervisor startup: {error}; stderr: {stderr}");
+ });
let writer = stream.try_clone().expect("clone");
let mut client = Client {
reader: BufReader::new(stream),
@@ -393,8 +439,8 @@ fn setup_with_rejection(
)
.expect("write settings.json");
let socket = dir.path().join(format!("{name}.sock"));
- let supervisor = spawn_supervisor(&socket, &agent_dir);
- let mut client = Client::connect(&socket);
+ let mut supervisor = spawn_supervisor(&socket, &agent_dir);
+ let mut client = Client::connect(&mut supervisor);
client.send_command(
"c1",
&json!({
@@ -1149,3 +1195,64 @@ fn provider_failure_recovered_by_retry_settles_the_turn() {
"no bare agent_end frames: {agent_ends:?}"
);
}
+
+#[test]
+fn socket_presence_is_not_readiness_until_listen_succeeds() {
+ let dir = tempfile::TempDir::new().expect("temp dir");
+ let path = dir.path().join("bound-before-listen.sock");
+ let listener = socket2::Socket::new(
+ socket2::Domain::UNIX,
+ socket2::Type::STREAM,
+ /*protocol*/ None,
+ )
+ .expect("socket");
+ listener
+ .bind(&socket2::SockAddr::unix(&path).expect("address"))
+ .expect("bind without listen");
+ assert!(path.exists());
+ let refusal = std::os::unix::net::UnixStream::connect(&path)
+ .unwrap_err()
+ .kind();
+ assert!(
+ matches!(
+ refusal,
+ std::io::ErrorKind::ConnectionRefused | std::io::ErrorKind::InvalidInput
+ ),
+ "bound-before-listen must refuse the connection (Linux: ECONNREFUSED, macOS: EINVAL)"
+ );
+ let mut pending = 0;
+ let stream = connect_when_ready(
+ &path,
+ || Ok(None),
+ || {
+ pending += 1;
+ listener
+ .listen(1)
+ .expect("permit listening only after the readiness probe refuses");
+ },
+ )
+ .expect("wait for readiness");
+ assert_eq!(pending, 1);
+ let (peer, _) = listener.accept().expect("accept the returned connection");
+ drop(peer);
+ drop(stream);
+}
+
+#[test]
+fn readiness_reports_child_exit_instead_of_waiting_on_a_stale_socket() {
+ use std::os::unix::process::ExitStatusExt;
+ let dir = tempfile::TempDir::new().expect("temp dir");
+ let path = dir.path().join("exited.sock");
+ let listener = std::os::unix::net::UnixListener::bind(&path).expect("bind");
+ drop(listener);
+ let error = connect_when_ready(
+ &path,
+ || Ok(Some(std::process::ExitStatus::from_raw(23 << 8))),
+ || panic!("exited child must not retry"),
+ )
+ .unwrap_err();
+ assert!(
+ error.to_string().contains("exited during startup"),
+ "{error}"
+ );
+}