Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(plugins): make plugin uninstall state consistent on failure

jearhe8be259be5fa6
diff --git a/apps/desktop/src/components/plugins/PluginContributionsPanel.vue b/apps/desktop/src/components/plugins/PluginContributionsPanel.vue
index 37e58867e6..e61bfdee1f 100644
--- a/apps/desktop/src/components/plugins/PluginContributionsPanel.vue
+++ b/apps/desktop/src/components/plugins/PluginContributionsPanel.vue
@@ -867,6 +867,10 @@ async function uninstallSelectedPlugin() {
selectFirstProvider();
} catch (cause) {
toast(cause instanceof Error ? cause.message : String(cause), 5000);
+ // A failed uninstall can still have changed the store (the container is renamed out of the
+ // plugin store before its physical delete, for instance), so re-read the installed list
+ // instead of leaving the panel on state it may no longer describe.
+ await refreshAfterBatch();
} finally {
operating.value = false;
}
diff --git a/apps/desktop/src/components/plugins/__tests__/PluginContributionsPanelBatch.spec.ts b/apps/desktop/src/components/plugins/__tests__/PluginContributionsPanelBatch.spec.ts
index 71eb7c0b22..61994220b9 100644
--- a/apps/desktop/src/components/plugins/__tests__/PluginContributionsPanelBatch.spec.ts
+++ b/apps/desktop/src/components/plugins/__tests__/PluginContributionsPanelBatch.spec.ts
@@ -854,3 +854,37 @@ describe("PluginContributionsPanel marketplace sort", () => {
expect(renderedOrder()).toEqual(["a.older", "b.newer"]);
});
});
+
+describe("PluginContributionsPanel single uninstall outcomes", () => {
+ it("re-reads the installed list and notifies listeners when a single uninstall fails", async () => {
+ const changed = vi.fn();
+ window.addEventListener("dbx:plugins-changed", changed);
+ const failure = "The process cannot access the file because it is being used by another process. (os error 32)";
+ mocks.uninstallPlugin.mockRejectedValueOnce(new Error(failure));
+ // The backend kept the plugin installed (the uninstall never committed), and the panel has to
+ // show exactly that instead of the state it guessed before the call.
+ mocks.listPlugins.mockResolvedValueOnce([installed("a"), installed("b", "9.9.9")]);
+
+ try {
+ await state.uninstallSelectedPlugin();
+ } finally {
+ window.removeEventListener("dbx:plugins-changed", changed);
+ }
+
+ expect(mocks.toast).toHaveBeenLastCalledWith(failure, 5000);
+ expect(mocks.listPlugins).toHaveBeenCalledOnce();
+ expect(state.installedPlugins.map((plugin) => `${plugin.manifest.id}@${plugin.manifest.version}`)).toEqual(["[email protected]", "[email protected]"]);
+ expect(changed).toHaveBeenCalledOnce();
+ expect(state.error).toBe("");
+ });
+
+ it("keeps the uninstall failure visible when the follow-up refresh also fails", async () => {
+ mocks.uninstallPlugin.mockRejectedValueOnce(new Error("denied"));
+ mocks.listPlugins.mockRejectedValueOnce(new Error("refresh offline"));
+
+ await state.uninstallSelectedPlugin();
+
+ expect(mocks.toast).toHaveBeenLastCalledWith("denied", 5000);
+ expect(state.error).toBe('pluginPlatform.batchRefreshFailed:{"error":"refresh offline"}');
+ });
+});
diff --git a/crates/dbx-plugin-runtime/src/plugins.rs b/crates/dbx-plugin-runtime/src/plugins.rs
index c58cec4236..40ef3baa2c 100644
--- a/crates/dbx-plugin-runtime/src/plugins.rs
+++ b/crates/dbx-plugin-runtime/src/plugins.rs
@@ -198,6 +198,11 @@ impl PluginRegistry {
let mut plugins = Vec::new();
for entry in entries {
let entry = entry.map_err(|err| err.to_string())?;
+ if entry.file_name() == std::ffi::OsStr::new(installer::PLUGIN_TRASH_DIR) {
+ // Logical uninstall tombstones are not plugin containers: never discover one, not
+ // even while its physical delete is still pending.
+ continue;
+ }
let container_path = entry.path();
if !container_path.is_dir() {
continue;
@@ -292,6 +297,12 @@ impl PluginRegistry {
let plugin =
self.find_driver(driver_id)?.ok_or_else(|| format!("Plugin driver '{driver_id}' is not installed"))?;
ensure_plugin_compatible(&plugin)?;
+ // This is a short-lived, one-shot driver invocation: it starts its own sidecar instead of
+ // going through `PluginHost`, so it is not in `PluginHost::sessions` and needs its own
+ // lease. `begin_operation` matches those semantics (not a connection the user keeps open)
+ // and makes the whole start -> invoke -> shutdown sequence mutually exclusive with an
+ // install, rollback, or uninstall of the same plugin.
+ let _operation = self.lifecycle.begin_operation(&plugin.manifest.id)?;
let env = env.with_plugin_data_dir(&self.plugin_data_dir(&plugin.manifest.id));
let session = PluginSidecarSession::start(plugin, self.app_version.clone(), env).await?;
let result = session.invoke_with_timeout(method, params, Some(driver_id), timeout_duration).await;
@@ -694,6 +705,65 @@ sleep 30
let _ = std::fs::remove_dir_all(root);
}
+ #[tokio::test]
+ async fn driver_invocations_are_gated_by_the_update_lease_for_their_whole_session() {
+ let root = std::env::temp_dir().join(format!("dbx-plugin-driver-lease-test-{}", uuid::Uuid::new_v4()));
+ let plugin_dir = root.join("sample");
+ std::fs::create_dir_all(&plugin_dir).unwrap();
+ std::fs::write(
+ plugin_dir.join("manifest.json"),
+ // External drivers only exist on the legacy manifest shape, which is what
+ // `PluginRegistry::find_driver` resolves.
+ serde_json::json!({
+ "id": "sample",
+ "name": "Sample",
+ "version": "1.0.0",
+ "publisher": "example",
+ "protocol_version": 1,
+ "executable": "plugin.sh",
+ "drivers": [{ "id": "sample-driver", "label": "Sample", "kind": "external", "database_type": "sample" }]
+ })
+ .to_string(),
+ )
+ .unwrap();
+ // Present but never executable: the manifest stays compatible so the invocation gets past
+ // the lease, while starting the sidecar fails immediately and deterministically on every
+ // platform (no exec bit on unix, not a valid image on Windows).
+ std::fs::write(plugin_dir.join("plugin.sh"), "#!/bin/sh\nexit 1\n").unwrap();
+ let registry = PluginRegistry::new_with_app_version(root.clone(), "0.5.67");
+
+ let update = registry.lifecycle().begin_update("sample").unwrap();
+ let refused = registry
+ .invoke_driver_with_env_and_timeout::<serde_json::Value>(
+ "sample-driver",
+ "testConnection",
+ serde_json::json!({}),
+ PluginRuntimeEnv::default(),
+ None,
+ )
+ .await
+ .unwrap_err();
+ assert!(refused.contains("Plugin update is in progress"), "{refused}");
+ drop(update);
+
+ // Once the update released the lease the invocation runs, and because the sidecar cannot
+ // start it must report that instead of the update error: the guard covered the start
+ // attempt and was released on the way out.
+ let failed_start = registry
+ .invoke_driver_with_env_and_timeout::<serde_json::Value>(
+ "sample-driver",
+ "testConnection",
+ serde_json::json!({}),
+ PluginRuntimeEnv::default(),
+ None,
+ )
+ .await
+ .unwrap_err();
+ assert!(!failed_start.contains("Plugin update is in progress"), "{failed_start}");
+ assert!(registry.lifecycle().begin_update("sample").is_ok(), "a failed invocation must not leak its lease");
+ let _ = std::fs::remove_dir_all(root);
+ }
+
#[test]
fn installed_plugin_info_hides_runtime_paths() {
let plugin = InstalledPlugin::new(
diff --git a/crates/dbx-plugin-runtime/src/plugins/host.rs b/crates/dbx-plugin-runtime/src/plugins/host.rs
index 828b96872c..0fe4b6ecbc 100644
--- a/crates/dbx-plugin-runtime/src/plugins/host.rs
+++ b/crates/dbx-plugin-runtime/src/plugins/host.rs
@@ -10,9 +10,9 @@ use tokio::sync::{broadcast, Mutex, RwLock};
use super::{
InstalledPlugin, PluginBinaryMessage, PluginConnectionActionContribution, PluginConnectionCapability,
PluginConnectionProviderContribution, PluginEvent, PluginFormFieldBinding, PluginFormFieldDefinition,
- PluginFormFieldType, PluginRegistry, PluginRuntimeEnv, PluginSessionState, PluginSidecarSession,
- PLUGIN_CONNECTION_ACTION_METHOD, PLUGIN_CONNECTION_CONNECT_METHOD, PLUGIN_CONNECTION_DISCONNECT_METHOD,
- PLUGIN_CONNECTION_TEST_METHOD,
+ PluginFormFieldType, PluginPackageInstaller, PluginRegistry, PluginRuntimeEnv, PluginSessionState,
+ PluginSidecarSession, PluginTrustStore, PLUGIN_CONNECTION_ACTION_METHOD, PLUGIN_CONNECTION_CONNECT_METHOD,
+ PLUGIN_CONNECTION_DISCONNECT_METHOD, PLUGIN_CONNECTION_TEST_METHOD,
};
#[derive(Debug, Clone, Serialize)]
@@ -352,6 +352,25 @@ impl PluginHost {
}
}
+ /// Runtime-aware uninstall. The lifecycle update lease is taken *before* the sidecar is stopped
+ /// and held until the store-level uninstall committed, so nothing can re-activate the plugin
+ /// and re-lock its container between the runtime stop and the filesystem rename. It also keeps
+ /// `PluginHost::sessions` and the plugin store consistent: the session is removed and the
+ /// container gone before the lease is released.
+ ///
+ /// Callers drain the plugin's connection pools and external driver pools first: the lease is
+ /// refused while the plugin still has an active connection or operation.
+ pub async fn uninstall_plugin(&self, plugin_id: &str) -> Result<(), String> {
+ let _update = self.inner.registry.lifecycle.begin_update(plugin_id)?;
+ self.stop(plugin_id).await;
+ let root_dir = self.inner.registry.root_dir().to_path_buf();
+ let app_version = self.inner.registry.app_version().to_string();
+ // Uninstall never validates a package signature, so it must not load the user trust store.
+ let installer = PluginPackageInstaller::with_trust_store(root_dir, app_version, PluginTrustStore::default());
+ let plugin_id = plugin_id.to_string();
+ tokio::task::spawn_blocking(move || installer.uninstall(&plugin_id)).await.map_err(|error| error.to_string())?
+ }
+
async fn running_session(&self, plugin_id: &str) -> Option<Arc<PluginSidecarSession>> {
let session = self.inner.sessions.read().await.get(plugin_id).cloned()?;
(session.status().state == PluginSessionState::Running).then_some(session)
@@ -836,6 +855,43 @@ mod tests {
use crate::models::connection::ConnectionConfig;
use crate::plugins::PluginConnectionProviderContribution;
+ #[tokio::test]
+ async fn uninstall_plugin_holds_one_update_lease_across_the_runtime_and_the_store() {
+ use crate::plugins::installer::PLUGIN_TRASH_DIR;
+ use crate::plugins::{PluginHost, PluginRegistry};
+
+ let temp = tempfile::tempdir().unwrap();
+ let root = temp.path().join("plugins");
+ let plugin_dir = root.join("sample.hello");
+ std::fs::create_dir_all(&plugin_dir).unwrap();
+ std::fs::write(
+ plugin_dir.join("manifest.json"),
+ serde_json::json!({ "id": "sample.hello", "name": "Sample", "version": "1.0.0", "protocol_version": 1 })
+ .to_string(),
+ )
+ .unwrap();
+ let registry = PluginRegistry::new_with_app_version(root.clone(), "0.5.67");
+ let lifecycle = registry.lifecycle();
+ let host = PluginHost::new(registry);
+
+ // An active operation refuses the uninstall before anything is stopped or deleted, so the
+ // caller still sees a complete, discoverable plugin.
+ let operation = lifecycle.begin_operation("sample.hello").unwrap();
+ let refused = host.uninstall_plugin("sample.hello").await.unwrap_err();
+ assert!(refused.contains("active operations"), "{refused}");
+ assert!(plugin_dir.join("manifest.json").is_file(), "a refused uninstall must not touch the container");
+ drop(operation);
+
+ host.uninstall_plugin("sample.hello").await.unwrap();
+ assert!(!plugin_dir.exists());
+ let tombstones = std::fs::read_dir(root.join(PLUGIN_TRASH_DIR)).map(|entries| entries.count()).unwrap_or(0);
+ assert_eq!(tombstones, 0, "a successful uninstall sweeps its tombstone");
+
+ // The lease is released again, and it was scoped to just this plugin.
+ assert!(lifecycle.begin_update("sample.hello").is_ok());
+ assert!(lifecycle.begin_update("sample.other").is_ok());
+ }
+
#[tokio::test]
async fn ui_only_connections_hold_update_guards_but_saved_configs_do_not() {
let root = tempfile::tempdir().unwrap();
diff --git a/crates/dbx-plugin-runtime/src/plugins/installer.rs b/crates/dbx-plugin-runtime/src/plugins/installer.rs
index db41b2b887..abcce1af24 100644
--- a/crates/dbx-plugin-runtime/src/plugins/installer.rs
+++ b/crates/dbx-plugin-runtime/src/plugins/installer.rs
@@ -25,6 +25,10 @@ const MAX_UNCOMPRESSED_BYTES: u64 = 1024 * 1024 * 1024;
const MAX_FILE_BYTES: u64 = 256 * 1024 * 1024;
const MAX_ARCHIVE_ENTRIES: usize = 10_000;
const INSTALL_LOCK_FILE: &str = ".install.lock";
+/// Where a logically uninstalled plugin container waits for its physical delete. The directory is
+/// no plugin container of its own (no manifest, no activations), so installed plugin discovery
+/// skips it, and `validate_plugin_id` rejects a leading dot, so no plugin id can collide with it.
+pub(super) const PLUGIN_TRASH_DIR: &str = ".trash";
const VERSIONS_DIR: &str = "versions";
const ACTIVATIONS_DIR: &str = "activations";
const TRUST_DIR: &str = ".trust";
@@ -409,6 +413,10 @@ impl PluginPackageInstaller {
let lock = open_install_lock(&self.root_dir)?;
lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin store: {error}"))?;
let result = self.install_bytes_locked(package, policy, expectation, source, allow_source_change);
+ if result.is_ok() {
+ // Opportunistic cleanup of tombstones an earlier uninstall could not delete yet.
+ self.sweep_plugin_trash(&TRANSIENT_LOCK_RETRY_DELAYS, |path: &Path| std::fs::remove_dir_all(path));
+ }
let _ = FileExt::unlock(&lock);
result
}
@@ -423,20 +431,81 @@ impl PluginPackageInstaller {
result
}
+ /// Store-level logical uninstall: the official `plugins/<plugin_id>` container is renamed into
+ /// `.trash` (that rename *is* the commit) and only then physically deleted. `remove_dir_all` is
+ /// not atomic, so deleting the container in place could leave a partially deleted tree behind;
+ /// a failed rename instead leaves the container exactly as it was and reports a clean failure.
pub fn uninstall(&self, plugin_id: &str) -> Result<(), String> {
+ self.uninstall_with_ops(
+ plugin_id,
+ &TRANSIENT_LOCK_RETRY_DELAYS,
+ |src: &Path, dst: &Path| std::fs::rename(src, dst),
+ |path: &Path| std::fs::remove_dir_all(path),
+ )
+ }
+
+ /// The uninstall body, parameterised for tests: `delays` is the transient Windows lock retry
+ /// window, and the two filesystem primitives are injected so error 5 / 32 failures can be
+ /// reproduced deterministically on every platform instead of depending on a real scanner.
+ fn uninstall_with_ops(
+ &self,
+ plugin_id: &str,
+ delays: &[Duration],
+ mut rename: impl FnMut(&Path, &Path) -> std::io::Result<()>,
+ mut remove_dir_all: impl FnMut(&Path) -> std::io::Result<()>,
+ ) -> Result<(), String> {
validate_plugin_id(plugin_id)?;
let lock = open_install_lock(&self.root_dir)?;
lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin store: {error}"))?;
- let plugin_dir = self.root_dir.join(plugin_id);
- let result = match std::fs::remove_dir_all(&plugin_dir) {
- Ok(()) => Ok(()),
- Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
- Err(error) => Err(format!("Failed to uninstall plugin '{plugin_id}': {error}")),
- };
+ let result = (|| {
+ let plugin_dir = self.root_dir.join(plugin_id);
+ if plugin_dir.exists() {
+ let trash_dir = self.root_dir.join(PLUGIN_TRASH_DIR);
+ std::fs::create_dir_all(&trash_dir)
+ .map_err(|error| format!("Failed to prepare plugin trash '{}': {error}", trash_dir.display()))?;
+ let tombstone = unique_plugin_tombstone(&trash_dir, plugin_id);
+ // From here on the plugin is uninstalled: the container is out of the store root
+ // and discovery does not see it any more. An antivirus scanner holding a freshly
+ // extracted binary may fail this rename with error 5 / 32, hence the retry, and a
+ // rename that keeps failing leaves the container untouched for a clean failure.
+ retry_transient_lock(delays, || rename(&plugin_dir, &tombstone))
+ .map_err(|error| format!("Failed to uninstall plugin '{plugin_id}': {error}"))?;
+ }
+ self.sweep_plugin_trash(delays, &mut remove_dir_all);
+ Ok(())
+ })();
let _ = FileExt::unlock(&lock);
result
}
+ /// Best-effort physical delete of every `.trash` tombstone: the one the caller just committed
+ /// plus leftovers from an earlier uninstall whose delete failed. Callers hold `.install.lock`,
+ /// every entry in there is already logically uninstalled, and a tombstone that still cannot be
+ /// removed only logs a warning — the plugin is uninstalled either way, and a later install or
+ /// uninstall sweeps it again.
+ fn sweep_plugin_trash(&self, delays: &[Duration], mut remove_dir_all: impl FnMut(&Path) -> std::io::Result<()>) {
+ let trash_dir = self.root_dir.join(PLUGIN_TRASH_DIR);
+ let entries = match std::fs::read_dir(&trash_dir) {
+ Ok(entries) => entries,
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => return,
+ Err(error) => {
+ log::warn!("Failed to scan plugin trash '{}': {error}", trash_dir.display());
+ return;
+ }
+ };
+ for entry in entries.flatten() {
+ let tombstone = entry.path();
+ let removed = retry_transient_lock(delays, || match remove_dir_all(&tombstone) {
+ // Already gone (or not a directory): nothing left to clean up.
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
+ result => result,
+ });
+ if let Err(error) = removed {
+ log::warn!("Failed to remove plugin tombstone '{}': {error}", tombstone.display());
+ }
+ }
+ }
+
/// Recorded provenance of one container's active installation, if any.
pub(super) fn read_container_provenance(container_dir: &Path) -> Result<Option<PluginInstallProvenance>, String> {
Ok(read_latest_activation(container_dir)?.and_then(|record| record.provenance))
@@ -1088,6 +1157,19 @@ fn is_windows_lock_error(error: &std::io::Error) -> bool {
matches!(error.raw_os_error(), Some(5 | 32))
}
+/// Tombstone path for one logical uninstall: `.trash/<plugin id>`, or `.trash/<plugin id>-<n>`, the
+/// same suffix convention `install_bytes_locked` uses for replaced versions, when an earlier
+/// tombstone of that plugin is still waiting for its physical delete.
+fn unique_plugin_tombstone(trash_dir: &Path, plugin_id: &str) -> PathBuf {
+ let mut candidate = trash_dir.join(plugin_id);
+ let mut suffix = 0u32;
+ while candidate.exists() {
+ suffix = suffix.saturating_add(1);
+ candidate = trash_dir.join(format!("{plugin_id}-{suffix}"));
+ }
+ candidate
+}
+
fn make_backend_executable(path: &Option<PathBuf>) -> Result<(), String> {
#[cfg(unix)]
if let Some(path) = path {
@@ -1198,7 +1280,7 @@ fn sync_directory(_path: &Path) -> Result<(), String> {
mod tests {
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Cursor, Write};
- use std::path::Path;
+ use std::path::{Path, PathBuf};
use std::time::Duration;
use base64::Engine;
@@ -1208,8 +1290,8 @@ mod tests {
use super::{
is_activation_record_file, read_install_identity, retry_transient_lock, sha256_hex,
validate_package_expectation, PluginInstallPolicy, PluginPackageExpectation, PluginPackageInstaller,
- PluginSignatureStatus, PluginTrustStore, ACTIVATIONS_DIR, PLUGIN_CHECKSUMS_FILE, PLUGIN_SIGNATURE_FILE,
- VERSIONS_DIR,
+ PluginSignatureStatus, PluginTrustStore, ACTIVATIONS_DIR, INSTALL_LOCK_FILE, PLUGIN_CHECKSUMS_FILE,
+ PLUGIN_SIGNATURE_FILE, PLUGIN_TRASH_DIR, VERSIONS_DIR,
};
use crate::plugins::{PluginManifest, PluginRegistry};
@@ -2093,4 +2175,168 @@ mod tests {
assert_eq!(attempts.load(Ordering::SeqCst), 1);
assert_eq!(result.unwrap_err().raw_os_error(), Some(5));
}
+
+ /// Sorted `.trash` entries, so tombstone assertions are deterministic.
+ fn trash_entries(root: &Path) -> Vec<String> {
+ let mut names = std::fs::read_dir(root.join(PLUGIN_TRASH_DIR))
+ .map(|entries| {
+ entries
+ .filter_map(|entry| entry.ok())
+ .map(|entry| entry.file_name().to_string_lossy().into_owned())
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_default();
+ names.sort();
+ names
+ }
+
+ /// Installs `sample.hello` into a store rooted at `<temp>/plugins`, so `<temp>/plugin-data`
+ /// sits next to it exactly like the real registry layout does.
+ fn uninstall_fixture(temp: &tempfile::TempDir, version: &str) -> (PluginPackageInstaller, PathBuf) {
+ let root = temp.path().join("plugins");
+ let installer = PluginPackageInstaller::with_trust_store(root.clone(), "0.5.67", PluginTrustStore::default());
+ installer.install_bytes(&package(version, None, false), PluginInstallPolicy::LocalDevelopment).unwrap();
+ (installer, root)
+ }
+
+ #[test]
+ fn uninstall_commits_logically_and_sweeps_its_own_tombstone() {
+ let temp = tempfile::tempdir().unwrap();
+ let (installer, root) = uninstall_fixture(&temp, "1.0.0");
+ let plugin_data = temp.path().join("plugin-data").join("sample.hello");
+ std::fs::create_dir_all(&plugin_data).unwrap();
+ std::fs::write(plugin_data.join("preferences.json"), "{}").unwrap();
+ let container = root.join("sample.hello");
+ assert!(container.join(VERSIONS_DIR).join("1.0.0").join("manifest.json").is_file());
+
+ installer.uninstall("sample.hello").unwrap();
+
+ assert!(!container.exists(), "the official container must be gone");
+ assert!(trash_entries(&root).is_empty(), "a successful uninstall sweeps its own tombstone");
+ assert!(root.join(INSTALL_LOCK_FILE).is_file(), "the store lock file stays in place");
+ assert!(plugin_data.join("preferences.json").is_file(), "plugin data survives an uninstall");
+ let registry = PluginRegistry::new_with_app_version(root, "0.5.67");
+ assert!(registry.list_installed().unwrap().is_empty());
+ assert!(registry.find_plugin("sample.hello").unwrap().is_none());
+
+ // Uninstalling a plugin that is already gone stays idempotent.
+ installer.uninstall("sample.hello").unwrap();
+ }
+
+ #[test]
+ #[cfg(windows)]
+ fn uninstall_retries_transient_windows_locks_on_the_commit_rename() {
+ use std::sync::atomic::{AtomicUsize, Ordering};
+
+ let temp = tempfile::tempdir().unwrap();
+ let (installer, root) = uninstall_fixture(&temp, "1.0.0");
+ let attempts = AtomicUsize::new(0);
+ installer
+ .uninstall_with_ops(
+ "sample.hello",
+ &[Duration::ZERO, Duration::ZERO, Duration::ZERO],
+ |src: &Path, dst: &Path| match attempts.fetch_add(1, Ordering::SeqCst) {
+ 0 => Err(std::io::Error::from_raw_os_error(5)),
+ 1 => Err(std::io::Error::from_raw_os_error(32)),
+ _ => std::fs::rename(src, dst),
+ },
+ |path: &Path| std::fs::remove_dir_all(path),
+ )
+ .unwrap();
+
+ assert_eq!(attempts.load(Ordering::SeqCst), 3, "two lock errors then one successful rename");
+ assert!(!root.join("sample.hello").exists());
+ assert!(trash_entries(&root).is_empty());
+ }
+
+ #[test]
+ fn uninstall_reports_a_clean_failure_and_keeps_the_container_when_the_rename_keeps_failing() {
+ use std::sync::atomic::{AtomicUsize, Ordering};
+
+ let temp = tempfile::tempdir().unwrap();
+ let (installer, root) = uninstall_fixture(&temp, "1.0.0");
+ let container = root.join("sample.hello");
+ let attempts = AtomicUsize::new(0);
+ let error = installer
+ .uninstall_with_ops(
+ "sample.hello",
+ &[Duration::ZERO, Duration::ZERO, Duration::ZERO],
+ |_: &Path, _: &Path| {
+ attempts.fetch_add(1, Ordering::SeqCst);
+ Err(std::io::Error::from_raw_os_error(32))
+ },
+ |path: &Path| std::fs::remove_dir_all(path),
+ )
+ .unwrap_err();
+
+ assert!(error.contains("Failed to uninstall plugin 'sample.hello'"), "{error}");
+ assert_eq!(attempts.load(Ordering::SeqCst), if cfg!(windows) { 4 } else { 1 });
+ // A failed logical commit must leave the container exactly as it was: the plugin has to
+ // stay installed, discoverable, and loadable after a restart.
+ assert!(container.join(VERSIONS_DIR).join("1.0.0").join("manifest.json").is_file());
+ assert_eq!(activation_record_count(&container), 1);
+ assert!(trash_entries(&root).is_empty(), "a failed commit must not leave a tombstone behind");
+ let registry = PluginRegistry::new_with_app_version(root, "0.5.67");
+ assert_eq!(registry.list_installed().unwrap().len(), 1);
+ assert_eq!(registry.find_plugin("sample.hello").unwrap().unwrap().manifest.version, "1.0.0");
+ }
+
+ #[test]
+ fn uninstall_stays_a_logical_success_when_the_tombstone_cannot_be_deleted() {
+ let temp = tempfile::tempdir().unwrap();
+ let (installer, root) = uninstall_fixture(&temp, "1.0.0");
+
+ installer
+ .uninstall_with_ops(
+ "sample.hello",
+ &[Duration::ZERO, Duration::ZERO, Duration::ZERO],
+ |src: &Path, dst: &Path| std::fs::rename(src, dst),
+ |_: &Path| Err(std::io::Error::from_raw_os_error(32)),
+ )
+ .unwrap();
+
+ assert!(!root.join("sample.hello").exists());
+ assert_eq!(trash_entries(&root), vec!["sample.hello".to_string()]);
+ let registry = PluginRegistry::new_with_app_version(root, "0.5.67");
+ assert!(registry.list_installed().unwrap().is_empty());
+ assert!(registry.find_plugin("sample.hello").unwrap().is_none());
+ }
+
+ #[test]
+ fn install_and_uninstall_sweep_tombstones_left_by_an_earlier_attempt() {
+ let temp = tempfile::tempdir().unwrap();
+ let (installer, root) = uninstall_fixture(&temp, "1.0.0");
+ let stale = root.join(PLUGIN_TRASH_DIR).join("sample.hello");
+ std::fs::create_dir_all(stale.join(VERSIONS_DIR).join("1.0.0")).unwrap();
+ std::fs::write(stale.join(VERSIONS_DIR).join("1.0.0").join("manifest.json"), "{}").unwrap();
+
+ installer.install_bytes(&package("1.1.0", None, false), PluginInstallPolicy::LocalDevelopment).unwrap();
+ assert!(!stale.exists(), "an install sweeps leftovers of an earlier uninstall");
+
+ std::fs::create_dir_all(&stale).unwrap();
+ std::fs::write(stale.join("leftover.bin"), b"still locked").unwrap();
+ installer.uninstall("sample.hello").unwrap();
+ assert!(!root.join("sample.hello").exists());
+ assert!(!stale.exists(), "an uninstall sweeps old tombstones as well");
+ }
+
+ #[test]
+ fn tombstone_containers_are_never_discovered_as_installed_plugins() {
+ let temp = tempfile::tempdir().unwrap();
+ let (installer, root) = uninstall_fixture(&temp, "1.0.0");
+ let tombstone = root.join(PLUGIN_TRASH_DIR).join("sample.hello");
+ std::fs::create_dir_all(root.join(PLUGIN_TRASH_DIR)).unwrap();
+ std::fs::rename(root.join("sample.hello"), &tombstone).unwrap();
+ // The tombstone still holds a complete container: versions/, activations/, manifest.json.
+ assert!(tombstone.join(VERSIONS_DIR).join("1.0.0").join("manifest.json").is_file());
+ assert_eq!(activation_record_count(&tombstone), 1);
+
+ let registry = PluginRegistry::new_with_app_version(root.clone(), "0.5.67");
+ assert!(registry.list_installed().unwrap().is_empty());
+ assert!(registry.find_plugin("sample.hello").unwrap().is_none());
+
+ // The store stays usable: a reinstall does not collide with the pending tombstone.
+ installer.install_bytes(&package("1.0.0", None, false), PluginInstallPolicy::LocalDevelopment).unwrap();
+ assert_eq!(registry.list_installed().unwrap().len(), 1);
+ }
}
diff --git a/crates/dbx-web/src/routes/plugins.rs b/crates/dbx-web/src/routes/plugins.rs
index 0f55898afc..91ed7ff655 100644
--- a/crates/dbx-web/src/routes/plugins.rs
+++ b/crates/dbx-web/src/routes/plugins.rs
@@ -353,22 +353,15 @@ pub async fn uninstall_plugin(
}
let plugin = state.app.plugins.find_plugin(&request.plugin_id).map_err(AppError::from)?;
state.app.remove_plugin_connection_pools(&request.plugin_id).await;
- state.app.plugin_host.stop(&request.plugin_id).await;
if let Some(plugin) = &plugin {
stop_external_driver_pools(&state, plugin).await;
}
- let root_dir = state.app.plugins.root_dir().to_path_buf();
- let app_version = state.app.plugins.app_version().to_string();
- let plugin_id = request.plugin_id.clone();
- tokio::task::spawn_blocking(move || {
- PluginPackageInstaller::new(root_dir, app_version)?.uninstall(&request.plugin_id)
- })
- .await
- .map_err(|error| AppError::internal(error.to_string()))?
- .map_err(AppError::bad_request)?;
+ // Stops the runtime and uninstalls the store under one lifecycle update lease, so a plugin
+ // call cannot re-activate the sidecar (and re-lock its container) in between.
+ state.app.plugin_host.uninstall_plugin(&request.plugin_id).await.map_err(AppError::bad_request)?;
// A reinstall must ask for AI tool access and data grants again.
- if let Err(error) = state.app.storage.forget_plugin_permissions(&plugin_id).await {
- log::warn!("Failed to clear permissions of uninstalled plugin {plugin_id}: {error}");
+ if let Err(error) = state.app.storage.forget_plugin_permissions(&request.plugin_id).await {
+ log::warn!("Failed to clear permissions of uninstalled plugin {}: {error}", request.plugin_id);
}
list_plugins(State(state)).await
}
diff --git a/src-tauri/src/commands/plugins.rs b/src-tauri/src/commands/plugins.rs
index 041e78de56..b64a2e1cdc 100644
--- a/src-tauri/src/commands/plugins.rs
+++ b/src-tauri/src/commands/plugins.rs
@@ -276,18 +276,12 @@ pub async fn uninstall_plugin(
}
let plugin = state.plugins.find_plugin(&plugin_id)?;
state.remove_plugin_connection_pools(&plugin_id).await;
- state.plugin_host.stop(&plugin_id).await;
if let Some(plugin) = &plugin {
stop_external_driver_pools(&state, plugin).await;
}
- let root_dir = state.plugins.root_dir().to_path_buf();
- let app_version = state.plugins.app_version().to_string();
- let uninstalled_id = plugin_id.clone();
- tauri::async_runtime::spawn_blocking(move || {
- PluginPackageInstaller::new(root_dir, app_version)?.uninstall(&uninstalled_id)
- })
- .await
- .map_err(|error| error.to_string())??;
+ // Stops the runtime and uninstalls the store under one lifecycle update lease, so a plugin
+ // call cannot re-activate the sidecar (and re-lock its container) in between.
+ state.plugin_host.uninstall_plugin(&plugin_id).await?;
// A reinstall must ask for AI tool access and data grants again.
if let Err(error) = state.storage.forget_plugin_permissions(&plugin_id).await {
log::warn!("Failed to clear permissions of uninstalled plugin {plugin_id}: {error}");