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:
Charlie Marsh
2026-11-17 23:18:54 +00:00
committed by copyberry
parent 7d7af7b903
commit ea6b64fd12
3 changed files with 145 additions and 12 deletions
+6
View File
@@ -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);
}),
+18 -5
View File
@@ -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;
+121 -7
View File
@@ -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);
}),