Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Avoid redundant clones when sending app-server notifications (#55723)

Charlie Marsh57d4fac64adb
diff --git a/codex-rs/app-server/src/outgoing_message.rs b/codex-rs/app-server/src/outgoing_message.rs
index 647481cb3c..92e5a88391 100644
--- a/codex-rs/app-server/src/outgoing_message.rs
+++ b/codex-rs/app-server/src/outgoing_message.rs
@@ -797,12 +797,13 @@ impl OutgoingMessageSender {
}
return;
}
- for connection_id in connection_ids {
+ let messages = std::iter::repeat_n(outgoing_message, connection_ids.len());
+ for (connection_id, message) in connection_ids.iter().zip(messages) {
if let Err(err) = self
.sender
.send(OutgoingEnvelope::ToConnection {
connection_id: *connection_id,
- message: outgoing_message.clone(),
+ message,
write_complete_tx: None,
})
.await
@@ -1365,41 +1366,66 @@ mod tests {
}
}
+ /// Empty target lists broadcast; explicit targets preserve order, payload, and one timestamp.
#[tokio::test]
async fn send_server_notification_to_connections_reuses_timestamp() {
- let (tx, mut rx) = mpsc::channel::<OutgoingEnvelope>(2);
- let outgoing =
- OutgoingMessageSender::new(tx, codex_analytics::AnalyticsEventsClient::disabled());
-
- outgoing
- .send_server_notification_to_connections(
- &[ConnectionId(1), ConnectionId(2)],
- ServerNotification::ConfigWarning(ConfigWarningNotification {
- summary: "test".to_string(),
- details: None,
- path: None,
- range: None,
- }),
- )
- .await;
-
- let timestamps = [
- rx.recv()
- .await
- .expect("first connection should receive notification"),
- rx.recv()
- .await
- .expect("second connection should receive notification"),
- ]
- .map(|envelope| match envelope {
- OutgoingEnvelope::ToConnection {
- message: OutgoingMessage::AppServerNotification(envelope),
- ..
- } => envelope.emitted_at_ms,
- _ => panic!("expected targeted server notification"),
- });
+ for connection_ids in [
+ vec![],
+ vec![ConnectionId(1)],
+ vec![ConnectionId(1), ConnectionId(2)],
+ ] {
+ let (tx, mut rx) = mpsc::channel::<OutgoingEnvelope>(2);
+ let outgoing =
+ OutgoingMessageSender::new(tx, codex_analytics::AnalyticsEventsClient::disabled());
+ let notification = ServerNotification::ConfigWarning(ConfigWarningNotification {
+ summary: "test".to_string(),
+ details: None,
+ path: None,
+ range: None,
+ });
+ let expected = serde_json::to_value(&notification).expect("serialize notification");
- assert_eq!(timestamps[0], timestamps[1]);
+ outgoing
+ .send_server_notification_to_connections(&connection_ids, notification)
+ .await;
+
+ let mut timestamps = Vec::new();
+ for index in 0..connection_ids.len().max(1) {
+ let message = match rx.try_recv().expect("notification should be queued") {
+ OutgoingEnvelope::Broadcast { message } => {
+ assert!(connection_ids.is_empty());
+ message
+ }
+ OutgoingEnvelope::ToConnection {
+ connection_id,
+ message,
+ write_complete_tx,
+ } => {
+ assert_eq!(connection_id, connection_ids[index]);
+ assert!(write_complete_tx.is_none());
+ message
+ }
+ };
+ let OutgoingMessage::AppServerNotification(envelope) = message else {
+ panic!("expected server notification");
+ };
+ assert_eq!(
+ serde_json::to_value(&envelope.notification).unwrap(),
+ expected
+ );
+ timestamps.push(
+ envelope
+ .emitted_at_ms
+ .expect("notification has a timestamp"),
+ );
+ }
+ assert!(
+ timestamps
+ .iter()
+ .all(|timestamp| *timestamp == timestamps[0])
+ );
+ assert!(rx.try_recv().is_err());
+ }
}
#[tokio::test]
diff --git a/codex-rs/app-server/src/transport.rs b/codex-rs/app-server/src/transport.rs
index 98aeeeac84..4aef699835 100644
--- a/codex-rs/app-server/src/transport.rs
+++ b/codex-rs/app-server/src/transport.rs
@@ -230,11 +230,12 @@ pub(crate) async fn route_outgoing_envelope(
})
.collect();
- for connection_id in target_connections {
+ let messages = std::iter::repeat_n(message, target_connections.len());
+ for (connection_id, message) in target_connections.into_iter().zip(messages) {
let _ = send_message_to_connection(
connections,
connection_id,
- message.clone(),
+ message,
/*write_complete_tx*/ None,
)
.await;
diff --git a/codex-rs/app-server/src/transport_tests.rs b/codex-rs/app-server/src/transport_tests.rs
index 5b98f9bbc8..fe591ccbce 100644
--- a/codex-rs/app-server/src/transport_tests.rs
+++ b/codex-rs/app-server/src/transport_tests.rs
@@ -415,6 +415,56 @@ async fn command_execution_request_approval_keeps_additional_permissions_with_ca
);
}
+/// Broadcasts preserve their payload for eligible recipients and skip every other connection.
+/// The empty eligible set must not accidentally send to an uninitialized or opted-out client.
+#[tokio::test]
+async fn broadcast_only_reaches_eligible_connections() {
+ for eligible_count in 0..=2 {
+ let notification = thread_realtime_started_notification();
+ let method = notification.to_string();
+ let message = app_server_notification(notification);
+ let expected = serde_json::to_value(&message).expect("serialize notification");
+ let mut connections = HashMap::new();
+ let mut receivers = Vec::new();
+ let configs = [
+ (false, true, HashSet::new()),
+ (true, false, HashSet::new()),
+ (true, true, HashSet::from([method])),
+ ]
+ .into_iter()
+ .chain((0..eligible_count).map(|_| (true, true, HashSet::new())));
+ for (index, (initialized, experimental_api, opted_out_methods)) in configs.enumerate() {
+ let (writer_tx, writer_rx) = mpsc::channel(1);
+ connections.insert(
+ ConnectionId(index as u64),
+ OutboundConnectionState::new(
+ writer_tx,
+ Arc::new(AtomicBool::new(initialized)),
+ Arc::new(AtomicBool::new(experimental_api)),
+ Arc::new(RwLock::new(opted_out_methods)),
+ /*disconnect_sender*/ None,
+ ),
+ );
+ receivers.push(writer_rx);
+ }
+
+ route_outgoing_envelope(&mut connections, OutgoingEnvelope::Broadcast { message }).await;
+
+ for (index, mut receiver) in receivers.into_iter().enumerate() {
+ if index < 3 {
+ assert!(receiver.try_recv().is_err());
+ } else {
+ let queued = receiver
+ .try_recv()
+ .expect("eligible client receives notification");
+ assert_eq!(serde_json::to_value(&queued.message).unwrap(), expected);
+ assert!(queued.write_complete_tx.is_none());
+ assert!(receiver.try_recv().is_err());
+ }
+ }
+ }
+}
+
#[tokio::test]
async fn broadcast_does_not_block_on_slow_connection() {
let fast_connection_id = ConnectionId(1);