mirror of
https://github.com/openai/codex.git
synced 2026-11-17 22:10:37 +00:00
Simplify exec-server RPC batching
This commit is contained in:
Generated
-1
@@ -3049,7 +3049,6 @@ dependencies = [
|
||||
"codex-utils-path-uri",
|
||||
"futures",
|
||||
"serde",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
||||
@@ -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),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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(¶ms.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(¶ms.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(
|
||||
¶ms.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(¶ms.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(¶ms.path, params.sandbox.as_ref())
|
||||
.await?,
|
||||
})
|
||||
}
|
||||
FS_READ_DIRECTORY_METHOD => {
|
||||
let params: FsReadDirectoryParams = decode_rpc_params(call.params)?;
|
||||
let entries = self
|
||||
.read_directory(¶ms.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(
|
||||
¶ms.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(
|
||||
¶ms.source_path,
|
||||
¶ms.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(
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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()
|
||||
{
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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",
|
||||
))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user