Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Move relay helpers into exec-server test support (#40712)

Adam Perry @ OpenAI399be2d6b509
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock
index a72f837ac4..dcd85231bd 100644
--- a/codex-rs/Cargo.lock
+++ b/codex-rs/Cargo.lock
@@ -3089,8 +3089,15 @@ dependencies = [
name = "codex-exec-server-test-support"
version = "0.0.0"
dependencies = [
+ "anyhow",
"codex-exec-server",
"codex-http-client",
+ "futures",
+ "prost",
+ "serde_json",
+ "tokio",
+ "tokio-tungstenite",
+ "wiremock",
]
[[package]]
diff --git a/codex-rs/exec-server/BUILD.bazel b/codex-rs/exec-server/BUILD.bazel
index edd3380811..d70b389698 100644
--- a/codex-rs/exec-server/BUILD.bazel
+++ b/codex-rs/exec-server/BUILD.bazel
@@ -1,5 +1,10 @@
load("//:defs.bzl", "codex_rust_crate")
+exports_files(
+ ["src/proto/codex.exec_server.relay.v1.rs"],
+ visibility = ["//codex-rs/exec-server/tests/support:__pkg__"],
+)
+
codex_rust_crate(
name = "exec-server",
crate_name = "codex_exec_server",
diff --git a/codex-rs/exec-server/tests/common/relay.rs b/codex-rs/exec-server/tests/common/relay.rs
index 977b70d1ba..cca0f967a4 100644
--- a/codex-rs/exec-server/tests/common/relay.rs
+++ b/codex-rs/exec-server/tests/common/relay.rs
@@ -1,34 +1,20 @@
-#[path = "../../src/proto/codex.exec_server.relay.v1.rs"]
-mod relay_proto;
-
use std::sync::Arc;
use std::sync::Mutex;
-use std::time::Duration;
use anyhow::Context;
use anyhow::Result;
use codex_api::AuthProvider;
use codex_exec_server::ExecServerClient;
use codex_exec_server::NoiseChannelIdentity;
-use codex_exec_server::NoiseChannelPublicKey;
use codex_exec_server::NoiseRendezvousConnectArgs;
use codex_exec_server::NoiseRendezvousConnectBundle;
use codex_exec_server::RemoteEnvironmentConfig;
use codex_http_client::HttpClientFactory;
use codex_http_client::OutboundProxyPolicy;
-use futures::SinkExt;
-use futures::StreamExt;
use http::HeaderMap;
use http::HeaderValue;
-use prost::Message as ProstMessage;
-use relay_proto::RelayMessageFrame;
-use relay_proto::relay_message_frame;
use tokio::net::TcpListener;
-use tokio::net::TcpStream;
use tokio::time::timeout;
-use tokio_tungstenite::WebSocketStream;
-use tokio_tungstenite::accept_async;
-use tokio_tungstenite::tungstenite::Message;
use tokio_util::task::AbortOnDropHandle;
use wiremock::Mock;
use wiremock::MockServer;
@@ -37,11 +23,16 @@ use wiremock::matchers::header;
use wiremock::matchers::method;
use wiremock::matchers::path;
+pub(crate) use codex_exec_server_test_support::relay::TEST_TIMEOUT;
+pub(crate) use codex_exec_server_test_support::relay::accept_websocket;
+pub(crate) use codex_exec_server_test_support::relay::assert_relay_data_is_encrypted;
+pub(crate) use codex_exec_server_test_support::relay::proxy_relay_frames;
+pub(crate) use codex_exec_server_test_support::relay::registered_executor_public_key;
+
pub(crate) const ENVIRONMENT_ID: &str = "env-noise-relay-test";
pub(crate) const EXECUTOR_REGISTRATION_ID: &str = "registration-1";
pub(crate) const HARNESS_KEY_AUTHORIZATION: &str = "harness-key-authorization";
pub(crate) const REGISTRY_TOKEN: &str = "registry-token";
-pub(crate) const TEST_TIMEOUT: Duration = Duration::from_secs(30);
#[derive(Debug)]
struct StaticRegistryAuthProvider;
@@ -163,92 +154,3 @@ impl RelayConnection {
let _ = self.relay_task.await;
}
}
-
-pub(crate) async fn accept_websocket(
- listener: &TcpListener,
- role: &str,
-) -> Result<WebSocketStream<TcpStream>> {
- let (socket, _peer_addr) = timeout(TEST_TIMEOUT, listener.accept())
- .await
- .with_context(|| format!("remote {role} should connect to fake rendezvous"))??;
- timeout(TEST_TIMEOUT, accept_async(socket))
- .await
- .with_context(|| format!("fake rendezvous should accept {role} websocket"))?
- .map_err(Into::into)
-}
-
-pub(crate) async fn registered_executor_public_key(
- registry: &MockServer,
-) -> Result<NoiseChannelPublicKey> {
- let requests = registry
- .received_requests()
- .await
- .context("wiremock should retain requests")?;
- let request = requests
- .iter()
- .find(|request| request.url.path().ends_with("/register"))
- .context("exec-server should register before connecting")?;
- let body: serde_json::Value = serde_json::from_slice(&request.body)?;
- let key = serde_json::from_value(body["executor_public_key"].clone())?;
- Ok(key)
-}
-
-pub(crate) async fn proxy_relay_frames(
- mut environment: WebSocketStream<TcpStream>,
- mut harness: WebSocketStream<TcpStream>,
- captured_frames: Arc<Mutex<Vec<Vec<u8>>>>,
-) -> Result<()> {
- loop {
- tokio::select! {
- message = environment.next() => {
- let Some(message) = message else {
- break;
- };
- let message = message?;
- capture_binary_frame(&captured_frames, &message);
- harness.send(message).await?;
- }
- message = harness.next() => {
- let Some(message) = message else {
- break;
- };
- let message = message?;
- capture_binary_frame(&captured_frames, &message);
- environment.send(message).await?;
- }
- }
- }
- Ok(())
-}
-
-fn capture_binary_frame(captured_frames: &Mutex<Vec<Vec<u8>>>, message: &Message) {
- if let Message::Binary(bytes) = message {
- captured_frames
- .lock()
- .unwrap_or_else(std::sync::PoisonError::into_inner)
- .push(bytes.to_vec());
- }
-}
-
-pub(crate) fn assert_relay_data_is_encrypted(captured_frames: &Mutex<Vec<Vec<u8>>>) -> Result<()> {
- let captured_frames = captured_frames
- .lock()
- .unwrap_or_else(std::sync::PoisonError::into_inner);
- let mut data_frames = 0;
- for encoded in captured_frames.iter() {
- let frame = RelayMessageFrame::decode(encoded.as_slice())?;
- let Some(relay_message_frame::Body::Data(data)) = frame.body else {
- continue;
- };
- data_frames += 1;
- let payload = String::from_utf8_lossy(&data.payload);
- assert!(!payload.contains("initialize"));
- assert!(!payload.contains("process/start"));
- assert!(!payload.contains("noise-relay-test"));
- }
- assert!(
- data_frames >= 4,
- "expected encrypted request and response frames"
- );
- Ok(())
-}
diff --git a/codex-rs/exec-server/tests/support/BUILD.bazel b/codex-rs/exec-server/tests/support/BUILD.bazel
index 8e09d7dafd..6bb55d52be 100644
--- a/codex-rs/exec-server/tests/support/BUILD.bazel
+++ b/codex-rs/exec-server/tests/support/BUILD.bazel
@@ -2,6 +2,7 @@ load("//:defs.bzl", "codex_rust_crate")
codex_rust_crate(
name = "support",
+ compile_data = ["//codex-rs/exec-server:src/proto/codex.exec_server.relay.v1.rs"],
crate_name = "codex_exec_server_test_support",
crate_srcs = glob(["*.rs"]),
)
diff --git a/codex-rs/exec-server/tests/support/Cargo.toml b/codex-rs/exec-server/tests/support/Cargo.toml
index 85ad347b6c..073d4e3411 100644
--- a/codex-rs/exec-server/tests/support/Cargo.toml
+++ b/codex-rs/exec-server/tests/support/Cargo.toml
@@ -13,5 +13,12 @@ doctest = false
workspace = true
[dependencies]
+anyhow = { workspace = true }
codex-exec-server = { workspace = true }
codex-http-client = { workspace = true }
+futures = { workspace = true }
+prost = "0.14.3"
+serde_json = { workspace = true }
+tokio = { workspace = true, features = ["macros", "net", "time"] }
+tokio-tungstenite = { workspace = true }
+wiremock = { workspace = true }
diff --git a/codex-rs/exec-server/tests/support/lib.rs b/codex-rs/exec-server/tests/support/lib.rs
index 5234363564..bc29a2b17c 100644
--- a/codex-rs/exec-server/tests/support/lib.rs
+++ b/codex-rs/exec-server/tests/support/lib.rs
@@ -2,6 +2,8 @@ use codex_exec_server::EnvironmentManager;
use codex_http_client::HttpClientFactory;
use codex_http_client::OutboundProxyPolicy;
+pub mod relay;
+
/// Builds a manager without environments using the legacy outbound HTTP policy.
pub fn environment_manager_without_environments() -> EnvironmentManager {
EnvironmentManager::without_environments(HttpClientFactory::new(
diff --git a/codex-rs/exec-server/tests/support/relay.rs b/codex-rs/exec-server/tests/support/relay.rs
new file mode 100644
index 0000000000..569f15dfb9
--- /dev/null
+++ b/codex-rs/exec-server/tests/support/relay.rs
@@ -0,0 +1,113 @@
+#[path = "../../src/proto/codex.exec_server.relay.v1.rs"]
+mod relay_proto;
+
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::time::Duration;
+
+use anyhow::Context;
+use anyhow::Result;
+use codex_exec_server::NoiseChannelPublicKey;
+use futures::SinkExt;
+use futures::StreamExt;
+use prost::Message as ProstMessage;
+use relay_proto::RelayMessageFrame;
+use relay_proto::relay_message_frame;
+use tokio::net::TcpListener;
+use tokio::net::TcpStream;
+use tokio::time::timeout;
+use tokio_tungstenite::WebSocketStream;
+use tokio_tungstenite::accept_async;
+use tokio_tungstenite::tungstenite::Message;
+use wiremock::MockServer;
+
+pub const TEST_TIMEOUT: Duration = Duration::from_secs(30);
+
+pub async fn accept_websocket(
+ listener: &TcpListener,
+ role: &str,
+) -> Result<WebSocketStream<TcpStream>> {
+ let (socket, _peer_addr) = timeout(TEST_TIMEOUT, listener.accept())
+ .await
+ .with_context(|| format!("remote {role} should connect to fake rendezvous"))??;
+ timeout(TEST_TIMEOUT, accept_async(socket))
+ .await
+ .with_context(|| format!("fake rendezvous should accept {role} websocket"))?
+ .map_err(Into::into)
+}
+
+pub async fn registered_executor_public_key(
+ registry: &MockServer,
+) -> Result<NoiseChannelPublicKey> {
+ let requests = registry
+ .received_requests()
+ .await
+ .context("wiremock should retain requests")?;
+ let request = requests
+ .iter()
+ .find(|request| request.url.path().ends_with("/register"))
+ .context("exec-server should register before connecting")?;
+ let body: serde_json::Value = serde_json::from_slice(&request.body)?;
+ let key = serde_json::from_value(body["executor_public_key"].clone())?;
+ Ok(key)
+}
+
+pub async fn proxy_relay_frames(
+ mut environment: WebSocketStream<TcpStream>,
+ mut harness: WebSocketStream<TcpStream>,
+ captured_frames: Arc<Mutex<Vec<Vec<u8>>>>,
+) -> Result<()> {
+ loop {
+ tokio::select! {
+ message = environment.next() => {
+ let Some(message) = message else {
+ break;
+ };
+ let message = message?;
+ capture_binary_frame(&captured_frames, &message);
+ harness.send(message).await?;
+ }
+ message = harness.next() => {
+ let Some(message) = message else {
+ break;
+ };
+ let message = message?;
+ capture_binary_frame(&captured_frames, &message);
+ environment.send(message).await?;
+ }
+ }
+ }
+ Ok(())
+}
+
+fn capture_binary_frame(captured_frames: &Mutex<Vec<Vec<u8>>>, message: &Message) {
+ if let Message::Binary(bytes) = message {
+ captured_frames
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .push(bytes.to_vec());
+ }
+}
+
+pub fn assert_relay_data_is_encrypted(captured_frames: &Mutex<Vec<Vec<u8>>>) -> Result<()> {
+ let captured_frames = captured_frames
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ let mut data_frames = 0;
+ for encoded in captured_frames.iter() {
+ let frame = RelayMessageFrame::decode(encoded.as_slice())?;
+ let Some(relay_message_frame::Body::Data(data)) = frame.body else {
+ continue;
+ };
+ data_frames += 1;
+ let payload = String::from_utf8_lossy(&data.payload);
+ assert!(!payload.contains("initialize"));
+ assert!(!payload.contains("process/start"));
+ assert!(!payload.contains("noise-relay-test"));
+ }
+ assert!(
+ data_frames >= 4,
+ "expected encrypted request and response frames"
+ );
+ Ok(())
+}