mirror of
https://github.com/openai/codex.git
synced 2026-11-18 22:20:48 +00:00
Use the local session index in the multi-backend resume picker (#62127)
## Why The resume picker starts local-only listings from the state database. When multiple backends are available, the shared listing mode makes local backends use the default thread store listing too. ## What changed Choose the initial page mode per backend. Local workspaces start with `StateDbOnly`, and remote workspaces use `StoreDefault`. Each backend paginates in its current mode and can fall back to `StoreDefault` independently. Explicit recovery requests keep their requested mode. ## Testing Cover mixed local and remote listings, per-backend fallback and pagination, and an explicit recovery request after fallback fails. GitOrigin-RevId: d0c9284211b86bb781b3df6642660054cb3c6ccf
This commit is contained in:
@@ -954,6 +954,11 @@ fn spawn_app_server_source(backend: AppServerPickerBackend) -> sources::Source {
|
||||
config,
|
||||
} = backend;
|
||||
let backend_id = app_server.backend_id();
|
||||
let initial_mode = if app_server.uses_remote_workspace() {
|
||||
PageLoadMode::StoreDefault
|
||||
} else {
|
||||
PageLoadMode::StateDbOnly
|
||||
};
|
||||
let (bg_tx, events) = mpsc::unbounded_channel();
|
||||
let (request_tx, mut request_rx) = mpsc::unbounded_channel::<PickerLoadRequest>();
|
||||
|
||||
@@ -1098,6 +1103,7 @@ fn spawn_app_server_source(backend: AppServerPickerBackend) -> sources::Source {
|
||||
|
||||
sources::Source {
|
||||
backend_id,
|
||||
initial_mode,
|
||||
loader: Arc::new(move |request: PickerLoadRequest| {
|
||||
let _ = request_tx.send(request);
|
||||
}),
|
||||
|
||||
@@ -26,6 +26,7 @@ fn completion_page(catalog: &catalog::ThreadCatalog, failed: &HashSet<BackendId>
|
||||
|
||||
pub(super) struct Source {
|
||||
pub(super) backend_id: BackendId,
|
||||
pub(super) initial_mode: PageLoadMode,
|
||||
pub(super) loader: PickerLoader,
|
||||
pub(super) events: mpsc::UnboundedReceiver<BackgroundEvent>,
|
||||
pub(super) task: tokio::task::JoinHandle<()>,
|
||||
@@ -42,12 +43,13 @@ pub(super) fn spawn(
|
||||
let mut tasks = Vec::new();
|
||||
for Source {
|
||||
backend_id,
|
||||
initial_mode,
|
||||
loader,
|
||||
events: receiver,
|
||||
task,
|
||||
} in sources
|
||||
{
|
||||
assert!(workers.insert(backend_id, loader).is_none());
|
||||
assert!(workers.insert(backend_id, (loader, initial_mode)).is_none());
|
||||
tasks.push(task);
|
||||
events.push(
|
||||
UnboundedReceiverStream::new(receiver)
|
||||
@@ -77,9 +79,20 @@ pub(super) fn spawn(
|
||||
}
|
||||
let request_token = request.request_token;
|
||||
let mut started = false;
|
||||
for (id, worker) in &workers {
|
||||
for (id, (worker, source_initial_mode)) in &workers {
|
||||
if failed.contains(id) { continue; }
|
||||
if let Some(page) = catalog.begin_page(*id, request.mode) {
|
||||
// A listing starts with listing_token == request_token; recovery
|
||||
// keeps that listing token but allocates a new request token.
|
||||
// Only the first load can use a source's preferred mode.
|
||||
let initial_mode = if request.cursor.is_none()
|
||||
&& request.request_token == request.listing_token
|
||||
&& request.mode == PageLoadMode::StoreDefault
|
||||
{
|
||||
*source_initial_mode
|
||||
} else {
|
||||
request.mode
|
||||
};
|
||||
if let Some(page) = catalog.begin_page(*id, initial_mode) {
|
||||
let mut source_request = request.clone();
|
||||
source_request.cursor = page.cursor.clone();
|
||||
source_request.mode = page.mode;
|
||||
@@ -116,7 +129,7 @@ pub(super) fn spawn(
|
||||
| PickerLoadRequest::Unarchive { backend_id, .. } => *backend_id,
|
||||
PickerLoadRequest::Page(_) => unreachable!(),
|
||||
};
|
||||
if let Some(worker) = workers.get(&backend) {
|
||||
if let Some((worker, _)) = workers.get(&backend) {
|
||||
worker(request);
|
||||
} else {
|
||||
let error = std::io::Error::other("The session's backend is unavailable.");
|
||||
@@ -171,7 +184,7 @@ pub(super) fn spawn(
|
||||
pending_page.page.mode = PageLoadMode::StoreDefault;
|
||||
pending_page.request = fallback.clone();
|
||||
pending.insert(id, pending_page);
|
||||
workers[&id](PickerLoadRequest::Page(fallback));
|
||||
(workers[&id].0)(PickerLoadRequest::Page(fallback));
|
||||
continue;
|
||||
}
|
||||
let mut wait_for_other_source = false;
|
||||
|
||||
@@ -15,6 +15,7 @@ fn source() -> (
|
||||
(
|
||||
Source {
|
||||
backend_id: BackendId::new(),
|
||||
initial_mode: PageLoadMode::StoreDefault,
|
||||
loader: Arc::new(move |request| {
|
||||
let _ = requests.send(request);
|
||||
}),
|
||||
@@ -45,6 +46,19 @@ async fn next(receiver: &mut mpsc::UnboundedReceiver<BackgroundEvent>) -> Backgr
|
||||
.unwrap()
|
||||
.unwrap()
|
||||
}
|
||||
async fn next_page_request(
|
||||
receiver: &mut mpsc::UnboundedReceiver<PickerLoadRequest>,
|
||||
expected: &str,
|
||||
) -> PageLoadRequest {
|
||||
let request = tokio::time::timeout(std::time::Duration::from_secs(2), receiver.recv())
|
||||
.await
|
||||
.unwrap_or_else(|_| panic!("timed out waiting for {expected}"))
|
||||
.unwrap_or_else(|| panic!("worker closed before {expected}"));
|
||||
let PickerLoadRequest::Page(page) = request else {
|
||||
panic!("expected {expected} to be a page request");
|
||||
};
|
||||
page
|
||||
}
|
||||
fn reply(token: usize, thread: ThreadId, cursor: Option<&str>) -> BackgroundEvent {
|
||||
let mut row = make_row("/tmp/worker.jsonl", "2025-01-01T00:00:00Z", "conversation");
|
||||
row.thread_id = Some(thread);
|
||||
@@ -60,6 +74,100 @@ fn reply(token: usize, thread: ThreadId, cursor: Option<&str>) -> BackgroundEven
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mixed_sources_keep_indexed_and_recovery_modes_separate() {
|
||||
let (mut indexed, mut indexed_requests, indexed_events) = source();
|
||||
indexed.initial_mode = PageLoadMode::StateDbOnly;
|
||||
let (mut recovering, mut recovering_requests, recovering_events) = source();
|
||||
recovering.initial_mode = PageLoadMode::StateDbOnly;
|
||||
let (remote, mut remote_requests, remote_events) = source();
|
||||
let (output, mut events) = mpsc::unbounded_channel();
|
||||
let PickerBackground { loader, task } = spawn(vec![indexed, recovering, remote], output);
|
||||
|
||||
loader(request(/*token*/ 1, /*cursor*/ None));
|
||||
for (requests, expected) in [
|
||||
(&mut indexed_requests, PageLoadMode::StateDbOnly),
|
||||
(&mut recovering_requests, PageLoadMode::StateDbOnly),
|
||||
(&mut remote_requests, PageLoadMode::StoreDefault),
|
||||
] {
|
||||
let page = next_page_request(requests, "initial source listing").await;
|
||||
assert_eq!(page.mode, expected);
|
||||
}
|
||||
|
||||
remote_events
|
||||
.send(reply(
|
||||
/*token*/ 1,
|
||||
ThreadId::new(),
|
||||
/*cursor*/ None,
|
||||
))
|
||||
.unwrap();
|
||||
assert!(matches!(
|
||||
next(&mut events).await,
|
||||
BackgroundEvent::PartialPage { .. }
|
||||
));
|
||||
assert!(matches!(
|
||||
next(&mut events).await,
|
||||
BackgroundEvent::Page { .. }
|
||||
));
|
||||
indexed_events
|
||||
.send(reply(
|
||||
/*token*/ 1,
|
||||
ThreadId::new(),
|
||||
Some("indexed-next"),
|
||||
))
|
||||
.unwrap();
|
||||
assert!(matches!(
|
||||
next(&mut events).await,
|
||||
BackgroundEvent::PartialPage { .. }
|
||||
));
|
||||
recovering_events
|
||||
.send(BackgroundEvent::Page {
|
||||
request_token: 1,
|
||||
search_token: None,
|
||||
mode: PageLoadMode::StateDbOnly,
|
||||
page: Err(std::io::Error::other("indexed listing failed")),
|
||||
})
|
||||
.unwrap();
|
||||
let fallback = next_page_request(&mut recovering_requests, "source-specific repair").await;
|
||||
assert_eq!(fallback.mode, PageLoadMode::StoreDefault);
|
||||
recovering_events
|
||||
.send(reply(
|
||||
/*token*/ 1,
|
||||
ThreadId::new(),
|
||||
Some("recovery-next"),
|
||||
))
|
||||
.unwrap();
|
||||
assert!(matches!(
|
||||
next(&mut events).await,
|
||||
BackgroundEvent::PartialPage { .. }
|
||||
));
|
||||
|
||||
loader(request(/*token*/ 2, Some(PageCursor::Catalog)));
|
||||
for (requests, expected_mode, expected_cursor) in [
|
||||
(
|
||||
&mut indexed_requests,
|
||||
PageLoadMode::StateDbOnly,
|
||||
"indexed-next",
|
||||
),
|
||||
(
|
||||
&mut recovering_requests,
|
||||
PageLoadMode::StoreDefault,
|
||||
"recovery-next",
|
||||
),
|
||||
] {
|
||||
let page = next_page_request(requests, "continuation page").await;
|
||||
assert_eq!(page.mode, expected_mode);
|
||||
assert!(
|
||||
matches!(page.cursor, Some(PageCursor::AppServer(cursor)) if cursor == expected_cursor)
|
||||
);
|
||||
}
|
||||
assert!(remote_requests.try_recv().is_err());
|
||||
|
||||
drop(loader);
|
||||
task.await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sources_stream_rows_and_route_actions_to_each_source() {
|
||||
let (first, mut first_requests, first_events) = source();
|
||||
@@ -329,7 +437,8 @@ async fn late_source_failure_finishes_catalog_progress() {
|
||||
|
||||
#[tokio::test]
|
||||
async fn single_source_initial_failure_preserves_fallback_error() {
|
||||
let (source, mut requests, replies) = source();
|
||||
let (mut source, mut requests, replies) = source();
|
||||
source.initial_mode = PageLoadMode::StateDbOnly;
|
||||
let (output, mut events) = mpsc::unbounded_channel();
|
||||
let PickerBackground { loader, task } = spawn(vec![source], output);
|
||||
let PickerLoadRequest::Page(mut initial) = request(/*token*/ 1, /*cursor*/ None) else {
|
||||
@@ -337,9 +446,7 @@ async fn single_source_initial_failure_preserves_fallback_error() {
|
||||
};
|
||||
initial.mode = PageLoadMode::StateDbOnly;
|
||||
loader(PickerLoadRequest::Page(initial));
|
||||
let Some(PickerLoadRequest::Page(initial)) = requests.recv().await else {
|
||||
panic!("expected initial listing")
|
||||
};
|
||||
let initial = next_page_request(&mut requests, "initial listing").await;
|
||||
assert_eq!(initial.mode, PageLoadMode::StateDbOnly);
|
||||
replies
|
||||
.send(BackgroundEvent::Page {
|
||||
@@ -349,9 +456,7 @@ async fn single_source_initial_failure_preserves_fallback_error() {
|
||||
page: Err(std::io::Error::other("indexed listing failed")),
|
||||
})
|
||||
.unwrap();
|
||||
let Some(PickerLoadRequest::Page(fallback)) = requests.recv().await else {
|
||||
panic!("expected store fallback")
|
||||
};
|
||||
let fallback = next_page_request(&mut requests, "store fallback").await;
|
||||
assert_eq!(fallback.mode, PageLoadMode::StoreDefault);
|
||||
replies
|
||||
.send(BackgroundEvent::Page {
|
||||
@@ -375,6 +480,14 @@ async fn single_source_initial_failure_preserves_fallback_error() {
|
||||
};
|
||||
assert_eq!(mode, PageLoadMode::StoreDefault);
|
||||
assert_eq!(err.to_string(), "store listing failed");
|
||||
|
||||
let PickerLoadRequest::Page(mut recovery) = request(/*token*/ 2, /*cursor*/ None) else {
|
||||
unreachable!()
|
||||
};
|
||||
recovery.listing_token = 1;
|
||||
loader(PickerLoadRequest::Page(recovery));
|
||||
let recovery = next_page_request(&mut requests, "explicit recovery request").await;
|
||||
assert_eq!(recovery.mode, PageLoadMode::StoreDefault);
|
||||
drop(loader);
|
||||
task.await.unwrap();
|
||||
}
|
||||
@@ -499,6 +612,7 @@ async fn detached_picker_cleanup_drains_accepted_mutations() {
|
||||
});
|
||||
let source = Source {
|
||||
backend_id,
|
||||
initial_mode: PageLoadMode::StoreDefault,
|
||||
loader: Arc::new(move |request| {
|
||||
let _ = requests.send(request);
|
||||
}),
|
||||
|
||||
Reference in New Issue
Block a user