fix: infinite loop on user-initiated exit

Author: velocitysystems

src/lib.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::sync::atomic::{AtomicU8, Ordering};
 use std::sync::Arc;
 
 use serde::Serialize;
@@ -301,6 +302,9 @@ impl Builder {
             Ok(())
          })
          .on_event(|app, event| {
+            // 0 = not started, 1 = running, 2 = complete
+            static CLEANUP_STATE: AtomicU8 = AtomicU8::new(0);
+
             match event {
                RunEvent::ExitRequested { api, code, .. } => {
                   // Only intercept user-initiated exits (code is None). Programmatic
@@ -310,51 +314,55 @@ impl Builder {
                      return;
                   }
 
+                  // Claim cleanup ownership once. If another handler invocation won
+                  // the race, keep exit prevented while its cleanup finishes.
+                  if CLEANUP_STATE
+                     .compare_exchange(0, 1, Ordering::SeqCst, Ordering::SeqCst)
+                     .is_err()
+                  {
+                     if CLEANUP_STATE.load(Ordering::SeqCst) == 1 {
+                        api.prevent_exit();
+                        debug!("Exit requested while database cleanup is in progress");
+                     }
+                     return;
+                  }
+
                   info!("App exit requested - cleaning up transactions and databases");
 
                   // Prevent immediate exit so we can close connections and checkpoint WAL
                   api.prevent_exit();
 
                   let app_handle = app.clone();
 
-                  let handle = match tokio::runtime::Handle::try_current() {
-                     Ok(h) => h,
-                     Err(_) => {
-                        warn!("No tokio runtime available for cleanup");
-                        app_handle.exit(code.unwrap_or(0));
-                        return;
-                     }
-                  };
-
                   let instances_clone = app.state::<DbInstances>().inner().clone();
                   let interruptible_txs_clone = app.state::<ActiveInterruptibleTransactions>().inner().clone();
                   let regular_txs_clone = app.state::<ActiveRegularTransactions>().inner().clone();
                   let active_subs_clone = app.state::<subscriptions::ActiveSubscriptions>().inner().clone();
 
-                  // Spawn a blocking thread to abort transactions and close databases
-                  // (block_in_place panics on current_thread runtime)
-                  let cleanup_result = std::thread::spawn(move || {
-                     handle.block_on(async {
-                        // First, abort all subscriptions and transactions
-                        debug!("Aborting active subscriptions and transactions");
-                        active_subs_clone.abort_all().await;
-                        sqlx_sqlite_toolkit::cleanup_all_transactions(&interruptible_txs_clone, &regular_txs_clone).await;
-
-                        // Close databases (each wrapper's close() disables its own
-                        // observer at the crate level, unregistering SQLite hooks)
-                        let mut guard = instances_clone.inner.write().await;
-                        let wrappers: Vec<DatabaseWrapper> =
-                           guard.drain().map(|(_, v)| v).collect();
-
-                        // Close databases in parallel with timeout
-                        let mut set = tokio::task::JoinSet::new();
-                        for wrapper in wrappers {
-                           set.spawn(async move { wrapper.close().await });
-                        }
-
+                  // Run cleanup on the async runtime (without blocking the event loop),
+                  // then trigger a programmatic exit when done.
+                  tauri::async_runtime::spawn(async move {
+                     {
                         let timeout_result = tokio::time::timeout(
                            std::time::Duration::from_secs(5),
                            async {
+                              // First, abort all subscriptions and transactions
+                              debug!("Aborting active subscriptions and transactions");
+                              active_subs_clone.abort_all().await;
+                              sqlx_sqlite_toolkit::cleanup_all_transactions(&interruptible_txs_clone, &regular_txs_clone).await;
+
+                              // Close databases (each wrapper's close() disables its own
+                              // observer at the crate level, unregistering SQLite hooks)
+                              let mut guard = instances_clone.inner.write().await;
+                              let wrappers: Vec<DatabaseWrapper> =
+                                 guard.drain().map(|(_, v)| v).collect();
+
+                              // Close databases in parallel
+                              let mut set = tokio::task::JoinSet::new();
+                              for wrapper in wrappers {
+                                 set.spawn(async move { wrapper.close().await });
+                              }
+
                               while let Some(result) = set.join_next().await {
                                  match result {
                                     Ok(Err(e)) => warn!("Error closing database: {:?}", e),
@@ -371,15 +379,15 @@ impl Builder {
                         } else {
                            debug!("Database cleanup complete");
                         }
-                     })
-                  })
-                  .join();
-
-                  if let Err(e) = cleanup_result {
-                     error!("Database cleanup thread panicked: {:?}", e);
-                  }
+                     }
 
-                  app_handle.exit(code.unwrap_or(0));
+                     // Mark cleanup complete before triggering programmatic exit.
+                     // Follow-up ExitRequested events won't rerun cleanup because:
+                     // - Programmatic shutdown requests bypass the user-exit cleanup path
+                     // - Cleanup can only be started once per process lifetime
+                     CLEANUP_STATE.store(2, Ordering::SeqCst);
+                     app_handle.exit(0);
+                  });
                }
                RunEvent::Exit => {
                   // ExitRequested should have already closed all databases