mirror of
https://github.com/openai/codex.git
synced 2026-11-20 22:40:37 +00:00
Add opt-in concurrent exec-server request dispatch (#36987)
## Why Sequential dispatch lets a long-running request block unrelated health checks and cleanup on the same connection. ## What changed - Add `--concurrent-requests <COUNT>` for local and remote exec-server connections, while retaining sequential dispatch when the option is omitted or set to `1`. - Preserve handshake ordering before enabling concurrent dispatch. - Reserve separate capacity for status, signal, terminate, and close requests so they remain responsive when ordinary request capacity is saturated. - Drain queued client responses during disconnect and cancel outstanding request tasks during connection shutdown. ## Testing - Cover CLI parsing and concurrency-limit validation. - Verify default sequential behavior, pipelined handshake ordering, concurrent request progress, control-request responsiveness, and disconnect handling. GitOrigin-RevId: 48e4b092e318204ed635543f01f9ee0e7df095fc
This commit is contained in:
committed by
copyberry
parent
1d952f027e
commit
eeae88d8a6
@@ -1,8 +1,10 @@
|
||||
#![cfg(unix)]
|
||||
|
||||
mod common;
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use codex_exec_server::EnvironmentInfo;
|
||||
use codex_exec_server::EnvironmentStatus;
|
||||
use codex_exec_server::EnvironmentStatusKind;
|
||||
use codex_exec_server::ExecResponse;
|
||||
use codex_exec_server::InitializeParams;
|
||||
use codex_exec_server::InitializeResponse;
|
||||
@@ -16,11 +18,17 @@ use codex_exec_server_protocol::JSONRPCResponse;
|
||||
use codex_exec_server_protocol::ProcessSandboxType;
|
||||
use codex_utils_path_uri::PathUri;
|
||||
use common::exec_server::exec_server;
|
||||
use common::exec_server::exec_server_with_env;
|
||||
use pretty_assertions::assert_eq;
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn exec_server_starts_process_over_websocket() -> anyhow::Result<()> {
|
||||
let mut server = exec_server().await?;
|
||||
let process_argv = if cfg!(windows) {
|
||||
vec!["cmd.exe", "/D", "/C", "exit 0"]
|
||||
} else {
|
||||
vec!["true"]
|
||||
};
|
||||
let initialize_id = server
|
||||
.send_request(
|
||||
"initialize",
|
||||
@@ -48,7 +56,7 @@ async fn exec_server_starts_process_over_websocket() -> anyhow::Result<()> {
|
||||
"process/start",
|
||||
serde_json::json!({
|
||||
"processId": "proc-1",
|
||||
"argv": ["true"],
|
||||
"argv": process_argv,
|
||||
"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,
|
||||
"env": {},
|
||||
"tty": false,
|
||||
@@ -86,6 +94,20 @@ async fn exec_server_starts_process_over_websocket() -> anyhow::Result<()> {
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Result<()> {
|
||||
let mut server = exec_server().await?;
|
||||
let process_argv = if cfg!(windows) {
|
||||
vec!["cmd.exe", "/D", "/C", "ping -n 601 127.0.0.1 >NUL"]
|
||||
} else {
|
||||
vec![
|
||||
"/bin/sh",
|
||||
"-c",
|
||||
"parent=$PPID; while kill -0 \"$parent\" 2>/dev/null; do sleep 1; done",
|
||||
]
|
||||
};
|
||||
let process_env = if cfg!(windows) {
|
||||
serde_json::json!({ "PATH": std::env::var("PATH")? })
|
||||
} else {
|
||||
serde_json::json!({})
|
||||
};
|
||||
let initialize_id = server
|
||||
.send_request(
|
||||
"initialize",
|
||||
@@ -112,9 +134,9 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res
|
||||
"process/start",
|
||||
serde_json::json!({
|
||||
"processId": "proc-serial-read",
|
||||
"argv": ["/bin/sh", "-c", "parent=$PPID; while kill -0 \"$parent\" 2>/dev/null; do sleep 1; done"],
|
||||
"argv": process_argv,
|
||||
"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,
|
||||
"env": {},
|
||||
"env": process_env,
|
||||
"tty": false,
|
||||
"pipeStdin": false,
|
||||
"arg0": null
|
||||
@@ -149,9 +171,9 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res
|
||||
"process/start",
|
||||
serde_json::json!({
|
||||
"processId": "proc-serial-queued",
|
||||
"argv": ["/bin/sh", "-c", "parent=$PPID; while kill -0 \"$parent\" 2>/dev/null; do sleep 1; done"],
|
||||
"argv": process_argv,
|
||||
"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,
|
||||
"env": {},
|
||||
"env": process_env,
|
||||
"tty": false,
|
||||
"pipeStdin": false,
|
||||
"arg0": null
|
||||
@@ -159,18 +181,25 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res
|
||||
)
|
||||
.await?;
|
||||
|
||||
let JSONRPCMessage::Response(JSONRPCResponse { id, .. }) = server.next_event().await? else {
|
||||
let response = server
|
||||
.wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))
|
||||
.await?;
|
||||
let JSONRPCMessage::Response(JSONRPCResponse { id, .. }) = response else {
|
||||
panic!("expected the blocked process/read to finish before the queued process/start");
|
||||
};
|
||||
assert_eq!(id, read_id);
|
||||
let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = server.next_event().await?
|
||||
else {
|
||||
let response = server
|
||||
.wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))
|
||||
.await?;
|
||||
let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = response else {
|
||||
panic!("expected the queued environment/info response after process/read");
|
||||
};
|
||||
assert_eq!(id, queued_environment_info_id);
|
||||
let _: EnvironmentInfo = serde_json::from_value(result)?;
|
||||
let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = server.next_event().await?
|
||||
else {
|
||||
let response = server
|
||||
.wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))
|
||||
.await?;
|
||||
let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = response else {
|
||||
panic!("expected the queued process/start response after process/read");
|
||||
};
|
||||
assert_eq!(id, queued_start_id);
|
||||
@@ -182,6 +211,203 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res
|
||||
}
|
||||
);
|
||||
|
||||
for process_id in ["proc-serial-read", "proc-serial-queued"] {
|
||||
let terminate_id = server
|
||||
.send_request(
|
||||
"process/terminate",
|
||||
serde_json::json!({ "processId": process_id }),
|
||||
)
|
||||
.await?;
|
||||
server
|
||||
.wait_for_event(|event| {
|
||||
matches!(
|
||||
event,
|
||||
JSONRPCMessage::Response(JSONRPCResponse { id, .. }) if id == &terminate_id
|
||||
)
|
||||
})
|
||||
.await?;
|
||||
}
|
||||
|
||||
server.shutdown().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A long read cannot block health checks; saturated ordinary work cannot block health checks or cleanup.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn exec_server_keeps_control_requests_live_during_long_reads_and_queued_requests()
|
||||
-> anyhow::Result<()> {
|
||||
let mut server = exec_server_with_env(
|
||||
std::iter::empty::<(&str, &str)>(),
|
||||
&["--concurrent-requests", "32"],
|
||||
)
|
||||
.await?;
|
||||
let process_argv = if cfg!(windows) {
|
||||
vec!["cmd.exe", "/D", "/C", "ping -n 601 127.0.0.1 >NUL"]
|
||||
} else {
|
||||
vec![
|
||||
"/bin/sh",
|
||||
"-c",
|
||||
"parent=$PPID; while kill -0 \"$parent\" 2>/dev/null; do sleep 1; done",
|
||||
]
|
||||
};
|
||||
let process_env = if cfg!(windows) {
|
||||
serde_json::json!({ "PATH": std::env::var("PATH")? })
|
||||
} else {
|
||||
serde_json::json!({})
|
||||
};
|
||||
let initialize_id = server
|
||||
.send_request(
|
||||
"initialize",
|
||||
serde_json::to_value(InitializeParams {
|
||||
client_name: "exec-server-test".to_string(),
|
||||
resume_session_id: None,
|
||||
})?,
|
||||
)
|
||||
.await?;
|
||||
assert!(matches!(
|
||||
server.next_event().await?,
|
||||
JSONRPCMessage::Response(JSONRPCResponse { id, .. }) if id == initialize_id
|
||||
));
|
||||
server
|
||||
.send_notification("initialized", serde_json::json!({}))
|
||||
.await?;
|
||||
|
||||
let process_start_id = server
|
||||
.send_request(
|
||||
"process/start",
|
||||
serde_json::json!({
|
||||
"processId": "proc-capacity",
|
||||
"argv": process_argv,
|
||||
"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,
|
||||
"env": process_env,
|
||||
"tty": false,
|
||||
"pipeStdin": false,
|
||||
"arg0": null
|
||||
}),
|
||||
)
|
||||
.await?;
|
||||
assert!(matches!(
|
||||
server.next_event().await?,
|
||||
JSONRPCMessage::Response(JSONRPCResponse { id, .. }) if id == process_start_id
|
||||
));
|
||||
|
||||
let read_params = serde_json::json!({
|
||||
"processId": "proc-capacity",
|
||||
"afterSeq": null,
|
||||
"maxBytes": null,
|
||||
"waitMs": 600_000
|
||||
});
|
||||
server
|
||||
.send_request("process/read", read_params.clone())
|
||||
.await?;
|
||||
let concurrent_start_id = server
|
||||
.send_request(
|
||||
"process/start",
|
||||
serde_json::json!({
|
||||
"processId": "proc-concurrent",
|
||||
"argv": process_argv,
|
||||
"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,
|
||||
"env": process_env,
|
||||
"tty": false,
|
||||
"pipeStdin": false,
|
||||
"arg0": null
|
||||
}),
|
||||
)
|
||||
.await?;
|
||||
let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = server.next_event().await?
|
||||
else {
|
||||
panic!("expected process/start to finish before the pending process/read");
|
||||
};
|
||||
assert_eq!(id, concurrent_start_id);
|
||||
assert_eq!(
|
||||
serde_json::from_value::<ExecResponse>(result)?,
|
||||
ExecResponse {
|
||||
process_id: ProcessId::from("proc-concurrent"),
|
||||
sandbox_type: Some(ProcessSandboxType::None),
|
||||
}
|
||||
);
|
||||
for _ in 1..32 {
|
||||
server
|
||||
.send_request("process/read", read_params.clone())
|
||||
.await?;
|
||||
}
|
||||
|
||||
let queued_read_id = server.send_request("process/read", read_params).await?;
|
||||
|
||||
let environment_info_id = server
|
||||
.send_request("environment/info", serde_json::json!({}))
|
||||
.await?;
|
||||
let response = server
|
||||
.wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))
|
||||
.await?;
|
||||
let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = response else {
|
||||
panic!("expected environment/info response at regular request capacity");
|
||||
};
|
||||
assert_eq!(id, environment_info_id);
|
||||
let _: EnvironmentInfo = serde_json::from_value(result)?;
|
||||
|
||||
let environment_status_id = server
|
||||
.send_request("environment/status", serde_json::json!({}))
|
||||
.await?;
|
||||
let response = server
|
||||
.wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))
|
||||
.await?;
|
||||
let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = response else {
|
||||
panic!("expected environment/status response at regular request capacity");
|
||||
};
|
||||
assert_eq!(id, environment_status_id);
|
||||
assert_eq!(
|
||||
serde_json::from_value::<EnvironmentStatus>(result)?,
|
||||
EnvironmentStatus {
|
||||
status: EnvironmentStatusKind::Ready,
|
||||
}
|
||||
);
|
||||
|
||||
let terminate_id = server
|
||||
.send_request(
|
||||
"process/terminate",
|
||||
serde_json::json!({ "processId": "proc-capacity" }),
|
||||
)
|
||||
.await?;
|
||||
let mut terminate_response = None;
|
||||
let mut queued_read_completed = false;
|
||||
while terminate_response.is_none() || !queued_read_completed {
|
||||
match server.next_event().await? {
|
||||
JSONRPCMessage::Response(JSONRPCResponse { id, result }) if id == terminate_id => {
|
||||
terminate_response = Some(serde_json::from_value::<TerminateResponse>(result)?);
|
||||
}
|
||||
JSONRPCMessage::Response(JSONRPCResponse { id, result }) if id == queued_read_id => {
|
||||
let _: ReadResponse = serde_json::from_value(result)?;
|
||||
queued_read_completed = true;
|
||||
}
|
||||
JSONRPCMessage::Error(error) => {
|
||||
anyhow::bail!("unexpected error while waiting for queued requests: {error:?}");
|
||||
}
|
||||
JSONRPCMessage::Request(_)
|
||||
| JSONRPCMessage::Response(_)
|
||||
| JSONRPCMessage::Notification(_) => {}
|
||||
}
|
||||
}
|
||||
assert_eq!(
|
||||
terminate_response,
|
||||
Some(TerminateResponse { running: true })
|
||||
);
|
||||
|
||||
let terminate_id = server
|
||||
.send_request(
|
||||
"process/terminate",
|
||||
serde_json::json!({ "processId": "proc-concurrent" }),
|
||||
)
|
||||
.await?;
|
||||
server
|
||||
.wait_for_event(|event| {
|
||||
matches!(
|
||||
event,
|
||||
JSONRPCMessage::Response(JSONRPCResponse { id, .. }) if id == &terminate_id
|
||||
)
|
||||
})
|
||||
.await?;
|
||||
|
||||
server.shutdown().await?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -189,6 +415,20 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn exec_server_defaults_omitted_pipe_stdin_to_closed_stdin() -> anyhow::Result<()> {
|
||||
let mut server = exec_server().await?;
|
||||
let process_argv = if cfg!(windows) {
|
||||
vec!["cmd.exe", "/D", "/C", "ping -n 2 127.0.0.1 >NUL"]
|
||||
} else {
|
||||
vec![
|
||||
"/bin/sh",
|
||||
"-c",
|
||||
"sleep 0.3; if IFS= read -r line; then printf 'read:%s\\n' \"$line\"; else printf 'eof\\n'; fi",
|
||||
]
|
||||
};
|
||||
let process_env = if cfg!(windows) {
|
||||
serde_json::json!({ "PATH": std::env::var("PATH")? })
|
||||
} else {
|
||||
serde_json::json!({})
|
||||
};
|
||||
let initialize_id = server
|
||||
.send_request(
|
||||
"initialize",
|
||||
@@ -216,13 +456,9 @@ async fn exec_server_defaults_omitted_pipe_stdin_to_closed_stdin() -> anyhow::Re
|
||||
"process/start",
|
||||
serde_json::json!({
|
||||
"processId": "proc-default-stdin",
|
||||
"argv": [
|
||||
"/bin/sh",
|
||||
"-c",
|
||||
"sleep 0.3; if IFS= read -r line; then printf 'read:%s\\n' \"$line\"; else printf 'eof\\n'; fi"
|
||||
],
|
||||
"argv": process_argv,
|
||||
"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,
|
||||
"env": {},
|
||||
"env": process_env,
|
||||
"tty": false,
|
||||
"arg0": null
|
||||
}),
|
||||
@@ -284,6 +520,26 @@ async fn exec_server_defaults_omitted_pipe_stdin_to_closed_stdin() -> anyhow::Re
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn exec_server_dedupes_retried_process_write_ids() -> anyhow::Result<()> {
|
||||
let mut server = exec_server().await?;
|
||||
let process_argv = if cfg!(windows) {
|
||||
vec![
|
||||
"powershell.exe",
|
||||
"-NoProfile",
|
||||
"-NonInteractive",
|
||||
"-Command",
|
||||
"[Console]::Out.WriteLine('line:' + [Console]::In.ReadLine()); [Console]::Out.WriteLine('line:' + [Console]::In.ReadLine())",
|
||||
]
|
||||
} else {
|
||||
vec![
|
||||
"/bin/sh",
|
||||
"-c",
|
||||
"IFS= read -r first; printf 'line:%s\\n' \"$first\"; IFS= read -r second; printf 'line:%s\\n' \"$second\"",
|
||||
]
|
||||
};
|
||||
let process_env = if cfg!(windows) {
|
||||
serde_json::to_value(std::env::vars().collect::<HashMap<_, _>>())?
|
||||
} else {
|
||||
serde_json::json!({})
|
||||
};
|
||||
let initialize_id = server
|
||||
.send_request(
|
||||
"initialize",
|
||||
@@ -311,13 +567,9 @@ async fn exec_server_dedupes_retried_process_write_ids() -> anyhow::Result<()> {
|
||||
"process/start",
|
||||
serde_json::json!({
|
||||
"processId": "proc-write-id",
|
||||
"argv": [
|
||||
"/bin/sh",
|
||||
"-c",
|
||||
"IFS= read -r first; printf 'line:%s\\n' \"$first\"; IFS= read -r second; printf 'line:%s\\n' \"$second\""
|
||||
],
|
||||
"argv": process_argv,
|
||||
"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,
|
||||
"env": {},
|
||||
"env": process_env,
|
||||
"tty": false,
|
||||
"pipeStdin": true,
|
||||
"arg0": null
|
||||
@@ -401,13 +653,16 @@ async fn exec_server_dedupes_retried_process_write_ids() -> anyhow::Result<()> {
|
||||
.flat_map(|chunk| chunk.chunk.into_inner()),
|
||||
);
|
||||
after_seq = Some(read_response.next_seq.saturating_sub(1));
|
||||
if read_response.closed || output.ends_with(b"line:second\n") {
|
||||
if read_response.closed
|
||||
|| output.ends_with(b"line:second\n")
|
||||
|| output.ends_with(b"line:second\r\n")
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
assert_eq!(
|
||||
String::from_utf8(output)?,
|
||||
String::from_utf8(output)?.replace("\r\n", "\n"),
|
||||
"line:first\nline:second\n".to_string()
|
||||
);
|
||||
|
||||
@@ -418,6 +673,16 @@ async fn exec_server_dedupes_retried_process_write_ids() -> anyhow::Result<()> {
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn exec_server_resumes_detached_session_without_killing_processes() -> anyhow::Result<()> {
|
||||
let mut server = exec_server().await?;
|
||||
let process_argv = if cfg!(windows) {
|
||||
vec!["cmd.exe", "/D", "/C", "ping -n 6 127.0.0.1 >NUL"]
|
||||
} else {
|
||||
vec!["/bin/sh", "-c", "sleep 5"]
|
||||
};
|
||||
let process_env = if cfg!(windows) {
|
||||
serde_json::json!({ "PATH": std::env::var("PATH")? })
|
||||
} else {
|
||||
serde_json::json!({})
|
||||
};
|
||||
let initialize_id = server
|
||||
.send_request(
|
||||
"initialize",
|
||||
@@ -449,9 +714,9 @@ async fn exec_server_resumes_detached_session_without_killing_processes() -> any
|
||||
"process/start",
|
||||
serde_json::json!({
|
||||
"processId": "proc-resume",
|
||||
"argv": ["/bin/sh", "-c", "sleep 5"],
|
||||
"argv": process_argv,
|
||||
"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,
|
||||
"env": {},
|
||||
"env": process_env,
|
||||
"tty": false,
|
||||
"pipeStdin": false,
|
||||
"arg0": null
|
||||
|
||||
Reference in New Issue
Block a user