Lightweight coding agent that runs in your terminal
Rust
Move session index I/O off async runtime threads (#49708)
Charlie Marsh4f699cd64227
diff --git a/codex-rs/rollout/src/session_index.rs b/codex-rs/rollout/src/session_index.rsindex 3e3b077ec0..b69b388ed1 100644--- a/codex-rs/rollout/src/session_index.rs+++ b/codex-rs/rollout/src/session_index.rs@@ -5,8 +5,8 @@ use std::io::ErrorKind;use std::io::Write;use std::path::Path;use std::path::PathBuf;+use std::sync::Arc;use std::sync::LazyLock;-use std::sync::Mutex;use std::time::SystemTime;use crate::reverse_jsonl_scanner::ReverseJsonlScanner;@@ -18,7 +18,8 @@ use serde::Deserialize;use serde::Serialize;const SESSION_INDEX_FILE: &str = "session_index.jsonl";-static SESSION_INDEX_LOCK: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));+static SESSION_INDEX_LOCK: LazyLock<Arc<tokio::sync::Mutex<()>>> =+ LazyLock::new(|| Arc::new(tokio::sync::Mutex::new(())));#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]pub struct SessionIndexEntry {@@ -45,28 +46,28 @@ pub async fn append_thread_name(thread_name: name.to_string(),updated_at,};- append_session_index_entry(codex_home, &entry).await+ append_session_index_entry(codex_home, entry).await}/// Append a raw session index entry to `session_index.jsonl`./// Consumers scan from the end to find the newest match.pub async fn append_session_index_entry(codex_home: &Path,- entry: &SessionIndexEntry,+ entry: SessionIndexEntry,) -> std::io::Result<()> {- let _guard = SESSION_INDEX_LOCK- .lock()- .map_err(|err| std::io::Error::other(err.to_string()))?;let path = session_index_path(codex_home);- let mut file = std::fs::OpenOptions::new()- .create(true)- .append(true)- .open(&path)?;- let mut line = serde_json::to_string(entry).map_err(std::io::Error::other)?;- line.push('\n');- file.write_all(line.as_bytes())?;- file.flush()?;- Ok(())+ with_session_index_lock(&SESSION_INDEX_LOCK, move || {+ let mut file = std::fs::OpenOptions::new()+ .create(true)+ .append(true)+ .open(&path)?;+ let mut line = serde_json::to_string(&entry).map_err(std::io::Error::other)?;+ line.push('\n');+ file.write_all(line.as_bytes())?;+ file.flush()?;+ Ok(())+ })+ .await}/// Remove all recorded names for a thread from the session index.@@ -74,33 +75,47 @@ pub async fn remove_thread_name_entries(codex_home: &Path,thread_id: ThreadId,) -> std::io::Result<()> {- let _guard = SESSION_INDEX_LOCK- .lock()- .map_err(|err| std::io::Error::other(err.to_string()))?;let path = session_index_path(codex_home);- let contents = match std::fs::read_to_string(&path) {- Ok(contents) => contents,- Err(err) if err.kind() == ErrorKind::NotFound => return Ok(()),- Err(err) => return Err(err),- };- let mut removed = false;- let mut remaining = String::with_capacity(contents.len());- for line in contents.lines() {- let should_remove = serde_json::from_str::<SessionIndexEntry>(line.trim())- .is_ok_and(|entry| entry.id == thread_id);- if should_remove {- removed = true;- } else {- remaining.push_str(line);- remaining.push('\n');+ with_session_index_lock(&SESSION_INDEX_LOCK, move || {+ let contents = match std::fs::read_to_string(&path) {+ Ok(contents) => contents,+ Err(err) if err.kind() == ErrorKind::NotFound => return Ok(()),+ Err(err) => return Err(err),+ };+ let mut removed = false;+ let mut remaining = String::with_capacity(contents.len());+ for line in contents.lines() {+ let should_remove = serde_json::from_str::<SessionIndexEntry>(line.trim())+ .is_ok_and(|entry| entry.id == thread_id);+ if should_remove {+ removed = true;+ } else {+ remaining.push_str(line);+ remaining.push('\n');+ }}- }- if !removed {- return Ok(());- }- let temp_path = path.with_extension("jsonl.tmp");- std::fs::write(&temp_path, remaining)?;- std::fs::rename(temp_path, path)+ if !removed {+ return Ok(());+ }+ let temp_path = path.with_extension("jsonl.tmp");+ std::fs::write(&temp_path, remaining)?;+ std::fs::rename(temp_path, path)+ })+ .await+}++/// Acquire the ordered index lock before dispatch and retain it through cancelled updates.+async fn with_session_index_lock(+ lock: &Arc<tokio::sync::Mutex<()>>,+ update: impl FnOnce() -> std::io::Result<()> + Send + 'static,+) -> std::io::Result<()> {+ let guard = Arc::clone(lock).lock_owned().await;+ tokio::task::spawn_blocking(move || {+ let _guard = guard;+ update()+ })+ .await+ .map_err(std::io::Error::other)?}/// Find the latest thread name for a thread id, if any.@@ -124,13 +139,15 @@ pub async fn find_thread_names_by_ids(codex_home: &Path,thread_ids: &HashSet<ThreadId>,) -> std::io::Result<HashMap<ThreadId, String>> {- let path = session_index_path(codex_home);- if thread_ids.is_empty() || !path.exists() {+ if thread_ids.is_empty() {return Ok(HashMap::new());}-+ let path = session_index_path(codex_home);let mut remaining_ids = thread_ids.clone();tokio::task::spawn_blocking(move || {+ if !path.exists() {+ return Ok(HashMap::new());+ }let mut scanner = ReverseJsonlScanner::new(File::open(path)?)?;let mut names = HashMap::with_capacity(remaining_ids.len());while let Some(outcome) = scanner.scan_next::<SessionIndexEntry>()? {diff --git a/codex-rs/rollout/src/session_index_tests.rs b/codex-rs/rollout/src/session_index_tests.rsindex c9089cde84..7f101c8c32 100644--- a/codex-rs/rollout/src/session_index_tests.rs+++ b/codex-rs/rollout/src/session_index_tests.rs@@ -447,6 +447,110 @@ async fn find_thread_names_by_ids_skips_unusable_names_and_reads_across_chunks()Ok(())}+#[tokio::test]+async fn removal_preserves_other_names_and_malformed_lines() -> std::io::Result<()> {+ let temp = TempDir::new()?;+ let removed_id = ThreadId::new();+ let kept_id = ThreadId::new();+ append_thread_name(temp.path(), removed_id, "old").await?;+ append_thread_name(temp.path(), removed_id, "new").await?;+ append_thread_name(temp.path(), kept_id, "kept").await?;+ let path = session_index_path(temp.path());+ std::fs::OpenOptions::new()+ .append(true)+ .open(&path)?+ .write_all(b"malformed\n")?;++ remove_thread_name_entries(temp.path(), removed_id).await?;++ assert_eq!(+ find_thread_names_by_ids(temp.path(), &HashSet::from([removed_id, kept_id])).await?,+ HashMap::from([(kept_id, "kept".to_string())]),+ );+ assert!(+ std::fs::read_to_string(path)?+ .lines()+ .any(|line| line == "malformed")+ );+ Ok(())+}++#[tokio::test]+async fn cancelled_index_update_holds_lock_until_worker_finishes() -> std::io::Result<()> {+ let (reached_tx, reached_rx) = tokio::sync::oneshot::channel();+ let (resume_tx, resume_rx) = std::sync::mpsc::channel();+ let update = tokio::spawn(with_session_index_lock(&SESSION_INDEX_LOCK, move || {+ let _ = reached_tx.send(());+ // Dropping the sender on a test failure also releases the blocking worker.+ let _ = resume_rx.recv();+ Ok(())+ }));+ reached_rx.await.unwrap();+ update.abort();+ assert!(update.await.unwrap_err().is_cancelled());++ let lock_is_held = SESSION_INDEX_LOCK.try_lock().is_err();+ resume_tx.send(()).unwrap();+ with_session_index_lock(&SESSION_INDEX_LOCK, || Ok(())).await?;+ assert!(+ lock_is_held,+ "cancellation released the running worker's lock"+ );+ Ok(())+}++#[test]+fn cancelled_queued_index_update_preserves_the_next_write() -> std::io::Result<()> {+ let runtime = tokio::runtime::Builder::new_current_thread()+ .enable_all()+ .max_blocking_threads(1)+ .build()?;+ runtime.block_on(async {+ let home = TempDir::new()?;+ let path = home.path().join("thread-name");+ // A private lock ensures shared-process test runners cannot supply another owner's guard.+ let lock = Arc::new(tokio::sync::Mutex::new(()));++ let (reached_tx, reached_rx) = tokio::sync::oneshot::channel();+ let (resume_tx, resume_rx) = std::sync::mpsc::channel::<()>();+ let blocker = tokio::task::spawn_blocking(move || {+ let _ = reached_tx.send(());+ // Dropping the sender on a failure also lets runtime teardown finish.+ let _ = resume_rx.recv();+ });+ reached_rx.await.unwrap();++ let queued_path = path.clone();+ let mut update = Box::pin(with_session_index_lock(&lock, move || {+ std::fs::write(queued_path, "obsolete")+ }));+ let state = std::future::poll_fn(|cx| {+ std::task::Poll::Ready(std::future::Future::poll(update.as_mut(), cx))+ })+ .await;+ assert!(+ state.is_pending(),+ "the blocking pool should hold the update queued"+ );+ assert!(+ lock.try_lock().is_err(),+ "this update must own the lock before cancellation"+ );+ drop(update);+ let queued_update_holds_lock = lock.try_lock().is_err();++ drop(resume_tx);+ blocker.await.unwrap();+ let next_path = path.clone();+ with_session_index_lock(&lock, move || std::fs::write(next_path, "latest")).await?;+ assert_eq!(+ (queued_update_holds_lock, std::fs::read_to_string(path)?),+ (true, "latest".to_string())+ );+ Ok(())+ })+}+#[test]fn scan_index_finds_latest_match_among_mixed_entries() -> std::io::Result<()> {let temp = TempDir::new()?;