Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Fix hanging during remote project search (#65257)
Kirill Bulatov8323e2327761
diff --git a/crates/project/src/buffer_store.rs b/crates/project/src/buffer_store.rsindex 3f96a1da968..6e3a570a5e1 100644--- a/crates/project/src/buffer_store.rs+++ b/crates/project/src/buffer_store.rs@@ -40,6 +40,8 @@ pub struct BufferStore {path_to_buffer_id: HashMap<ProjectPath, BufferId>,downstream_client: Option<(AnyProtoClient, u64)>,shared_buffers: HashMap<proto::PeerId, HashMap<BufferId, SharedBuffer>>,+ pending_buffer_shares: HashMap<u64, Task<()>>,+ next_buffer_share_id: u64,non_searchable_buffers: HashSet<BufferId>,project_search: RemoteProjectSearchState,}@@ -850,6 +852,8 @@ impl BufferStore {opened_buffers: Default::default(),path_to_buffer_id: Default::default(),shared_buffers: Default::default(),+ pending_buffer_shares: HashMap::default(),+ next_buffer_share_id: 0,loading_buffers: Default::default(),non_searchable_buffers: Default::default(),worktree_store,@@ -877,6 +881,8 @@ impl BufferStore {path_to_buffer_id: Default::default(),loading_buffers: Default::default(),shared_buffers: Default::default(),+ pending_buffer_shares: HashMap::default(),+ next_buffer_share_id: 0,non_searchable_buffers: Default::default(),worktree_store,project_search: Default::default(),@@ -1635,12 +1641,11 @@ impl BufferStore {return Task::ready(Ok(()));};- cx.spawn(async move |this, cx| {- let Some(buffer) = this.read_with(cx, |this, _| this.get(buffer_id))? else {- return anyhow::Ok(());- };-- let operations = buffer.update(cx, |b, cx| b.serialize_ops(None, cx));+ let buffer = buffer.clone();+ let share_id = util::post_inc(&mut self.next_buffer_share_id);+ let (completion_tx, completion_rx) = oneshot::channel();+ let transfer = cx.spawn(async move |buffer_store, cx| {+ let operations = buffer.update(cx, |buffer, cx| buffer.serialize_ops(None, cx));let operations = operations.await;let state = buffer.update(cx, |buffer, cx| buffer.to_proto(cx));@@ -1673,6 +1678,17 @@ impl BufferStore {.await.log_err();}++ completion_tx.send(()).ok();+ buffer_store+ .update(cx, |store, _| {+ store.pending_buffer_shares.remove(&share_id);+ })+ .ok();+ });+ self.pending_buffer_shares.insert(share_id, transfer);+ cx.background_spawn(async move {+ completion_rx.await?;Ok(())})}diff --git a/crates/project/src/project_search.rs b/crates/project/src/project_search.rsindex edb4b0adf59..ed7da579f06 100644--- a/crates/project/src/project_search.rs+++ b/crates/project/src/project_search.rs@@ -11,7 +11,7 @@ use std::{use anyhow::Context;use async_channel::{Receiver, Sender, bounded, unbounded};-use collections::HashSet;+use collections::HashMap;use fs::{Fs, ReadSeek};use futures::FutureExt as _;use futures::{SinkExt, StreamExt, select_biased, stream::FuturesOrdered};@@ -20,6 +20,7 @@ use language::{Buffer, BufferSnapshot, Point};use parking_lot::Mutex;use postage::oneshot;use rpc::{AnyProtoClient, proto};+use text::Rope;use encoding_rs::Encoding;use file_content::{@@ -167,7 +168,7 @@ impl Search {/// Prepares a project search run. The resulting [`SearchResultsHandle`] has to be used to specify whether you're interested in matching buffers/// or full search results.pub fn into_handle(mut self, query: SearchQuery, cx: &mut App) -> SearchResultsHandle {- let mut open_buffers = HashSet::default();+ let mut open_buffers = HashMap::default();let mut unnamed_buffers = Vec::new();let mut entryless_file_buffers = Vec::new();const MAX_CONCURRENT_BUFFER_OPENS: usize = 64;@@ -183,7 +184,7 @@ impl Search {{continue;} else if let Some(entry_id) = buffer.entry_id(cx) {- open_buffers.insert(entry_id);+ open_buffers.insert(entry_id, buffer.as_rope().clone());} else if searches_all_unnamed_buffers {match (&self.kind, buffer.file()) {(SearchKind::Local { .. }, Some(file)) => {@@ -713,7 +714,7 @@ fn path_key_sort_key(struct Worker {query: Arc<SearchQuery>,- open_buffers: Arc<HashSet<ProjectEntryId>>,+ open_buffers: Arc<HashMap<ProjectEntryId, Rope>>,candidates: FindSearchCandidates,/// Ok, we're back in background: run full scan & find all matches in a given buffer snapshot./// Then, when you're done, share them via the channel you were given.@@ -793,7 +794,7 @@ impl Worker {struct RequestHandler<'worker> {query: &'worker SearchQuery,fs: Option<&'worker dyn Fs>,- open_entries: &'worker HashSet<ProjectEntryId>,+ open_entries: &'worker HashMap<ProjectEntryId, Rope>,confirm_contents_will_match_tx: &'worker Sender<MatchingEntry>,}@@ -929,9 +930,15 @@ impl RequestHandler<'_> {}}- if self.open_entries.contains(&entry.id) {- // The buffer is already in memory and that's the version we want to scan;- // hence skip the dilly-dally and look for all matches straight away.+ if let Some(text) = self.open_entries.get(&entry.id) {+ if self+ .query+ .detect(&mut text.bytes_in_range(0..text.len()))+ .await?+ .is_none()+ {+ return Ok(());+ }should_scan_tx.send((ProjectPath {diff --git a/crates/project/tests/integration/project_tests.rs b/crates/project/tests/integration/project_tests.rsindex 5cbbf8e115d..f4642a384b3 100644--- a/crates/project/tests/integration/project_tests.rs+++ b/crates/project/tests/integration/project_tests.rs@@ -11988,6 +11988,27 @@ async fn test_search(cx: &mut gpui::TestAppContext) {(path!("dir/four.rs").to_string(), vec![25..28, 36..39])]));++ assert_eq!(+ search(+ &project,+ SearchQuery::text(+ "THREE",+ false,+ true,+ false,+ Default::default(),+ Default::default(),+ false,+ None,+ )+ .unwrap(),+ cx+ )+ .await+ .unwrap(),+ HashMap::from_iter([(path!("dir/three.rs").to_string(), vec![6..11])])+ );}#[gpui::test]diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rsindex 586d40e7211..bfad457cf8d 100644--- a/crates/remote_server/src/headless_project.rs+++ b/crates/remote_server/src/headless_project.rs@@ -9,7 +9,8 @@ use lsp::LanguageServerId;use extension::ExtensionHostProxy;use extension_host::headless_host::HeadlessExtensionStore;use fs::Fs;-use gpui::{App, AppContext as _, AsyncApp, Context, Entity, PromptLevel, TaskExt};+use futures::{channel::oneshot, stream::StreamExt as _};+use gpui::{App, AppContext as _, AsyncApp, Context, Entity, PromptLevel, Task, TaskExt};use http_client::HttpClient;use language::{Buffer, BufferEvent, LanguageRegistry, proto::serialize_operation};use node_runtime::NodeRuntime;@@ -39,6 +40,7 @@ use smol::process::Child;use settings::{Settings as _, SettingsLocation, initial_server_settings_content};use std::{+ mem,num::NonZeroU64,path::{Path, PathBuf},sync::{@@ -74,6 +76,8 @@ pub struct HeadlessProject {// Local variant is used within LSP store, but that's a separate entity.pub _toolchain_store: Entity<ToolchainStore>,pub kernels: HashMap<String, Child>,+ search_buffer_batches: async_channel::Sender<SearchBufferBatch>,+ _search_buffer_sender: Task<()>,}pub struct HeadlessAppState {@@ -86,6 +90,17 @@ pub struct HeadlessAppState {pub startup_time: Instant,}+const MAX_SEARCH_CANDIDATES_PER_BATCH: usize = 64;+const MAX_UNACKNOWLEDGED_SEARCH_BYTES: usize = 1024 * 1024;++struct SearchBufferBatch {+ buffers: Vec<Entity<Buffer>>,+ handle: u64,+ peer_id: proto::PeerId,+ project_id: u64,+ completion: oneshot::Sender<Result<()>>,+}+impl HeadlessProject {pub fn init(cx: &mut App) {settings::init(cx);@@ -343,6 +358,59 @@ impl HeadlessProject {AgentServerStore::init_headless(&session);ContextServerStore::init_headless(&session);+ let (search_buffer_batches, batches) = async_channel::bounded::<SearchBufferBatch>(1);+ let search_buffer_sender = cx.spawn({+ let buffer_store = buffer_store.clone();+ let client = session.clone();+ async move |_, cx| {+ while let Ok(batch) = batches.recv().await {+ let result = async {+ let mut buffer_ids = Vec::new();+ let mut unacknowledged_bytes = 0;+ for buffer in &batch.buffers {+ if batch.completion.is_canceled() {+ break;+ }+ let (buffer_id, transferred_bytes, transfer) =+ buffer_store.update(cx, |store, cx| {+ let buffer_id = buffer.read(cx).remote_id();+ let transferred_bytes = if store.is_shared(buffer_id, cx) {+ 0+ } else {+ buffer.read(cx).len()+ };+ let transfer = store.create_buffer_for_peer(+ buffer,+ REMOTE_SERVER_PEER_ID,+ cx,+ );+ (buffer_id, transferred_bytes, transfer)+ });+ transfer.await?;+ buffer_ids.push(buffer_id.to_proto());+ unacknowledged_bytes += transferred_bytes;+ if unacknowledged_bytes >= MAX_UNACKNOWLEDGED_SEARCH_BYTES {+ Self::send_search_candidates(+ &client,+ &batch,+ mem::take(&mut buffer_ids),+ )+ .await?;+ unacknowledged_bytes = 0;+ }+ }+ if !buffer_ids.is_empty() {+ Self::send_search_candidates(&client, &batch, buffer_ids).await?;+ }+ anyhow::Ok(())+ }+ .await;++ batch.completion.send(result).ok();+ }+ }+ });+HeadlessProject {next_entry_id: Default::default(),session,@@ -363,6 +431,8 @@ impl HeadlessProject {profiling_collector: gpui::ProfilingCollector::new(startup_time),_toolchain_store: toolchain_store,kernels: Default::default(),+ search_buffer_batches,+ _search_buffer_sender: search_buffer_sender,}}@@ -1128,8 +1198,6 @@ impl HeadlessProject {envelope: TypedEnvelope<proto::FindSearchCandidates>,mut cx: AsyncApp,) -> Result<proto::Ack> {- use futures::stream::StreamExt as _;-let peer_id = envelope.original_sender_id.unwrap_or(envelope.sender_id);let message = envelope.payload;let query = SearchQuery::from_proto(@@ -1140,8 +1208,9 @@ impl HeadlessProject {let project_id = message.project_id;let buffer_store = this.read_with(&cx, |this, _| this.buffer_store.clone());let handle = message.handle;- let _buffer_store = buffer_store.clone();- let client = this.read_with(&cx, |this, _| this.session.clone());+ let client = this.read_with(&cx, |project, _| project.session.clone());+ let search_buffer_batches =+ this.read_with(&cx, |project, _| project.search_buffer_batches.clone());let task = cx.spawn(async move |cx| {let results = this.update(cx, |this, cx| {project::Search::local(@@ -1154,44 +1223,25 @@ impl HeadlessProject {.into_handle(query, cx).matching_buffers(cx)});- let (batcher, batches) =- project::project_search::AdaptiveBatcher::new(cx.background_executor());- let mut new_matches = Box::pin(results.rx);-- let sender_task = cx.background_executor().spawn({- let client = client.clone();- async move {- let mut batches = std::pin::pin!(batches);- while let Some(buffer_ids) = batches.next().await {- client- .request(proto::FindSearchCandidatesChunk {- handle,- peer_id: Some(peer_id),- project_id,- variant: Some(- proto::find_search_candidates_chunk::Variant::Matches(- proto::FindSearchCandidatesMatches { buffer_ids },- ),- ),- })- .await?;- }- anyhow::Ok(())- }- });-- while let Some((buffer, _)) = new_matches.next().await {- let _ = buffer_store- .update(cx, |this, cx| {- this.create_buffer_for_peer(&buffer, REMOTE_SERVER_PEER_ID, cx)+ let mut batches = std::pin::pin!(+ results+ .rx+ .map(|(buffer, _)| buffer)+ .ready_chunks(MAX_SEARCH_CANDIDATES_PER_BATCH)+ );+ while let Some(buffers) = batches.next().await {+ let (completion, completed) = oneshot::channel();+ search_buffer_batches+ .send(SearchBufferBatch {+ buffers,+ handle,+ peer_id,+ project_id,+ completion,})- .await;- let buffer_id = buffer.read_with(cx, |this, _| this.remote_id().to_proto());- batcher.push(buffer_id).await;+ .await?;+ completed.await??;}- batcher.flush().await;-- sender_task.await?;client.request(proto::FindSearchCandidatesChunk {@@ -1205,13 +1255,31 @@ impl HeadlessProject {.await?;anyhow::Ok(())});- _buffer_store.update(&mut cx, |this, _| {- this.register_ongoing_project_search((peer_id, handle), task);+ buffer_store.update(&mut cx, |store, _| {+ store.register_ongoing_project_search((peer_id, handle), task);});Ok(proto::Ack {})}+ async fn send_search_candidates(+ client: &AnyProtoClient,+ batch: &SearchBufferBatch,+ buffer_ids: Vec<u64>,+ ) -> Result<()> {+ client+ .request(proto::FindSearchCandidatesChunk {+ handle: batch.handle,+ peer_id: Some(batch.peer_id),+ project_id: batch.project_id,+ variant: Some(proto::find_search_candidates_chunk::Variant::Matches(+ proto::FindSearchCandidatesMatches { buffer_ids },+ )),+ })+ .await?;+ Ok(())+ }+// Goes from client to host.async fn handle_find_search_candidates_cancel(this: Entity<Self>,@@ -1227,7 +1295,6 @@ impl HeadlessProject {envelope: TypedEnvelope<proto::ListRemoteDirectory>,cx: AsyncApp,) -> Result<proto::ListRemoteDirectoryResponse> {- use smol::stream::StreamExt;let fs = cx.read_entity(&this, |this, _| this.fs.clone());let expanded = PathBuf::from(shellexpand::tilde(&envelope.payload.path).to_string());let check_info = envelopediff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rsindex 3ef8e78748e..9b0deb09df6 100644--- a/crates/remote_server/src/remote_editing_tests.rs+++ b/crates/remote_server/src/remote_editing_tests.rs@@ -20,6 +20,7 @@ use editor::{};use extension::ExtensionHostProxy;use fs::{FakeFs, Fs};+use futures::FutureExt as _;use git::{Oid,repository::{CommitData, GitCommitTemplate, RepoPath, Worktree as GitWorktree},@@ -42,6 +43,7 @@ use node_runtime::NodeRuntime;use project::{CompletionSource, LanguageServerLogType, ProgressToken, Project, ProjectPath,agent_server_store::AgentServerCommand,+ buffer_store::BufferStoreEvent,image_store,lsp_store::log_store::{GlobalLogStore, LanguageServerKind, LanguageServerLogKey, LogKind, LogStore,@@ -66,7 +68,12 @@ use std::{},};use unindent::Unindent as _;-use util::{path, path_list::PathList, paths::PathMatcher, rel_path::rel_path};+use util::{+ path,+ path_list::PathList,+ paths::{PathMatcher, PathStyle},+ rel_path::rel_path,+};#[gpui::test]async fn test_basic_remote_editing(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {@@ -598,6 +605,221 @@ async fn test_remote_project_search(cx: &mut TestAppContext, server_cx: &mut Tes.await;}+#[gpui::test]+async fn test_remote_project_search_backpressure_survives_cancellation(+ cx: &mut TestAppContext,+ server_cx: &mut TestAppContext,+) {+ let fs = FakeFs::new(server_cx.executor());+ let files = (0..4)+ .map(|directory| {+ let files = (0..128)+ .map(|index| (format!("{index:03}.txt"), json!("testing rust-analyzer")))+ .collect::<serde_json::Map<_, _>>();+ (directory.to_string(), serde_json::Value::Object(files))+ })+ .collect::<serde_json::Map<_, _>>();+ fs.insert_tree(path!("/code/project"), serde_json::Value::Object(files))+ .await;+ let (project, headless) = init_test(&fs, cx, server_cx).await;+ project+ .update(cx, |project, cx| {+ project.find_or_create_worktree(path!("/code/project"), true, cx)+ })+ .await+ .expect("remote worktree should open");+ cx.run_until_parked();++ let client = project.read_with(cx, |project, cx| {+ project.remote_client().unwrap().read(cx).proto_client()+ });+ let pause_incoming = client.request(proto::Ping {});+ cx.run_until_parked();+ let received_buffers = Rc::new(RefCell::new(Vec::new()));+ let _subscription = cx.update(|cx| {+ let received_buffers = received_buffers.clone();+ let buffer_store = project.read(cx).buffer_store().clone();+ cx.subscribe(&buffer_store, move |_, event, cx| {+ if let BufferStoreEvent::BufferAdded(buffer) = event {+ received_buffers+ .borrow_mut()+ .push(buffer.read(cx).remote_id());+ }+ })+ });++ let shared_buffers = |cx: &mut TestAppContext| {+ headless.read_with(cx, |headless, cx| {+ let store = headless.buffer_store.read(cx);+ let mut ids = store+ .buffers()+ .filter_map(|buffer| {+ let id = buffer.read(cx).remote_id();+ store.is_shared(id, cx).then_some(id)+ })+ .collect::<Vec<_>>();+ ids.sort();+ ids+ })+ };+ let mut first_batch = None;+ let mut searches = Vec::new();+ for directory in 0..4 {+ let query = SearchQuery::text(+ "testing".to_string(),+ false,+ true,+ false,+ PathMatcher::new([format!("{directory}/**")], PathStyle::local()).unwrap(),+ PathMatcher::default(),+ false,+ None,+ )+ .unwrap();+ searches.push(project.update(cx, |project, cx| project.search(query, cx)));+ cx.run_until_parked();+ let shared = shared_buffers(server_cx);+ if let Some(first_batch) = &first_batch {+ assert_eq!(&shared, first_batch);+ } else {+ assert!(!shared.is_empty());+ assert!(+ shared.len() <= 64,+ "queued {} buffers without an acknowledgement",+ shared.len()+ );+ first_batch = Some(shared);+ }+ if directory >= 2 {+ searches.clear();+ cx.run_until_parked();+ }+ }++ let mut replacement = std::pin::pin!(do_search_and_assert(+ &project,+ "rust-analyzer",+ PathMatcher::new(["3/127.txt"], PathStyle::local()).unwrap(),+ false,+ &[path!("project/3/127.txt")],+ cx.clone(),+ ));+ assert!(replacement.as_mut().now_or_never().is_none());+ cx.run_until_parked();+ let mut expected_buffers = first_batch.unwrap();+ assert_eq!(shared_buffers(server_cx), expected_buffers);+ drop(pause_incoming);+ let buffers = replacement.await;+ expected_buffers.extend(+ buffers+ .iter()+ .map(|buffer| buffer.read_with(cx, |buffer, _| buffer.remote_id())),+ );+ expected_buffers.sort();+ cx.run_until_parked();+ received_buffers.borrow_mut().sort();+ assert_eq!(*received_buffers.borrow(), expected_buffers);+}++#[gpui::test]+async fn test_remote_project_search_limits_unacknowledged_bytes(+ cx: &mut TestAppContext,+ server_cx: &mut TestAppContext,+) {+ let fs = FakeFs::new(server_cx.executor());+ let text = format!("needle{}", "a".repeat(64 * 1024));+ let files = (0..64)+ .map(|index| (format!("{index:03}.txt"), json!(text)))+ .collect::<serde_json::Map<_, _>>();+ fs.insert_tree(path!("/code/project"), serde_json::Value::Object(files))+ .await;+ let (project, headless) = init_test(&fs, cx, server_cx).await;+ project+ .update(cx, |project, cx| {+ project.find_or_create_worktree(path!("/code/project"), true, cx)+ })+ .await+ .expect("remote worktree should open");+ cx.run_until_parked();++ let client = project.read_with(cx, |project, cx| {+ project.remote_client().unwrap().read(cx).proto_client()+ });+ let pause_incoming = client.request(proto::Ping {});+ cx.run_until_parked();+ let expected_paths = (0..64)+ .map(|index| format!("project{}{index:03}.txt", std::path::MAIN_SEPARATOR))+ .collect::<Vec<_>>();+ let expected_paths = expected_paths+ .iter()+ .map(String::as_str)+ .collect::<Vec<_>>();+ let mut search = std::pin::pin!(do_search_and_assert(+ &project,+ "needle",+ PathMatcher::default(),+ false,+ &expected_paths,+ cx.clone(),+ ));+ let shared_bytes = |cx: &mut TestAppContext| {+ headless.read_with(cx, |headless, cx| {+ let store = headless.buffer_store.read(cx);+ store+ .buffers()+ .filter(|buffer| store.is_shared(buffer.read(cx).remote_id(), cx))+ .map(|buffer| buffer.read(cx).len())+ .sum::<usize>()+ })+ };+ assert!(search.as_mut().now_or_never().is_none());+ cx.run_until_parked();+ let first_batch_bytes = shared_bytes(server_cx);+ let pause_second_batch = client.request(proto::Ping {});+ cx.run_until_parked();+ drop(pause_incoming);+ cx.run_until_parked();+ let second_batch_bytes = shared_bytes(server_cx) - first_batch_bytes;+ assert!(+ (text.len()..1024 * 1024 + text.len()).contains(&second_batch_bytes),+ "shared {second_batch_bytes} bytes without an acknowledgement"+ );+ drop(pause_second_batch);+ search.await;+}++#[gpui::test]+async fn test_remote_buffer_transfer_owned_by_buffer_store(+ cx: &mut TestAppContext,+ server_cx: &mut TestAppContext,+) {+ let fs = FakeFs::new(server_cx.executor());+ let (project, headless) = init_test(&fs, cx, server_cx).await;+ let buffer_store = headless.read_with(server_cx, |headless, _| headless.buffer_store.clone());+ let buffer = buffer_store.update(server_cx, |store, cx| {+ store.create_local_buffer("needle", None, false, cx)+ });+ let buffer_id = buffer.read_with(server_cx, |buffer, _| buffer.remote_id());+ buffer.update(server_cx, |buffer, cx| buffer.edit([(6..6, "!")], None, cx));+ let remote_buffer = project.update(cx, |project, cx| {+ project+ .buffer_store()+ .update(cx, |store, cx| store.wait_for_remote_buffer(buffer_id, cx))+ });+ let transfer = buffer_store.update(server_cx, |store, cx| {+ store.create_buffer_for_peer(&buffer, proto::REMOTE_SERVER_PEER_ID, cx)+ });+ drop(transfer);+ server_cx.update(|_| drop(buffer));+ cx.run_until_parked();++ let remote_buffer = remote_buffer+ .now_or_never()+ .expect("the transfer should survive dropping its caller")+ .expect("the transferred buffer should load");+ remote_buffer.read_with(cx, |buffer, _| assert_eq!(buffer.text(), "needle!"));+}+#[gpui::test]async fn test_remote_project_search_single_cpu(cx: &mut TestAppContext,