Lightweight coding agent that runs in your terminal
Rust
Extract exec-server request dispatching (#36440)
Adam Perry @ OpenAIee0247f95a6f
diff --git a/codex-rs/exec-server/src/server.rs b/codex-rs/exec-server/src/server.rsindex ba58b36dc9..3db6b58a4a 100644--- a/codex-rs/exec-server/src/server.rs+++ b/codex-rs/exec-server/src/server.rs@@ -3,6 +3,7 @@ mod handler;mod process_handler;mod processor;mod registry;+mod request_dispatcher;mod session_registry;mod transport;diff --git a/codex-rs/exec-server/src/server/processor.rs b/codex-rs/exec-server/src/server/processor.rsindex 016147e756..72ec510bf3 100644--- a/codex-rs/exec-server/src/server/processor.rs+++ b/codex-rs/exec-server/src/server/processor.rs@@ -1,8 +1,7 @@use std::sync::Arc;-use std::time::Instant;+use codex_exec_server_protocol::JSONRPCMessage;use tokio::sync::mpsc;-use tracing::Instrument;use tracing::debug;use tracing::warn;@@ -10,14 +9,13 @@ use crate::ExecServerRuntimePaths;use crate::connection::CHANNEL_CAPACITY;use crate::connection::JsonRpcConnection;use crate::connection::JsonRpcConnectionEvent;-use crate::rpc::RpcCallError;use crate::rpc::RpcNotificationSender;use crate::rpc::RpcServerOutboundMessage;use crate::rpc::encode_server_message;-use crate::rpc::invalid_request;-use crate::rpc::method_not_found;use crate::server::ExecServerHandler;use crate::server::registry::build_router;+use crate::server::request_dispatcher::RequestDispatcher;+use crate::server::request_dispatcher::RequestTaskResult;use crate::server::session_registry::SessionRegistry;use crate::telemetry::ConnectionTransport;use crate::telemetry::ExecServerTelemetry;@@ -90,7 +88,7 @@ async fn run_connection(let JsonRpcConnection {outgoing_tx: json_outgoing_tx,mut incoming_rx,- mut disconnected_rx,+ disconnected_rx,task_handles: connection_tasks,transport: _transport,} = connection;@@ -120,127 +118,32 @@ async fn run_connection(}});+ let mut dispatcher = RequestDispatcher::new(+ router,+ Arc::clone(&handler),+ outgoing_tx.clone(),+ disconnected_rx,+ requests.clone(),+ telemetry,+ );+// Process inbound events sequentially to preserve initialize/initialized ordering.while let Some(event) = incoming_rx.recv().await {if !handler.is_session_attached() {debug!("exec-server connection evicted after session resume");break;}- match event {+ let result = match event {JsonRpcConnectionEvent::MalformedMessage { reason } => {- warn!("ignoring malformed exec-server message: {reason}");- if outgoing_tx- .send(RpcServerOutboundMessage::Error {- request_id: codex_exec_server_protocol::RequestId::Integer(-1),- error: invalid_request(reason),- })- .await- .is_err()- {- break;- }+ dispatcher.handle_malformed_message(reason).await}JsonRpcConnectionEvent::Message(message) => match message {- codex_exec_server_protocol::JSONRPCMessage::Request(request) => {- let request_started_at = Instant::now();- if let Some((method, route)) = router.request_route(request.method.as_str()) {- let request_span = request_span(method, &request);- let message = tokio::select! {- message = route(Arc::clone(&handler), request).instrument(request_span.clone()) => message,- _ = disconnected_rx.changed() => {- request_span.record("result", "disconnected");- telemetry.request_completed(- method,- "disconnected",- request_started_at.elapsed(),- );- debug!("exec-server transport disconnected while handling request");- break;- }- };- let result = request_result(&message);- if let Some(message) = message- && outgoing_tx.send(message).await.is_err()- {- request_span.record("result", "disconnected");- telemetry.request_completed(- method,- "disconnected",- request_started_at.elapsed(),- );- break;- }- request_span.record("result", result);- telemetry.request_completed(method, result, request_started_at.elapsed());- drop(request_span);- } else {- let method = "unknown";- let request_span = request_span(method, &request);- if outgoing_tx- .send(RpcServerOutboundMessage::Error {- request_id: request.id,- error: method_not_found(format!(- "exec-server stub does not implement `{}` yet",- request.method- )),- })- .await- .is_err()- {- request_span.record("result", "disconnected");- telemetry.request_completed(- method,- "disconnected",- request_started_at.elapsed(),- );- break;- }- request_span.record("result", "error");- telemetry.request_completed(method, "error", request_started_at.elapsed());- }- }- codex_exec_server_protocol::JSONRPCMessage::Notification(notification) => {- let Some(route) = router.notification_route(notification.method.as_str())- else {- warn!(- "closing exec-server connection after unexpected notification: {}",- notification.method- );- break;- };- let result = tokio::select! {- result = route(Arc::clone(&handler), notification) => result,- _ = disconnected_rx.changed() => {- debug!(- "exec-server transport disconnected while handling notification"- );- break;- }- };- if let Err(err) = result {- warn!("closing exec-server connection after protocol error: {err}");- break;- }- }- codex_exec_server_protocol::JSONRPCMessage::Response(response) => {- if !requests.complete(response.id.clone(), Ok(response.result)) {- warn!(- "closing exec-server connection after unexpected client response: {:?}",- response.id- );- break;- }- }- codex_exec_server_protocol::JSONRPCMessage::Error(error) => {- if !requests.complete(error.id.clone(), Err(RpcCallError::Server(error.error)))- {- warn!(- "closing exec-server connection after unexpected client error: {:?}",- error.id- );- break;- }+ JSONRPCMessage::Request(request) => dispatcher.dispatch_request(request).await,+ JSONRPCMessage::Notification(notification) => {+ dispatcher.handle_notification(notification).await}+ JSONRPCMessage::Response(response) => dispatcher.handle_response(response),+ JSONRPCMessage::Error(error) => dispatcher.handle_error(error),},JsonRpcConnectionEvent::Disconnected { reason } => {if let Some(reason) = reason {@@ -248,10 +151,14 @@ async fn run_connection(}break;}+ };+ if result == RequestTaskResult::ConnectionClosed {+ break;}}requests.close();+ drop(dispatcher);handler.shutdown().await;drop(handler);drop(requests);@@ -263,38 +170,6 @@ async fn run_connection(let _ = outbound_task.await;}-fn request_span(- span_name: &str,- request: &codex_exec_server_protocol::JSONRPCRequest,-) -> tracing::Span {- let method = request.method.as_str();- let span = tracing::info_span!(- "codex.exec_server.request",- otel.kind = "server",- otel.name = span_name,- method,- result = tracing::field::Empty,- );- if let Some(trace) = &request.trace- && !codex_otel::set_parent_from_w3c_trace_context(&span, trace)- {- warn!(method, "ignoring invalid inbound exec-server trace carrier");- }- span-}--fn request_result(message: &Option<RpcServerOutboundMessage>) -> &'static str {- match message {- Some(RpcServerOutboundMessage::Error { .. }) => "error",- Some(- RpcServerOutboundMessage::Request(_)- | RpcServerOutboundMessage::Response { .. }- | RpcServerOutboundMessage::Notification(_),- )- | None => "success",- }-}-#[cfg(test)]mod tests {use std::collections::HashMap;@@ -307,11 +182,6 @@ mod tests {use codex_exec_server_protocol::JSONRPCResponse;use codex_exec_server_protocol::RequestId;use codex_utils_path_uri::PathUri;- use opentelemetry::trace::SpanId;- use opentelemetry::trace::TraceId;- use opentelemetry::trace::TracerProvider as _;- use opentelemetry_sdk::trace::InMemorySpanExporter;- use opentelemetry_sdk::trace::SdkTracerProvider;use pretty_assertions::assert_eq;use serde::Serialize;use serde::de::DeserializeOwned;@@ -323,10 +193,7 @@ mod tests {use tokio::io::duplex;use tokio::task::JoinHandle;use tokio::time::timeout;- use tracing_subscriber::filter::filter_fn;- use tracing_subscriber::prelude::*;- use super::request_span;use super::run_connection;use crate::ExecServerRuntimePaths;use crate::ProcessId;@@ -350,57 +217,6 @@ mod tests {use crate::protocol::TerminateResponse;use crate::server::session_registry::SessionRegistry;- #[test]- fn request_span_uses_bounded_name_wire_method_and_inbound_trace_parent() {- let span_exporter = InMemorySpanExporter::default();- let tracer_provider = SdkTracerProvider::builder()- .with_simple_exporter(span_exporter.clone())- .build();- let tracer = tracer_provider.tracer("exec-server-test");- let subscriber = tracing_subscriber::registry().with(- tracing_opentelemetry::layer()- .with_tracer(tracer)- .with_filter(filter_fn(codex_otel::OtelProvider::trace_export_filter)),- );- let trace_id = TraceId::from_hex("00000000000000000000000000000001").expect("trace id");- let parent_span_id = SpanId::from_hex("0000000000000002").expect("span id");- let trace = codex_protocol::protocol::W3cTraceContext {- traceparent: Some(format!("00-{trace_id}-{parent_span_id}-01")),- tracestate: None,- };-- let method = "custom/method";- tracing::subscriber::with_default(subscriber, || {- tracing::callsite::rebuild_interest_cache();- let request = JSONRPCRequest {- id: RequestId::Integer(1),- method: method.to_string(),- params: None,- trace: Some(trace),- };- let request_span = request_span("unknown", &request);- request_span.in_scope(|| {});- drop(request_span);- });-- tracer_provider.force_flush().expect("flush traces");- let spans = span_exporter.get_finished_spans().expect("span export");- let request_span = spans- .iter()- .find(|span| span.name.as_ref() == "unknown")- .expect("unknown method span");- assert_eq!(- request_span- .attributes- .iter()- .find(|attribute| attribute.key.as_str() == "method")- .map(|attribute| attribute.value.clone()),- Some(opentelemetry::Value::String(method.into()))- );- assert_eq!(request_span.span_context.trace_id(), trace_id);- assert_eq!(request_span.parent_span_id, parent_span_id);- }-#[tokio::test]async fn connection_accepts_pipelined_scalar_requests() {let registry = SessionRegistry::new(crate::ExecServerTelemetry::default());diff --git a/codex-rs/exec-server/src/server/request_dispatcher.rs b/codex-rs/exec-server/src/server/request_dispatcher.rsnew file mode 100644index 0000000000..1d4bcbae37--- /dev/null+++ b/codex-rs/exec-server/src/server/request_dispatcher.rs@@ -0,0 +1,219 @@+use std::sync::Arc;+use std::time::Instant;++use codex_exec_server_protocol::JSONRPCError;+use codex_exec_server_protocol::JSONRPCNotification;+use codex_exec_server_protocol::JSONRPCRequest;+use codex_exec_server_protocol::JSONRPCResponse;+use codex_exec_server_protocol::RequestId;+use tokio::sync::mpsc;+use tokio::sync::watch;+use tracing::Instrument;+use tracing::debug;+use tracing::warn;++use crate::rpc::RpcCallError;+use crate::rpc::RpcRouter;+use crate::rpc::RpcServerOutboundMessage;+use crate::rpc::invalid_request;+use crate::rpc::method_not_found;+use crate::rpc_server_requests::RpcServerRequestSender;+use crate::server::ExecServerHandler;+use crate::telemetry::ExecServerTelemetry;++pub(super) struct RequestDispatcher {+ router: Arc<RpcRouter<ExecServerHandler>>,+ handler: Arc<ExecServerHandler>,+ outgoing_tx: mpsc::Sender<RpcServerOutboundMessage>,+ disconnected_rx: watch::Receiver<bool>,+ requests: RpcServerRequestSender,+ telemetry: ExecServerTelemetry,+}++impl RequestDispatcher {+ pub(super) fn new(+ router: Arc<RpcRouter<ExecServerHandler>>,+ handler: Arc<ExecServerHandler>,+ outgoing_tx: mpsc::Sender<RpcServerOutboundMessage>,+ disconnected_rx: watch::Receiver<bool>,+ requests: RpcServerRequestSender,+ telemetry: ExecServerTelemetry,+ ) -> Self {+ Self {+ router,+ handler,+ outgoing_tx,+ disconnected_rx,+ requests,+ telemetry,+ }+ }++ pub(super) async fn handle_malformed_message(&self, reason: String) -> RequestTaskResult {+ warn!("ignoring malformed exec-server message: {reason}");+ if self+ .outgoing_tx+ .send(RpcServerOutboundMessage::Error {+ request_id: RequestId::Integer(-1),+ error: invalid_request(reason),+ })+ .await+ .is_err()+ {+ return RequestTaskResult::ConnectionClosed;+ }++ RequestTaskResult::Completed+ }++ pub(super) async fn handle_notification(+ &mut self,+ notification: JSONRPCNotification,+ ) -> RequestTaskResult {+ let Some(route) = self.router.notification_route(notification.method.as_str()) else {+ warn!(+ "closing exec-server connection after unexpected notification: {}",+ notification.method+ );+ return RequestTaskResult::ConnectionClosed;+ };+ let result = tokio::select! {+ result = route(Arc::clone(&self.handler), notification) => result,+ _ = self.disconnected_rx.changed() => {+ debug!("exec-server transport disconnected while handling notification");+ return RequestTaskResult::ConnectionClosed;+ }+ };+ if let Err(error) = result {+ warn!("closing exec-server connection after protocol error: {error}");+ return RequestTaskResult::ConnectionClosed;+ }++ RequestTaskResult::Completed+ }++ pub(super) fn handle_response(&self, response: JSONRPCResponse) -> RequestTaskResult {+ if !self+ .requests+ .complete(response.id.clone(), Ok(response.result))+ {+ warn!(+ "closing exec-server connection after unexpected client response: {:?}",+ response.id+ );+ return RequestTaskResult::ConnectionClosed;+ }++ RequestTaskResult::Completed+ }++ pub(super) fn handle_error(&self, error: JSONRPCError) -> RequestTaskResult {+ if !self+ .requests+ .complete(error.id.clone(), Err(RpcCallError::Server(error.error)))+ {+ warn!(+ "closing exec-server connection after unexpected client error: {:?}",+ error.id+ );+ return RequestTaskResult::ConnectionClosed;+ }++ RequestTaskResult::Completed+ }++ pub(super) async fn dispatch_request(&mut self, request: JSONRPCRequest) -> RequestTaskResult {+ let started_at = Instant::now();+ let Some((method, route)) = self.router.request_route(request.method.as_str()) else {+ let method = "unknown";+ let span = request_span(method, &request);+ if self+ .outgoing_tx+ .send(RpcServerOutboundMessage::Error {+ request_id: request.id,+ error: method_not_found(format!(+ "exec-server stub does not implement `{}` yet",+ request.method+ )),+ })+ .await+ .is_err()+ {+ span.record("result", "disconnected");+ self.telemetry+ .request_completed(method, "disconnected", started_at.elapsed());+ return RequestTaskResult::ConnectionClosed;+ }+ span.record("result", "error");+ self.telemetry+ .request_completed(method, "error", started_at.elapsed());+ return RequestTaskResult::Completed;+ };++ let span = request_span(method, &request);+ let message = tokio::select! {+ message = route(Arc::clone(&self.handler), request).instrument(span.clone()) => message,+ _ = self.disconnected_rx.changed() => {+ span.record("result", "disconnected");+ self.telemetry+ .request_completed(method, "disconnected", started_at.elapsed());+ debug!("exec-server transport disconnected while handling request");+ return RequestTaskResult::ConnectionClosed;+ }+ };+ let result = request_result(&message);+ if let Some(message) = message+ && self.outgoing_tx.send(message).await.is_err()+ {+ span.record("result", "disconnected");+ self.telemetry+ .request_completed(method, "disconnected", started_at.elapsed());+ return RequestTaskResult::ConnectionClosed;+ }+ span.record("result", result);+ self.telemetry+ .request_completed(method, result, started_at.elapsed());+ drop(span);++ RequestTaskResult::Completed+ }+}++#[derive(Eq, PartialEq)]+pub(super) enum RequestTaskResult {+ Completed,+ ConnectionClosed,+}++fn request_span(span_name: &str, request: &JSONRPCRequest) -> tracing::Span {+ let method = request.method.as_str();+ let span = tracing::info_span!(+ "codex.exec_server.request",+ otel.kind = "server",+ otel.name = span_name,+ method,+ result = tracing::field::Empty,+ );+ if let Some(trace) = &request.trace+ && !codex_otel::set_parent_from_w3c_trace_context(&span, trace)+ {+ warn!(method, "ignoring invalid inbound exec-server trace carrier");+ }+ span+}++fn request_result(message: &Option<RpcServerOutboundMessage>) -> &'static str {+ match message {+ Some(RpcServerOutboundMessage::Error { .. }) => "error",+ Some(+ RpcServerOutboundMessage::Request(_)+ | RpcServerOutboundMessage::Response { .. }+ | RpcServerOutboundMessage::Notification(_),+ )+ | None => "success",+ }+}++#[cfg(test)]+#[path = "request_dispatcher_tests.rs"]+mod tests;diff --git a/codex-rs/exec-server/src/server/request_dispatcher_tests.rs b/codex-rs/exec-server/src/server/request_dispatcher_tests.rsnew file mode 100644index 0000000000..619c6eda9f--- /dev/null+++ b/codex-rs/exec-server/src/server/request_dispatcher_tests.rs@@ -0,0 +1,64 @@+use codex_exec_server_protocol::JSONRPCRequest;+use codex_exec_server_protocol::RequestId;+use opentelemetry::trace::SpanId;+use opentelemetry::trace::TraceId;+use opentelemetry::trace::TracerProvider as _;+use opentelemetry_sdk::trace::InMemorySpanExporter;+use opentelemetry_sdk::trace::SdkTracerProvider;+use pretty_assertions::assert_eq;+use tracing_subscriber::filter::filter_fn;+use tracing_subscriber::prelude::*;++use super::request_span;++/// Request spans retain the wire method and inbound trace while bounding their exported names.+#[test]+fn request_span_uses_bounded_name_wire_method_and_inbound_trace_parent() {+ let span_exporter = InMemorySpanExporter::default();+ let tracer_provider = SdkTracerProvider::builder()+ .with_simple_exporter(span_exporter.clone())+ .build();+ let tracer = tracer_provider.tracer("exec-server-test");+ let subscriber = tracing_subscriber::registry().with(+ tracing_opentelemetry::layer()+ .with_tracer(tracer)+ .with_filter(filter_fn(codex_otel::OtelProvider::trace_export_filter)),+ );+ let trace_id = TraceId::from_hex("00000000000000000000000000000001").expect("trace id");+ let parent_span_id = SpanId::from_hex("0000000000000002").expect("span id");+ let trace = codex_protocol::protocol::W3cTraceContext {+ traceparent: Some(format!("00-{trace_id}-{parent_span_id}-01")),+ tracestate: None,+ };++ let method = "custom/method";+ tracing::subscriber::with_default(subscriber, || {+ tracing::callsite::rebuild_interest_cache();+ let request = JSONRPCRequest {+ id: RequestId::Integer(1),+ method: method.to_string(),+ params: None,+ trace: Some(trace),+ };+ let request_span = request_span("unknown", &request);+ request_span.in_scope(|| {});+ drop(request_span);+ });++ tracer_provider.force_flush().expect("flush traces");+ let spans = span_exporter.get_finished_spans().expect("span export");+ let request_span = spans+ .iter()+ .find(|span| span.name.as_ref() == "unknown")+ .expect("unknown method span");+ assert_eq!(+ request_span+ .attributes+ .iter()+ .find(|attribute| attribute.key.as_str() == "method")+ .map(|attribute| attribute.value.clone()),+ Some(opentelemetry::Value::String(method.into()))+ );+ assert_eq!(request_span.span_context.trace_id(), trace_id);+ assert_eq!(request_span.parent_span_id, parent_span_id);+}diff --git a/codex-rs/exec-server/tests/process.rs b/codex-rs/exec-server/tests/process.rsindex 68409c3018..273c022eaa 100644--- a/codex-rs/exec-server/tests/process.rs+++ b/codex-rs/exec-server/tests/process.rs@@ -2,6 +2,7 @@mod common;+use codex_exec_server::EnvironmentInfo;use codex_exec_server::ExecResponse;use codex_exec_server::InitializeParams;use codex_exec_server::InitializeResponse;@@ -81,6 +82,110 @@ async fn exec_server_starts_process_over_websocket() -> anyhow::Result<()> {Ok(())}+/// Ordinary requests run one at a time when concurrent processing is not enabled.+#[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 initialize_id = server+ .send_request(+ "initialize",+ serde_json::to_value(InitializeParams {+ client_name: "exec-server-test".to_string(),+ resume_session_id: None,+ })?,+ )+ .await?;+ let _ = server+ .wait_for_event(|event| {+ matches!(+ event,+ JSONRPCMessage::Response(JSONRPCResponse { id, .. }) if id == &initialize_id+ )+ })+ .await?;+ server+ .send_notification("initialized", serde_json::json!({}))+ .await?;++ let process_start_id = server+ .send_request(+ "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"],+ "cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,+ "env": {},+ "tty": false,+ "pipeStdin": false,+ "arg0": null+ }),+ )+ .await?;+ let _ = server+ .wait_for_event(|event| {+ matches!(+ event,+ JSONRPCMessage::Response(JSONRPCResponse { id, .. }) if id == &process_start_id+ )+ })+ .await?;++ let read_id = server+ .send_request(+ "process/read",+ serde_json::json!({+ "processId": "proc-serial-read",+ "afterSeq": null,+ "maxBytes": null,+ "waitMs": 250+ }),+ )+ .await?;+ let queued_environment_info_id = server+ .send_request("environment/info", serde_json::json!({}))+ .await?;+ let queued_start_id = server+ .send_request(+ "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"],+ "cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,+ "env": {},+ "tty": false,+ "pipeStdin": false,+ "arg0": null+ }),+ )+ .await?;++ let JSONRPCMessage::Response(JSONRPCResponse { id, .. }) = server.next_event().await? 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 {+ 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 {+ panic!("expected the queued process/start response after process/read");+ };+ assert_eq!(id, queued_start_id);+ assert_eq!(+ serde_json::from_value::<ExecResponse>(result)?,+ ExecResponse {+ process_id: ProcessId::from("proc-serial-queued"),+ sandbox_type: Some(ProcessSandboxType::None),+ }+ );++ server.shutdown().await?;+ Ok(())+}+#[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?;