Simplify exec-server RPC batching

This commit is contained in:
jif-oai
2026-06-21 12:20:00 +02:00
parent 88915cb1f3
commit f78399efc7
9 changed files with 43 additions and 390 deletions
-1
View File
@@ -3049,7 +3049,6 @@ dependencies = [
"codex-utils-path-uri",
"futures",
"serde",
"serde_json",
]
[[package]]
-25
View File
@@ -97,7 +97,6 @@ use crate::protocol::TerminateParams;
use crate::protocol::TerminateResponse;
use crate::protocol::WriteParams;
use crate::protocol::WriteResponse;
use crate::rpc::RpcBatchCall;
use crate::rpc::RpcCallError;
use crate::rpc::RpcClient;
@@ -762,29 +761,6 @@ impl ExecServerClient {
self.call_rpc(&rpc_client, method, params).await
}
pub(crate) async fn call_batch(
&self,
calls: Vec<RpcBatchCall>,
) -> Result<Vec<Result<Value, ExecServerError>>, ExecServerError> {
let rpc_client = self.inner.rpc_client().await?;
match rpc_client.call_batch(calls).await {
Ok(results) => Ok(results
.into_iter()
.map(|result| result.map_err(ExecServerError::from))
.collect()),
Err(error) => {
let error = ExecServerError::from(error);
if is_transport_closed_error(&error) {
Err(ExecServerError::Disconnected(disconnected_message(
/*reason*/ None,
)))
} else {
Err(error)
}
}
}
}
async fn call_rpc<P, T>(
&self,
rpc_client: &Arc<RpcClient>,
@@ -837,7 +813,6 @@ impl From<RpcCallError> for ExecServerError {
code: error.code,
message: error.message,
},
RpcCallError::InvalidBatch(message) => Self::Protocol(message),
}
}
}
-2
View File
@@ -42,8 +42,6 @@ pub use codex_file_system::CopyOptions;
pub use codex_file_system::CreateDirectoryOptions;
pub use codex_file_system::ExecutorFileSystem;
pub use codex_file_system::ExecutorFileSystemFuture;
pub use codex_file_system::ExecutorRpcBatchCall;
pub use codex_file_system::ExecutorRpcBatchResult;
pub use codex_file_system::FILE_READ_CHUNK_SIZE;
pub use codex_file_system::FileMetadata;
pub use codex_file_system::FileSystemReadStream;
@@ -1,10 +1,5 @@
use base64::Engine as _;
use base64::engine::general_purpose::STANDARD;
use codex_utils_absolute_path::AbsolutePathBuf;
use codex_utils_path_uri::PathUri;
use futures::StreamExt;
use serde::Serialize;
use serde::de::DeserializeOwned;
use std::path::Path;
use std::path::PathBuf;
use std::sync::Arc;
@@ -20,7 +15,6 @@ use crate::CreateDirectoryOptions;
use crate::ExecServerRuntimePaths;
use crate::ExecutorFileSystem;
use crate::ExecutorFileSystemFuture;
use crate::ExecutorRpcBatchCall;
use crate::FILE_READ_CHUNK_SIZE;
use crate::FileMetadata;
use crate::FileSystemReadStream;
@@ -28,36 +22,10 @@ use crate::FileSystemResult;
use crate::FileSystemSandboxContext;
use crate::ReadDirectoryEntry;
use crate::RemoveOptions;
use crate::protocol::FS_CANONICALIZE_METHOD;
use crate::protocol::FS_COPY_METHOD;
use crate::protocol::FS_CREATE_DIRECTORY_METHOD;
use crate::protocol::FS_GET_METADATA_METHOD;
use crate::protocol::FS_READ_DIRECTORY_METHOD;
use crate::protocol::FS_READ_FILE_METHOD;
use crate::protocol::FS_REMOVE_METHOD;
use crate::protocol::FS_WRITE_FILE_METHOD;
use crate::protocol::FsCanonicalizeParams;
use crate::protocol::FsCanonicalizeResponse;
use crate::protocol::FsCopyParams;
use crate::protocol::FsCopyResponse;
use crate::protocol::FsCreateDirectoryParams;
use crate::protocol::FsCreateDirectoryResponse;
use crate::protocol::FsGetMetadataParams;
use crate::protocol::FsGetMetadataResponse;
use crate::protocol::FsReadDirectoryEntry;
use crate::protocol::FsReadDirectoryParams;
use crate::protocol::FsReadDirectoryResponse;
use crate::protocol::FsReadFileParams;
use crate::protocol::FsReadFileResponse;
use crate::protocol::FsRemoveParams;
use crate::protocol::FsRemoveResponse;
use crate::protocol::FsWriteFileParams;
use crate::protocol::FsWriteFileResponse;
use crate::regular_file;
use crate::sandboxed_file_system::SandboxedFileSystem;
const MAX_READ_FILE_BYTES: u64 = 512 * 1024 * 1024;
const LOCAL_RPC_BATCH_CONCURRENCY: usize = 32;
fn file_too_large_error() -> io::Error {
io::Error::new(
@@ -224,124 +192,6 @@ impl LocalFileSystem {
.copy(source_path, destination_path, options, sandbox)
.await
}
async fn execute_rpc_batch(
&self,
calls: Vec<ExecutorRpcBatchCall>,
) -> FileSystemResult<Vec<FileSystemResult<serde_json::Value>>> {
Ok(futures::stream::iter(calls)
.map(|call| self.execute_rpc_request(call))
.buffered(LOCAL_RPC_BATCH_CONCURRENCY)
.collect()
.await)
}
async fn execute_rpc_request(
&self,
call: ExecutorRpcBatchCall,
) -> FileSystemResult<serde_json::Value> {
match call.method.as_str() {
FS_READ_FILE_METHOD => {
let params: FsReadFileParams = decode_rpc_params(call.params)?;
encode_rpc_response(FsReadFileResponse {
data_base64: STANDARD.encode(
self.read_file(&params.path, params.sandbox.as_ref())
.await?,
),
})
}
FS_WRITE_FILE_METHOD => {
let params: FsWriteFileParams = decode_rpc_params(call.params)?;
let contents = STANDARD.decode(params.data_base64).map_err(|err| {
io::Error::new(
io::ErrorKind::InvalidData,
format!("fs/writeFile received invalid base64 dataBase64: {err}"),
)
})?;
self.write_file(&params.path, contents, params.sandbox.as_ref())
.await?;
encode_rpc_response(FsWriteFileResponse {})
}
FS_CREATE_DIRECTORY_METHOD => {
let params: FsCreateDirectoryParams = decode_rpc_params(call.params)?;
self.create_directory(
&params.path,
CreateDirectoryOptions {
recursive: params.recursive.unwrap_or(false),
},
params.sandbox.as_ref(),
)
.await?;
encode_rpc_response(FsCreateDirectoryResponse {})
}
FS_GET_METADATA_METHOD => {
let params: FsGetMetadataParams = decode_rpc_params(call.params)?;
let metadata = self
.get_metadata(&params.path, params.sandbox.as_ref())
.await?;
encode_rpc_response(FsGetMetadataResponse {
is_directory: metadata.is_directory,
is_file: metadata.is_file,
is_symlink: metadata.is_symlink,
size: metadata.size,
created_at_ms: metadata.created_at_ms,
modified_at_ms: metadata.modified_at_ms,
})
}
FS_CANONICALIZE_METHOD => {
let params: FsCanonicalizeParams = decode_rpc_params(call.params)?;
encode_rpc_response(FsCanonicalizeResponse {
path: self
.canonicalize(&params.path, params.sandbox.as_ref())
.await?,
})
}
FS_READ_DIRECTORY_METHOD => {
let params: FsReadDirectoryParams = decode_rpc_params(call.params)?;
let entries = self
.read_directory(&params.path, params.sandbox.as_ref())
.await?
.into_iter()
.map(|entry| FsReadDirectoryEntry {
file_name: entry.file_name,
is_directory: entry.is_directory,
is_file: entry.is_file,
})
.collect();
encode_rpc_response(FsReadDirectoryResponse { entries })
}
FS_REMOVE_METHOD => {
let params: FsRemoveParams = decode_rpc_params(call.params)?;
self.remove(
&params.path,
RemoveOptions {
recursive: params.recursive.unwrap_or(false),
force: params.force.unwrap_or(false),
},
params.sandbox.as_ref(),
)
.await?;
encode_rpc_response(FsRemoveResponse {})
}
FS_COPY_METHOD => {
let params: FsCopyParams = decode_rpc_params(call.params)?;
self.copy(
&params.source_path,
&params.destination_path,
CopyOptions {
recursive: params.recursive,
},
params.sandbox.as_ref(),
)
.await?;
encode_rpc_response(FsCopyResponse {})
}
method => Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!("local filesystem RPC batch does not support `{method}`"),
)),
}
}
}
impl ExecutorFileSystem for LocalFileSystem {
@@ -429,21 +279,6 @@ impl ExecutorFileSystem for LocalFileSystem {
sandbox,
))
}
fn execute_rpc_batch<'a>(
&'a self,
calls: Vec<ExecutorRpcBatchCall>,
) -> ExecutorFileSystemFuture<'a, Vec<FileSystemResult<serde_json::Value>>> {
Box::pin(LocalFileSystem::execute_rpc_batch(self, calls))
}
}
fn decode_rpc_params<T: DeserializeOwned>(params: serde_json::Value) -> FileSystemResult<T> {
serde_json::from_value(params).map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))
}
fn encode_rpc_response<T: Serialize>(response: T) -> FileSystemResult<serde_json::Value> {
serde_json::to_value(response).map_err(io::Error::other)
}
impl UnsandboxedFileSystem {
@@ -9,8 +9,6 @@ use crate::CreateDirectoryOptions;
use crate::ExecServerError;
use crate::ExecutorFileSystem;
use crate::ExecutorFileSystemFuture;
use crate::ExecutorRpcBatchCall;
use crate::ExecutorRpcBatchResult;
use crate::FileMetadata;
use crate::FileSystemReadStream;
use crate::FileSystemResult;
@@ -18,7 +16,6 @@ use crate::FileSystemSandboxContext;
use crate::ReadDirectoryEntry;
use crate::RemoveOptions;
use crate::client::LazyRemoteExecServerClient;
use crate::connection::MAX_RPC_BATCH_REQUESTS;
use crate::protocol::FsCanonicalizeParams;
use crate::protocol::FsCopyParams;
use crate::protocol::FsCreateDirectoryParams;
@@ -27,7 +24,6 @@ use crate::protocol::FsReadDirectoryParams;
use crate::protocol::FsReadFileParams;
use crate::protocol::FsRemoveParams;
use crate::protocol::FsWriteFileParams;
use crate::rpc::RpcBatchCall;
const INVALID_REQUEST_ERROR_CODE: i64 = -32600;
const NOT_FOUND_ERROR_CODE: i64 = -32004;
@@ -227,43 +223,6 @@ impl RemoteFileSystem {
.map_err(map_remote_error)?;
Ok(())
}
async fn execute_rpc_batch(
&self,
calls: Vec<ExecutorRpcBatchCall>,
) -> FileSystemResult<Vec<ExecutorRpcBatchResult>> {
if calls.is_empty() {
return Ok(Vec::new());
}
let client = self.client.get().await.map_err(map_remote_error)?;
let mut decoded = Vec::with_capacity(calls.len());
let mut calls = calls.into_iter();
loop {
let call_chunk = calls
.by_ref()
.take(MAX_RPC_BATCH_REQUESTS)
.map(|call| RpcBatchCall {
method: call.method,
params: call.params,
})
.collect::<Vec<_>>();
if call_chunk.is_empty() {
break;
}
let results = client
.call_batch(call_chunk)
.await
.map_err(map_remote_error)?;
decoded.extend(
results
.into_iter()
.map(|result| result.map_err(map_remote_error)),
);
}
Ok(decoded)
}
}
impl ExecutorFileSystem for RemoteFileSystem {
@@ -351,13 +310,6 @@ impl ExecutorFileSystem for RemoteFileSystem {
sandbox,
))
}
fn execute_rpc_batch<'a>(
&'a self,
calls: Vec<ExecutorRpcBatchCall>,
) -> ExecutorFileSystemFuture<'a, Vec<ExecutorRpcBatchResult>> {
Box::pin(RemoteFileSystem::execute_rpc_batch(self, calls))
}
}
fn remote_sandbox_context(
-72
View File
@@ -26,7 +26,6 @@ use crate::connection::JsonRpcConnection;
use crate::connection::JsonRpcConnectionEvent;
use crate::connection::JsonRpcTransport;
use crate::connection::JsonRpcWireMessage;
use crate::connection::MAX_RPC_BATCH_REQUESTS;
pub(crate) const SESSION_ALREADY_ATTACHED_ERROR_CODE: i64 = -32010;
@@ -38,13 +37,6 @@ pub(crate) enum RpcCallError {
Json(serde_json::Error),
/// The executor returned a JSON-RPC error response for this call.
Server(JSONRPCErrorError),
/// The caller attempted to construct a batch that cannot be represented safely.
InvalidBatch(String),
}
pub(crate) struct RpcBatchCall {
pub(crate) method: String,
pub(crate) params: Value,
}
type PendingRequest = oneshot::Sender<Result<Value, RpcCallError>>;
@@ -412,70 +404,6 @@ impl RpcClient {
serde_json::from_value(response).map_err(RpcCallError::Json)
}
/// Sends independent RPC requests as one JSON-RPC batch.
///
/// The server may execute batch entries concurrently and does not guarantee execution order.
/// Callers must only batch requests that are safe to run in any order, and must send dependent
/// requests separately. Results are returned in the same order as `calls` by matching request
/// ids in the responses.
pub(crate) async fn call_batch(
&self,
calls: Vec<RpcBatchCall>,
) -> Result<Vec<Result<Value, RpcCallError>>, RpcCallError> {
if calls.is_empty() {
return Ok(Vec::new());
}
if calls.len() > MAX_RPC_BATCH_REQUESTS {
return Err(RpcCallError::InvalidBatch(format!(
"JSON-RPC batch contains {} requests; maximum is {MAX_RPC_BATCH_REQUESTS}",
calls.len()
)));
}
let mut request_ids = Vec::with_capacity(calls.len());
let mut requests = Vec::with_capacity(calls.len());
let mut response_receivers = Vec::with_capacity(calls.len());
{
let mut pending = self.pending.lock().await;
if self.closed.load(Ordering::Acquire) || *self.disconnected_rx.borrow() {
return Err(RpcCallError::Closed);
}
for RpcBatchCall { method, params } in calls {
let request_id =
RequestId::Integer(self.next_request_id.fetch_add(1, Ordering::SeqCst));
let (response_tx, response_rx) = oneshot::channel();
pending.insert(request_id.clone(), response_tx);
request_ids.push(request_id.clone());
requests.push(JSONRPCMessage::Request(JSONRPCRequest {
id: request_id,
method,
params: Some(params),
trace: None,
}));
response_receivers.push(response_rx);
}
}
if self
.write_tx
.send(JsonRpcWireMessage::Batch(requests))
.await
.is_err()
{
let mut pending = self.pending.lock().await;
for request_id in request_ids {
pending.remove(&request_id);
}
return Err(RpcCallError::Closed);
}
let mut results = Vec::with_capacity(response_receivers.len());
for response_rx in response_receivers {
results.push(response_rx.await.map_err(|_| RpcCallError::Closed)?);
}
Ok(results)
}
#[cfg(test)]
pub(crate) async fn pending_request_count(&self) -> usize {
self.pending.lock().await.len()
+43 -51
View File
@@ -1,6 +1,5 @@
use std::sync::Arc;
use futures::StreamExt;
use tokio::sync::mpsc;
use tracing::debug;
use tracing::warn;
@@ -20,8 +19,6 @@ use crate::server::ExecServerHandler;
use crate::server::registry::build_router;
use crate::server::session_registry::SessionRegistry;
const MAX_RPC_BATCH_CONCURRENCY: usize = 32;
#[derive(Clone)]
pub(crate) struct ConnectionProcessor {
session_registry: Arc<SessionRegistry>,
@@ -182,59 +179,54 @@ async fn run_connection(
continue;
}
let batch = futures::stream::iter(messages)
.map(|message| {
let router = Arc::clone(&router);
let handler = Arc::clone(&handler);
async move {
match message {
codex_app_server_protocol::JSONRPCMessage::Request(request) => {
dispatch_request(router, handler, request).await
}
codex_app_server_protocol::JSONRPCMessage::Notification(_) => {
Some(RpcServerOutboundMessage::Error {
request_id: codex_app_server_protocol::RequestId::Integer(
-1,
),
error: invalid_request(
"notifications cannot be sent in a JSON-RPC batch"
.to_string(),
),
})
}
codex_app_server_protocol::JSONRPCMessage::Response(response) => {
Some(RpcServerOutboundMessage::Error {
request_id: response.id,
error: invalid_request(
"client responses cannot be sent in a JSON-RPC batch"
.to_string(),
),
})
}
codex_app_server_protocol::JSONRPCMessage::Error(error) => {
Some(RpcServerOutboundMessage::Error {
request_id: error.id,
error: invalid_request(
"client errors cannot be sent in a JSON-RPC batch"
.to_string(),
),
})
let mut responses = Vec::new();
for message in messages {
let response = match message {
codex_app_server_protocol::JSONRPCMessage::Request(request) => {
tokio::select! {
response = dispatch_request(
Arc::clone(&router),
Arc::clone(&handler),
request,
) => response,
_ = disconnected_rx.changed() => {
debug!("exec-server transport disconnected while handling batch");
break;
}
}
}
})
.buffered(MAX_RPC_BATCH_CONCURRENCY)
.filter_map(std::future::ready)
.collect::<Vec<_>>();
let messages = tokio::select! {
messages = batch => messages,
_ = disconnected_rx.changed() => {
debug!("exec-server transport disconnected while handling batch");
break;
codex_app_server_protocol::JSONRPCMessage::Notification(_) => {
Some(RpcServerOutboundMessage::Error {
request_id: codex_app_server_protocol::RequestId::Integer(-1),
error: invalid_request(
"notifications cannot be sent in a JSON-RPC batch".to_string(),
),
})
}
codex_app_server_protocol::JSONRPCMessage::Response(response) => {
Some(RpcServerOutboundMessage::Error {
request_id: response.id,
error: invalid_request(
"client responses cannot be sent in a JSON-RPC batch"
.to_string(),
),
})
}
codex_app_server_protocol::JSONRPCMessage::Error(error) => {
Some(RpcServerOutboundMessage::Error {
request_id: error.id,
error: invalid_request(
"client errors cannot be sent in a JSON-RPC batch".to_string(),
),
})
}
};
if let Some(response) = response {
responses.push(response);
}
};
}
if outgoing_tx
.send(RpcServerOutboundMessage::Batch(messages))
.send(RpcServerOutboundMessage::Batch(responses))
.await
.is_err()
{
-1
View File
@@ -14,7 +14,6 @@ codex-utils-absolute-path = { workspace = true }
codex-utils-path-uri = { workspace = true }
futures = { workspace = true }
serde = { workspace = true, features = ["derive"] }
serde_json = { workspace = true }
[lib]
test = false
-25
View File
@@ -56,14 +56,6 @@ pub struct ReadDirectoryEntry {
pub is_file: bool,
}
#[derive(Clone, Debug, PartialEq)]
pub struct ExecutorRpcBatchCall {
pub method: String,
pub params: serde_json::Value,
}
pub type ExecutorRpcBatchResult = FileSystemResult<serde_json::Value>;
#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileSystemSandboxContext {
@@ -271,21 +263,4 @@ pub trait ExecutorFileSystem: Send + Sync {
copy_options: CopyOptions,
sandbox: Option<&'a FileSystemSandboxContext>,
) -> ExecutorFileSystemFuture<'a, ()>;
/// Sends independent executor RPC requests as one batch.
///
/// The executor may execute entries concurrently and does not guarantee execution order.
/// Callers must only batch requests that are safe to run in any order, and must send dependent
/// requests separately. Results are matched back to the input order by request id.
fn execute_rpc_batch<'a>(
&'a self,
_calls: Vec<ExecutorRpcBatchCall>,
) -> ExecutorFileSystemFuture<'a, Vec<ExecutorRpcBatchResult>> {
Box::pin(async move {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"filesystem does not support RPC batching",
))
})
}
}