The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(host): don't block the event loop while a closing project shuts down (#1419)
l0ng-ai77f86616c05d
diff --git a/crates/ide-host/src/lib.rs b/crates/ide-host/src/lib.rsindex eb3d08f67..2685d7bf1 100644--- a/crates/ide-host/src/lib.rs+++ b/crates/ide-host/src/lib.rs@@ -84,8 +84,13 @@ pub struct Host {pub(crate) external_logs: RwLock<HashMap<String, Vec<Arc<ide_vcs::Repo>>>>,requests: requests::Requests,project_requests: RwLock<HashMap<String, Vec<RequestId>>>,+ /// Shutdowns of projects closed with [`Host::close_project_detached`].+ closing: parking_lot::Mutex<Vec<std::thread::JoinHandle<()>>>,}+/// How long exit waits for project shutdown before giving up.+const EXIT_SHUTDOWN_WAIT: std::time::Duration = std::time::Duration::from_secs(10);+impl Host {pub fn new(config: HostConfig) -> Self {let HostConfig {@@ -129,6 +134,7 @@ impl Host {external_logs: RwLock::default(),requests: Default::default(),project_requests: RwLock::default(),+ closing: Default::default(),};host.apply_proxy();host@@ -182,46 +188,69 @@ impl Host {}}+ /// Closes `window`'s project and waits until its language servers, kernels and+ /// debug sessions have shut down. Never call this on the UI event-loop thread:+ /// the shutdown runs on the async runtime, whose workers may themselves be+ /// waiting for the event loop (IPC responses, window queries). Use+ /// [`Self::close_project_detached`] there.pub fn close_project(&self, window: &str) {+ if let Some(shutdown) = self.begin_close(window) {+ self.wait_blocking(shutdown);+ }+ }++ /// Like [`Self::close_project`], but returns once the project is detached from+ /// the window; its workers finish shutting down in the background, and+ /// [`Self::shutdown_notebooks_on_exit`] waits for them before the process exits.+ pub fn close_project_detached(&self, window: &str) {+ if let Some(shutdown) = self.begin_close(window) {+ let mut closing = self.closing.lock();+ closing.retain(|handle| !handle.is_finished());+ closing.push(shutdown);+ }+ }++ /// Detaches the project from `window` and stops what it started, synchronously,+ /// so the window can open another project at once. Returns the thread that+ /// finishes shutting down its workers.+ fn begin_close(&self, window: &str) -> Option<std::thread::JoinHandle<()>> {self.external_logs.write().remove(self.owner_window(window));for request in self.project_requests.write().remove(self.owner_window(window)).unwrap_or_default() {self.cancel_request(request);}- let project = self.projects.write().remove(window);- if let Some(project) = project {- if !project.light {- self.environment.project_closed();- }- if let Some(bridge) = &project.kotlin_bridge {- bridge.stop();- }- project.documents.clear_workspace_edit_history();- project.agents.shutdown();- project.notebooks.stop_admission();- // What the closing window started goes with it — the builds and searches it- // asked for, its runs, its shells and its debug sessions — and the language- // servers finish shutting down before the window is gone, as IDEA closes a- // project's processes.- self.processes.kill_project(&project.root);- self.terminals.kill_key(self.owner_window(window));- self.shutdown_project_workers_blocking(- vec![project.notebooks.clone()],- project.kotlin_bridge.iter().cloned().collect(),- Some(project.lsp.clone()),- Some((self.debugger.clone(), window.to_owned())),- );+ let project = self.projects.write().remove(window)?;+ if !project.light {+ self.environment.project_closed();}+ if let Some(bridge) = &project.kotlin_bridge {+ bridge.stop();+ }+ project.documents.clear_workspace_edit_history();+ project.agents.shutdown();+ project.notebooks.stop_admission();+ // What the closing window started goes with it — the builds and searches it+ // asked for, its runs, its shells and its debug sessions — and its language+ // servers shut down.+ self.processes.kill_project(&project.root);+ self.terminals.kill_key(self.owner_window(window));+ Some(self.spawn_project_shutdown(+ vec![project.notebooks.clone()],+ project.kotlin_bridge.iter().cloned().collect(),+ Some(project.lsp.clone()),+ Some((self.debugger.clone(), window.to_owned())),+ ))}- /// Synchronous project/window destruction must finish owned kernel cleanup,- /// not enqueue work which can be lost as the desktop runtime exits.- fn shutdown_project_workers_blocking(+ /// Project/window destruction must finish owned kernel cleanup, not enqueue+ /// work which can be lost as the desktop runtime exits: the returned thread is+ /// joined by the closer or, for a detached close, before exit.+ fn spawn_project_shutdown(&self,notebooks: Vec<Arc<notebook::NotebookService>>,bridges: Vec<Arc<kotlin_bridge::KotlinBridge>>,lsp: Option<Arc<ide_lsp::LspManager>>,debug: Option<(Arc<ide_dap::DebugManager>, String)>,- ) {+ ) -> std::thread::JoinHandle<()> {for bridge in &bridges {bridge.stop();}@@ -229,25 +258,37 @@ impl Host {service.stop_admission();}let runtime = self.runtime.clone();- let wait = move || {- let worker = std::thread::spawn(move || {- runtime.block_on(async move {- for bridge in bridges {- bridge.shutdown().await;- }- for service in notebooks {- service.shutdown().await;- }- if let Some(lsp) = lsp {- lsp.shutdown_all().await;- }- if let Some((debug, key)) = debug {- debug.stop_key(&key).await;- }- });+ std::thread::spawn(move || {+ runtime.block_on(async move {+ for bridge in bridges {+ bridge.shutdown().await;+ }+ for service in notebooks {+ service.shutdown().await;+ }+ if let Some(lsp) = lsp {+ lsp.shutdown_all().await;+ }+ if let Some((debug, key)) = debug {+ debug.stop_key(&key).await;+ }});- if let Err(error) = worker.join() {- tracing::error!("notebook shutdown thread failed: {error:?}");+ })+ }++ /// Waits for detached closes, so a project opened next never races the+ /// language servers of one still shutting down (e.g. over a shared workspace).+ pub(crate) fn wait_detached_closes(&self) {+ let pending: Vec<_> = self.closing.lock().drain(..).collect();+ for shutdown in pending {+ self.wait_blocking(shutdown);+ }+ }++ fn wait_blocking(&self, shutdown: std::thread::JoinHandle<()>) {+ let wait = move || {+ if let Err(error) = shutdown.join() {+ tracing::error!("project shutdown thread failed: {error:?}");}};if tokio::runtime::Handle::try_current()@@ -259,15 +300,32 @@ impl Host {}}- /// Called before the desktop runtime exits, including update/restart exits.+ /// Called before the desktop runtime exits, including update/restart exits, on+ /// the event-loop thread: waits for detached closes and the open projects'+ /// kernels, but no longer than [`EXIT_SHUTDOWN_WAIT`], so a runtime worker+ /// stuck on the event loop cannot keep the process from exiting.pub fn shutdown_notebooks_on_exit(&self) {let projects = self.projects();- self.shutdown_project_workers_blocking(+ let mut pending: Vec<_> = self.closing.lock().drain(..).collect();+ pending.push(self.spawn_project_shutdown(projects.iter().map(|project| project.notebooks.clone()).collect(),projects.iter().filter_map(|project| project.kotlin_bridge.clone()).collect(),None,None,- );+ ));+ let deadline = std::time::Instant::now() + EXIT_SHUTDOWN_WAIT;+ while pending.iter().any(|handle| !handle.is_finished()) {+ if std::time::Instant::now() >= deadline {+ tracing::warn!("project shutdown did not finish within {EXIT_SHUTDOWN_WAIT:?}; exiting anyway");+ return;+ }+ std::thread::sleep(std::time::Duration::from_millis(20));+ }+ for handle in pending {+ if let Err(error) = handle.join() {+ tracing::error!("project shutdown thread failed: {error:?}");+ }+ }}/// Called before desktop exit, which may bypass document destructors.diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex f946d9a3a..af9ebb4a4 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -88,6 +88,7 @@ impl Host {return Ok(current);}self.close_project(window);+ self.wait_detached_closes();let sink: SharedSink = (self.sink_for)(window);// Before anything the project starts: its children get the project's environment.let trusted = Arc::new(AtomicBool::new(self.trust.trusted(&root)?));@@ -570,6 +571,7 @@ impl Host {return Ok(current);}self.close_project(window);+ self.wait_detached_closes();let sink: SharedSink = (self.sink_for)(window);let settings = Arc::new(SettingsStore::load(&self.config_dir, None));let effective = settings.effective();diff --git a/crates/ide-host/tests/close_project.rs b/crates/ide-host/tests/close_project.rsindex e0b07cd11..3da5acbdc 100644--- a/crates/ide-host/tests/close_project.rs+++ b/crates/ide-host/tests/close_project.rs@@ -5,6 +5,7 @@use ide_core::NullSink;use ide_host::{Host, HostConfig, ops};use std::sync::Arc;+use std::time::{Duration, Instant};fn options(root: &std::path::Path) -> ide_terminal::TerminalOptions {ide_terminal::TerminalOptions {@@ -52,3 +53,53 @@ fn closing_a_project_closes_its_terminals_and_keeps_other_windows() {host.terminals.kill_key("other");});}++/// The desktop closes a project on the event-loop thread while runtime workers may be+/// blocked waiting for that thread (IPC responses, window queries): closing must not+/// wait for workers that need the runtime, and exit still waits for them once free.+#[test]+fn detached_close_returns_while_runtime_workers_wait_for_the_closing_thread() {+ let tmp = tempfile::tempdir().unwrap();+ let root = dunce::canonicalize(tmp.path()).unwrap().join("project");+ std::fs::create_dir_all(&root).unwrap();+ let runtime = tokio::runtime::Builder::new_multi_thread().worker_threads(1).enable_all().build().unwrap();+ let _guard = runtime.enter();+ let host = Arc::new(Host::new(HostConfig {+ config_dir: tmp.path().join("config"),+ data_dir: tmp.path().join("data"),+ local_data_dir: tmp.path().join("data"),+ languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),+ syntax: Arc::default(),+ sink_for: Box::new(|_| Arc::new(NullSink)),+ owner: |w| w,+ runtime: runtime.handle().clone(),+ project_environment: false,+ }));+ host.trust.decide(&root, true, false).unwrap();+ host.open_project("main", &root).unwrap();++ // Occupy the only runtime worker until "the event loop" answers.+ let (started_tx, started_rx) = std::sync::mpsc::channel();+ let (release_tx, release_rx) = std::sync::mpsc::channel::<()>();+ runtime.spawn(async move {+ started_tx.send(()).unwrap();+ let _ = release_rx.recv();+ });+ started_rx.recv().unwrap();++ let (closed_tx, closed_rx) = std::sync::mpsc::channel();+ let closer = host.clone();+ std::thread::spawn(move || {+ closer.close_project_detached("main");+ let _ = closed_tx.send(());+ });+ let returned = closed_rx.recv_timeout(Duration::from_secs(5));+ release_tx.send(()).unwrap();+ assert!(returned.is_ok(), "closing waited for a runtime worker that waits for the closing thread");+ assert!(host.project("main").is_err(), "the window no longer has the project");+ host.open_project("main", &root).expect("the window opens a project once the close has finished");++ let started = Instant::now();+ host.shutdown_notebooks_on_exit();+ assert!(started.elapsed() < Duration::from_secs(5), "exit joined the finished close instead of timing out");+}diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rsindex 34011eb7a..f651c71f9 100644--- a/src-tauri/src/state.rs+++ b/src-tauri/src/state.rs@@ -154,9 +154,11 @@ impl AppState {self.host.open_light(window, file)}+ /// Called on the event-loop thread (window destruction, the `close_project`+ /// command), so it must not wait for the project's workers to shut down.pub fn close_project(&self, window: &str) {self.remote_dev.disconnect(window);- self.host.close_project(window);+ self.host.close_project_detached(window);}}