Skip to content

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.

fix(deployment): filter servers by selected path coverage (#544)

l0ng-aiee2585e7e9fc
diff --git a/crates/ide-host/src/ops/deploy.rs b/crates/ide-host/src/ops/deploy.rs
index 1b843995a..e6b0bf021 100644
--- a/crates/ide-host/src/ops/deploy.rs
+++ b/crates/ide-host/src/ops/deploy.rs
@@ -1,6 +1,6 @@
use crate::Host;
use ide_core::{CancellationToken, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
-use ide_remote::{DeployedPath, SyncEntry, SyncStep, TransferReport};
+use ide_remote::{DeployedPath, DeploymentCoverage, SyncEntry, SyncStep, TransferReport};
use ide_ssh::{FsConnection, RemoteEntry};
use std::path::PathBuf;
@@ -31,6 +31,12 @@ fn local(paths: Vec<IpcPath>) -> Vec<PathBuf> {
paths.into_iter().map(|p| p.to_path_buf()).collect()
}
+/// Eligible paths per server, without contacting any deployment host.
+pub async fn deploy_coverage(window: &str, state: &Host, paths: Vec<IpcPath>) -> IdeResult<Vec<DeploymentCoverage>> {
+ let project = state.project(window)?;
+ Ok(ide_remote::coverage(&project.settings.effective(), &project.root, &local(paths)))
+}
+
/// Tools › Deployment › Upload to…: files and folders to `server` (default server when `None`).
pub async fn deploy_upload(
window: &str,
@@ -169,6 +175,7 @@ pub async fn deploy_test_connection(state: &Host, connection: FsConnection, path
}
pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
+ d.add("deploy_coverage", |c| async move { deploy_coverage(&c.window, &c.host, c.arg("paths")?).await });
d.add("deploy_upload", |c| async move {
deploy_upload(&c.window, &c.host, c.arg("paths")?, c.arg("server")?, c.arg("request")?).await
});
diff --git a/crates/ide-host/tests/rpc.rs b/crates/ide-host/tests/rpc.rs
index b3d51c759..39d9c1297 100644
--- a/crates/ide-host/tests/rpc.rs
+++ b/crates/ide-host/tests/rpc.rs
@@ -216,6 +216,7 @@ async fn local_deployment_runs_on_the_project_host() {
}));
let dispatcher = Dispatcher::standard();
for cmd in [
+ "deploy_coverage",
"deploy_upload",
"deploy_download",
"deploy_delete_remote",
@@ -243,6 +244,9 @@ async fn local_deployment_runs_on_the_project_host() {
invoke(&peer, "settings_set", json!({"scope":"project", "key":"deployment", "value":deployment.to_string()}))
.await
.unwrap();
+ let coverage = invoke(&peer, "deploy_coverage", json!({"paths":[file]})).await.unwrap();
+ assert_eq!(coverage[0]["server"], "local");
+ assert_eq!(coverage[0]["paths"], json!([ide_core::IpcPath::from(&file)]));
invoke(&peer, "deploy_test_connection", json!({"connection":{"kind":"local"}, "path":target})).await.unwrap();
let report = invoke(&peer, "deploy_upload", json!({"paths":[file], "request":1001})).await.unwrap();
assert_eq!(report["files"], 1, "{report}");
diff --git a/crates/ide-remote/src/deploy.rs b/crates/ide-remote/src/deploy.rs
index 712b9c197..a9197e40f 100644
--- a/crates/ide-remote/src/deploy.rs
+++ b/crates/ide-remote/src/deploy.rs
@@ -10,6 +10,45 @@ use specta::Type;
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
+/// Mapping eligibility uses a common synthetic server root: mapping and exclusion
+/// paths are both relative to that root, so checking never opens a connection.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct DeploymentCoverage {
+ pub server: String,
+ pub paths: Vec<String>,
+ pub skipped: Vec<TransferError>,
+}
+
+pub fn coverage(settings: &ide_core::settings::Settings, root: &Path, paths: &[PathBuf]) -> Vec<DeploymentCoverage> {
+ settings
+ .deployment
+ .servers
+ .iter()
+ .map(|server| {
+ let map = Mappings::new(server, root, "/");
+ let exclude = Excludes::new(&settings.deployment, server, "/");
+ let mut result = DeploymentCoverage { server: server.id.clone(), paths: Vec::new(), skipped: Vec::new() };
+ for path in paths {
+ let name = ide_core::ipc_path::to_ipc(path);
+ match mapped_path(&map, &exclude, path) {
+ Ok(_) => result.paths.push(name),
+ Err(message) => result.skipped.push(TransferError { path: name, message: message.into() }),
+ }
+ }
+ result
+ })
+ .collect()
+}
+
+fn mapped_path(map: &Mappings, exclude: &Excludes, local: &Path) -> Result<String, &'static str> {
+ let remote = map.remote(local).ok_or("Not covered by this server's mappings")?;
+ if exclude.local(local.strip_prefix(map.project_root()).unwrap_or(local)) || exclude.remote(&remote) {
+ return Err("Excluded from deployment");
+ }
+ Ok(remote)
+}
+
/// Modification times closer than this count as equal (FAT, rounding by servers).
const MTIME_SLACK: u32 = 2;
@@ -171,7 +210,7 @@ impl Deployment<'_> {
break;
}
let rel = self.rel(local);
- let Some(remote) = self.map.remote(local).filter(|r| !self.exclude.remote(r)) else {
+ let Some(remote) = mapped_path(self.map, self.exclude, local).ok() else {
report.skipped += 1;
continue;
};
@@ -193,7 +232,7 @@ impl Deployment<'_> {
let mut report = TransferReport::default();
let mut jobs: Vec<(String, PathBuf)> = Vec::new();
for p in paths {
- let Some(remote) = self.map.remote(p).filter(|r| !self.exclude.remote(r)) else {
+ let Some(remote) = mapped_path(self.map, self.exclude, p).ok() else {
report.skipped += 1;
continue;
};
@@ -239,7 +278,7 @@ impl Deployment<'_> {
let mut report = TransferReport::default();
for p in paths {
// Never a whole mapping (the project folder went away, or a mapped folder did).
- let Some(remote) = self.map.remote(p).filter(|r| !self.exclude.remote(r) && !self.map.is_root(r)) else {
+ let Some(remote) = mapped_path(self.map, self.exclude, p).ok().filter(|r| !self.map.is_root(r)) else {
report.skipped += 1;
continue;
};
@@ -257,12 +296,12 @@ impl Deployment<'_> {
/// Sync with Deployed: local and remote files under `local` side by side.
pub async fn compare(&self, local: &Path) -> IdeResult<Vec<SyncEntry>> {
- let remote_root =
- self.map.remote(local).ok_or_else(|| IdeError::invalid(format!("{} is not mapped", local.display())))?;
+ let remote_root = mapped_path(self.map, self.exclude, local)
+ .map_err(|reason| IdeError::invalid(format!("{}: {reason}", local.display())))?;
let mut by_rel: BTreeMap<String, SyncEntry> = BTreeMap::new();
let mut ignored = TransferReport::default();
for f in self.local_files(&[local.to_path_buf()], &mut ignored) {
- let Some(remote_path) = self.map.remote(&f) else { continue };
+ let Ok(remote_path) = mapped_path(self.map, self.exclude, &f) else { continue };
let size = std::fs::metadata(&f).map(|m| m.len()).unwrap_or(0);
let stamp = FileStamp { size, mtime: mtime_of(&f) };
by_rel.insert(
@@ -319,9 +358,7 @@ impl Deployment<'_> {
break;
}
let local = step.path.split('/').filter(|s| !s.is_empty()).fold(root.clone(), |p, s| p.join(s));
- let Some(remote) =
- self.map.remote(&local).filter(|r| !self.exclude.remote(r) && !self.excluded_local(&local))
- else {
+ let Some(remote) = mapped_path(self.map, self.exclude, &local).ok() else {
report.skipped += 1;
continue;
};
diff --git a/crates/ide-remote/src/lib.rs b/crates/ide-remote/src/lib.rs
index 09af9f62e..2bdd2dbb4 100644
--- a/crates/ide-remote/src/lib.rs
+++ b/crates/ide-remote/src/lib.rs
@@ -6,7 +6,9 @@ pub mod mapping;
pub mod service;
pub mod target;
-pub use deploy::{Deployment, SyncAction, SyncEntry, SyncStatus, SyncStep, TransferReport};
+pub use deploy::{
+ Deployment, DeploymentCoverage, SyncAction, SyncEntry, SyncStatus, SyncStep, TransferReport, coverage,
+};
pub use mapping::{Excludes, Mappings};
pub use service::{DeployedPath, RemoteService};
pub use target::{RemoteRuns, RemoteStart};
diff --git a/crates/ide-remote/tests/local.rs b/crates/ide-remote/tests/local.rs
index cb6540579..91aee56fe 100644
--- a/crates/ide-remote/tests/local.rs
+++ b/crates/ide-remote/tests/local.rs
@@ -209,3 +209,56 @@ async fn missing_non_directory_and_unwritable_targets_are_clear() {
assert!(result.unwrap_err().message.contains("not writable"));
assert_eq!(report.errors.len(), 1, "{report:?}");
}
+
+#[tokio::test]
+async fn coverage_matches_transfers_without_connecting() {
+ let tmp = tempfile::tempdir().unwrap();
+ let root = tmp.path().join("project");
+ let target = tmp.path().join("target");
+ for dir in ["src", "src-other", "assets", "src/private", "src/node_modules"] {
+ std::fs::create_dir_all(root.join(dir)).unwrap();
+ }
+ let names = ["src/a.txt", "assets/b.txt", "src-other/c.txt", "src/private/key", "src/node_modules/pkg"];
+ let paths: Vec<_> = names.iter().map(|name| root.join(name)).collect();
+ for path in &paths {
+ std::fs::write(path, "content").unwrap();
+ }
+ let mut settings = settings(&target);
+ settings.deployment.exclude = vec!["node_modules".into()];
+ settings.deployment.servers[0].mappings[0].local = "src".into();
+ settings.deployment.servers[0].excluded_paths = vec!["app/private".into()];
+ let mut assets = settings.deployment.servers[0].clone();
+ assets.id = "assets".into();
+ assets.mappings[0].local = "assets".into();
+ let mut offline = assets.clone();
+ offline.id = "offline".into();
+ offline.kind = DeploymentType::Sftp;
+ offline.ssh_config = "does-not-exist".into();
+ settings.deployment.servers.extend([assets, offline]);
+ let coverage = ide_remote::coverage(&settings, &root, &paths);
+ assert_eq!(coverage[0].paths, vec![ide_core::ipc_path::to_ipc(&paths[0])]);
+ assert_eq!(coverage[1].paths, vec![ide_core::ipc_path::to_ipc(&paths[1])]);
+ assert_eq!(coverage[2].paths, coverage[1].paths);
+ assert_eq!(coverage[0].skipped.len(), 4);
+ assert!(coverage[0].skipped[0].message.contains("mappings"));
+ assert!(coverage[0].skipped[2].message.contains("Excluded"));
+ let service = service(tmp.path());
+ let report = service
+ .upload(&settings, &root, Some("local"), &paths, CancellationToken::new(), &mut |_, _, _| {})
+ .await
+ .unwrap();
+ assert_eq!((report.files, report.skipped), (1, 4));
+ let entries =
+ service.compare(&settings, &root, Some("local"), &root.join("src"), CancellationToken::new()).await.unwrap();
+ assert_eq!(entries.len(), 1);
+ let report = service
+ .download(&settings, &root, Some("local"), &paths, CancellationToken::new(), &mut |_, _, _| {})
+ .await
+ .unwrap();
+ assert_eq!((report.files, report.skipped), (1, 4));
+ let report = service.delete_remote(&settings, &root, Some("local"), &paths).await.unwrap();
+ assert_eq!((report.files, report.skipped), (1, 4));
+ settings.deployment.servers[0].mappings.clear();
+ assert_eq!(ide_remote::coverage(&settings, &root, &[root.join("assets/b.txt")])[0].paths.len(), 1);
+ assert!(ide_remote::coverage(&settings, &root, &[root.join("../outside")])[0].paths.is_empty());
+}
diff --git a/src-tauri/src/commands/deploy.rs b/src-tauri/src/commands/deploy.rs
index be959bde2..ca486655d 100644
--- a/src-tauri/src/commands/deploy.rs
+++ b/src-tauri/src/commands/deploy.rs
@@ -1,9 +1,19 @@
use crate::state::AppState;
use ide_core::{IdeResult, IpcPath, RequestId};
-use ide_remote::{DeployedPath, SyncEntry, SyncStep, TransferReport};
+use ide_remote::{DeployedPath, DeploymentCoverage, SyncEntry, SyncStep, TransferReport};
use ide_ssh::{FsConnection, RemoteEntry};
use tauri::{State, Window};
+#[tauri::command]
+#[specta::specta]
+pub async fn deploy_coverage(
+ window: Window,
+ state: State<'_, AppState>,
+ paths: Vec<IpcPath>,
+) -> IdeResult<Vec<DeploymentCoverage>> {
+ ide_host::ops::deploy::deploy_coverage(window.label(), &state.host, paths).await
+}
+
#[tauri::command]
#[specta::specta]
pub async fn deploy_upload(
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 739271c7b..a031514b0 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -451,6 +451,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
ssh::git_credentials,
ssh::git_credential_forget,
ssh::ssh_terminal_command,
+ deploy::deploy_coverage,
deploy::deploy_upload,
deploy::deploy_download,
deploy::deploy_delete_remote,
diff --git a/src/bindings.ts b/src/bindings.ts
index 113eff5dd..bc6221f58 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -968,6 +968,7 @@ export const commands = {
* (run in a terminal tab, so prompts and host-key questions are answered there).
*/
sshTerminalCommand: (id: string) => typedError<SshTerminalCommand, IdeError>(__TAURI_INVOKE("ssh_terminal_command", { id })),
+ deployCoverage: (paths: IpcPath[]) => typedError<DeploymentCoverage[], IdeError>(__TAURI_INVOKE("deploy_coverage", { paths })),
deployUpload: (paths: IpcPath[], server: string | null, request: RequestId) => typedError<TransferReport, IdeError>(__TAURI_INVOKE("deploy_upload", { paths, server, request })),
deployDownload: (paths: IpcPath[], server: string | null, request: RequestId) => typedError<TransferReport, IdeError>(__TAURI_INVOKE("deploy_download", { paths, server, request })),
deployDeleteRemote: (paths: IpcPath[], server: string | null) => typedError<TransferReport, IdeError>(__TAURI_INVOKE("deploy_delete_remote", { paths, server })),
@@ -2396,6 +2397,16 @@ export type DeployedPath = {
webUrl: string | null,
};
+/**
+ * Mapping eligibility uses a common synthetic server root: mapping and exclusion
+ * paths are both relative to that root, so checking never opens a connection.
+ */
+export type DeploymentCoverage = {
+ server: string,
+ paths: string[],
+ skipped: TransferError[],
+};
+
export type DeploymentMapping = {
/** Project-relative folder; empty = the project root. */
local?: string,
diff --git a/src/features/deployment/Dialogs.test.tsx b/src/features/deployment/Dialogs.test.tsx
index 197893c4a..15ce23198 100644
--- a/src/features/deployment/Dialogs.test.tsx
+++ b/src/features/deployment/Dialogs.test.tsx
@@ -18,7 +18,8 @@ function openSync(entries: SyncEntry[]) {
sync: {
server: "s1",
serverName: "Staging",
- path: "/work/app",
+ paths: ["/work/app"],
+ skipped: [],
request: null,
entries,
error: null,
diff --git a/src/features/deployment/Dialogs.tsx b/src/features/deployment/Dialogs.tsx
index 3fea1e47c..982a1cda4 100644
--- a/src/features/deployment/Dialogs.tsx
+++ b/src/features/deployment/Dialogs.tsx
@@ -78,7 +78,7 @@ function SyncDialog() {
const shown = entries?.filter((e) => !sync.hideSame || e.status !== "same") ?? [];
const steps = syncSteps(sync.choices);
const same = entries?.filter((e) => e.status === "same").length ?? 0;
- const where = root ? relativePath(root, sync.path) || "/" : sync.path;
+ const where = sync.paths.map((path) => (root ? relativePath(root, path) || "/" : path)).join(", ");
return (
<Dialog
@@ -110,6 +110,12 @@ function SyncDialog() {
<span className={styles.mono}>{where}</span>
{entries && <> · {txt(`${steps.length} of ${entries.length} files will change`)}</>}
</div>
+ {!!sync.skipped?.length && (
+ <div className={styles.note}>
+ {txt(`Skipped: ${sync.skipped.length}`)}:{" "}
+ {sync.skipped.map((s) => (root ? relativePath(root, s.path) : s.path)).join(", ")}
+ </div>
+ )}
{sync.error && <div className={styles.error}>{sync.error}</div>}
{!entries && !sync.error && (
<div className={styles.center}>
diff --git a/src/features/deployment/actions.test.tsx b/src/features/deployment/actions.test.tsx
new file mode 100644
index 000000000..f3a1ae487
--- /dev/null
+++ b/src/features/deployment/actions.test.tsx
@@ -0,0 +1,107 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { DeploymentServerValid } from "@/platform/remoteSettings";
+
+const mocks = vi.hoisted(() => ({
+ actions: [] as { id: string; run: (context: { arg: string[] }) => unknown }[],
+ servers: [] as DeploymentServerValid[],
+ coverage: [] as { server: string; paths: string[]; skipped: { path: string; message: string }[] }[],
+ choose: vi.fn(),
+ notify: vi.fn(),
+ upload: vi.fn(),
+ compare: vi.fn(),
+}));
+vi.mock("@/platform/actions", () => ({
+ executeAction: vi.fn(),
+ registerActions: (actions: typeof mocks.actions) => {
+ mocks.actions = actions;
+ return () => {};
+ },
+}));
+vi.mock("@/workbench/messages", () => ({ confirm: vi.fn() }));
+vi.mock("@/platform/openUrl", () => ({ openExternalUrl: vi.fn() }));
+vi.mock("@/platform/context", () => ({ getContext: () => ({}) }));
+vi.mock("@/platform/project", () => ({
+ relativePath: (_: string, path: string) => path,
+ useProject: { getState: () => ({ project: { root: "/project" } }) },
+}));
+vi.mock("@/platform/workflowSettings", () => ({
+ workflowSettings: () => ({ deployment: { servers: mocks.servers, defaultServer: "one" } }),
+}));
+vi.mock("@/workbench/contributions", () => ({
+ notifications: () => ({ notify: mocks.notify }),
+ projectViewSelection: () => [],
+ toolWindowService: vi.fn(),
+}));
+vi.mock("@/workbench/inputDialogs", () => ({ chooseItem: mocks.choose }));
+vi.mock("./ssh", () => ({ withSsh: (_: unknown, run: () => unknown) => run() }));
+vi.mock("@/platform/ipc", () => ({
+ call: (value: unknown) => value,
+ nextRequestId: () => 1,
+ isCancelled: () => false,
+ commands: {
+ deployCoverage: async () => mocks.coverage,
+ deployUpload: mocks.upload,
+ deployCompare: mocks.compare,
+ },
+}));
+import { registerDeploymentActions } from "./actions";
+import { useDeployment } from "./store";
+
+async function run(id: string, paths = ["/project/a", "/project/b"]) {
+ mocks.actions.find((action) => action.id === id)!.run({ arg: paths });
+ await vi.waitFor(() =>
+ expect(
+ mocks.choose.mock.calls.length + mocks.notify.mock.calls.length + (useDeployment.getState().sync ? 1 : 0),
+ ).toBeGreaterThan(0),
+ );
+}
+beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.servers = ["one", "two"].map((id) => ({ id, name: id, kind: "local" }) as DeploymentServerValid);
+ mocks.coverage = [
+ {
+ server: "one",
+ paths: ["/project/a"],
+ skipped: [{ path: "/project/b", message: "Not covered by this server's mappings" }],
+ },
+ { server: "two", paths: [], skipped: [] },
+ ];
+ mocks.choose.mockResolvedValue(null);
+ mocks.upload.mockResolvedValue({ files: 1, skipped: 1, errors: [] });
+ mocks.compare.mockResolvedValue([]);
+ useDeployment.setState({ sync: null });
+ registerDeploymentActions();
+});
+describe("deployment eligibility", () => {
+ it.each(["deployment.uploadTo", "deployment.downloadFrom", "deployment.syncWith"])(
+ "filters %s and keeps a single option visible",
+ async (id) => {
+ await run(id);
+ expect(mocks.choose).toHaveBeenCalledWith(expect.objectContaining({ items: ["one"] }));
+ },
+ );
+ it("explains an empty match and links settings", async () => {
+ mocks.coverage[0]!.paths = [];
+ await run("deployment.uploadTo");
+ expect(mocks.choose).not.toHaveBeenCalled();
+ expect(mocks.notify).toHaveBeenCalledWith(
+ expect.objectContaining({
+ title: "No deployment server covers the selected paths",
+ actions: [expect.objectContaining({ label: "Configure…" })],
+ }),
+ );
+ });
+ it("explains why the default cannot deploy the named file", async () => {
+ mocks.coverage[0]!.paths = [];
+ await run("deployment.uploadToDefault");
+ expect(mocks.upload).not.toHaveBeenCalled();
+ expect(mocks.notify.mock.calls[0]![0].body.props.report.errors[0].path).toBe("/project/b");
+ });
+ it("compares every covered selection and retains skipped paths", async () => {
+ mocks.coverage[0]!.paths.push("/project/c");
+ mocks.choose.mockResolvedValue("one");
+ await run("deployment.syncWith");
+ await vi.waitFor(() => expect(mocks.compare).toHaveBeenCalledTimes(2));
+ expect(useDeployment.getState().sync?.skipped?.[0]?.path).toBe("/project/b");
+ });
+});
diff --git a/src/features/deployment/actions.tsx b/src/features/deployment/actions.tsx
index b54458b07..4e6163fa9 100644
--- a/src/features/deployment/actions.tsx
+++ b/src/features/deployment/actions.tsx
@@ -51,22 +51,54 @@ function notifyNoTargets() {
});
}
-/** Asks which server to use (the only one without asking). */
-async function pickServer(title: string): Promise<DeploymentServerValid | null> {
- const servers = deployment().servers;
- if (!servers.length) {
+async function serverCoverage(paths: string[]) {
+ try {
+ return await call(commands.deployCoverage(paths));
+ } catch (e) {
+ notifications().notify({
+ level: "error",
+ title: "Cannot check deployment mappings",
+ body: errorText(e),
+ group: GROUP,
+ });
+ return null;
+ }
+}
+
+function notifyNoCoverage(server?: DeploymentServerValid, skipped?: TransferReport["errors"]) {
+ notifications().notify({
+ level: "warning",
+ title: server
+ ? txTemplate(`No selected paths can be deployed to ${serverLabel(server)}`)
+ : "No deployment server covers the selected paths",
+ body: skipped?.length ? <ReportBody report={{ files: 0, skipped: skipped.length, errors: skipped }} /> : undefined,
+ group: GROUP,
+ key: "deployment.noCoverage",
+ actions: [{ label: "Configure…", run: () => void executeAction("deployment.configure") }],
+ });
+}
+
+/** Keep the chooser visible even when only one server covers the selection. */
+async function pickServer(title: string, paths: string[]): Promise<DeploymentServerValid | null> {
+ const configured = deployment().servers;
+ if (!configured.length) {
notifyNoServers();
return null;
}
- if (servers.length === 1) return servers[0]!;
+ const coverage = await serverCoverage(paths);
+ if (!coverage) return null;
+ const servers = configured.filter((server) => coverage.some((c) => c.server === server.id && c.paths.length));
+ if (!servers.length) {
+ notifyNoCoverage();
+ return null;
+ }
const labels = servers.map(serverLabel);
const picked = await chooseItem({ title, items: labels });
return picked === null ? null : (servers[labels.indexOf(picked)] ?? null);
}
-/** The default server; asks when none is marked default and there are several. */
-async function defaultServer(title: string): Promise<DeploymentServerValid | null> {
- return resolveServer(deployment(), null) ?? pickServer(title);
+async function defaultServer(title: string, paths: string[]): Promise<DeploymentServerValid | null> {
+ return resolveServer(deployment(), null) ?? pickServer(title, paths);
}
function ReportBody({ report }: { report: TransferReport }) {
@@ -118,6 +150,9 @@ function showFailure(title: string, server: DeploymentServerValid, e: unknown) {
async function transfer(direction: "upload" | "download", server: DeploymentServerValid | null, paths: string[]) {
if (!server) return;
+ const coverage = (await serverCoverage(paths))?.find((c) => c.server === server.id);
+ if (!coverage) return;
+ if (!coverage.paths.length) return notifyNoCoverage(server, coverage.skipped);
const request = nextRequestId();
try {
const report = await withSsh(server.kind === "sftp" ? server.sshConfig : "", () =>
@@ -139,8 +174,11 @@ export function downloadPaths(server: DeploymentServerValid, paths: string[]) {
}
async function deleteRemote(paths: string[]) {
- const server = await defaultServer("Delete from Server");
+ const server = await defaultServer("Delete from Server", paths);
if (!server) return;
+ const coverage = (await serverCoverage(paths))?.find((c) => c.server === server.id);
+ if (!coverage) return;
+ if (!coverage.paths.length) return notifyNoCoverage(server, coverage.skipped);
const root = projectRoot();
const names = paths.map((p) => (root ? relativePath(root, p) || "/" : p));
const ok = await confirm({
@@ -164,14 +202,18 @@ async function deleteRemote(paths: string[]) {
}
}
-/** Opens the Sync dialog for `path` and compares it with `server`. */
-export async function openSync(server: DeploymentServerValid, path: string) {
+/** Compares every covered selection with `server`. */
+export async function openSync(server: DeploymentServerValid, paths: string[]) {
+ const coverage = (await serverCoverage(paths))?.find((c) => c.server === server.id);
+ if (!coverage) return;
+ if (!coverage.paths.length) return notifyNoCoverage(server, coverage.skipped);
const request = nextRequestId();
useDeployment.setState({
sync: {
server: server.id,
serverName: serverLabel(server),
- path,
+ paths,
+ skipped: coverage.skipped,
request,
entries: null,
error: null,
@@ -181,9 +223,15 @@ export async function openSync(server: DeploymentServerValid, path: string) {
},
});
try {
- const entries = await withSsh(server.kind === "sftp" ? server.sshConfig : "", () =>
- call(commands.deployCompare(path, server.id, request)),
- );
+ const groups = await withSsh(server.kind === "sftp" ? server.sshConfig : "", async () => {
+ const entries = [];
+ for (const path of coverage.paths) {
+ if (useDeployment.getState().sync?.request !== request) break;
+ entries.push(...(await call(commands.deployCompare(path, server.id, request))));
+ }
+ return entries;
+ });
+ const entries = [...new Map(groups.map((entry) => [entry.path, entry])).values()];
if (useDeployment.getState().sync?.request !== request) return;
patchSync({ entries, choices: initialSyncChoices(entries), request: null });
} catch (e) {
@@ -211,6 +259,7 @@ export async function runSync(steps: { path: string; action: SyncAction }[]) {
call(commands.deploySync(steps, server.id, request)),
);
useDeployment.setState({ sync: null });
+ report.skipped += sync.skipped.length;
showReport(report, "sync", server);
} catch (e) {
if (isCancelled(e)) patchSync({ running: false, request: null });
@@ -275,7 +324,7 @@ export function registerDeploymentActions(): () => void {
icon: "export",
when,
keywords: ["deploy", "sftp", "upload", "remote"],
- run: withTargets(async (paths) => transfer("upload", await defaultServer("Upload to"), paths)),
+ run: withTargets(async (paths) => transfer("upload", await defaultServer("Upload to", paths), paths)),
},
{
id: "deployment.uploadTo",
@@ -284,7 +333,7 @@ export function registerDeploymentActions(): () => void {
category: CATEGORY,
when,
keywords: ["deploy", "sftp", "upload", "remote"],
- run: withTargets(async (paths) => transfer("upload", await pickServer("Upload to"), paths)),
+ run: withTargets(async (paths) => transfer("upload", await pickServer("Upload to", paths), paths)),
},
{
id: "deployment.downloadFromDefault",
@@ -293,7 +342,7 @@ export function registerDeploymentActions(): () => void {
category: CATEGORY,
when,
keywords: ["deploy", "sftp", "download", "remote"],
- run: withTargets(async (paths) => transfer("download", await defaultServer("Download from"), paths)),
+ run: withTargets(async (paths) => transfer("download", await defaultServer("Download from", paths), paths)),
},
{
id: "deployment.downloadFrom",
@@ -302,7 +351,7 @@ export function registerDeploymentActions(): () => void {
category: CATEGORY,
when,
keywords: ["deploy", "sftp", "download", "remote"],
- run: withTargets(async (paths) => transfer("download", await pickServer("Download from"), paths)),
+ run: withTargets(async (paths) => transfer("download", await pickServer("Download from", paths), paths)),
},
{
id: "deployment.syncWith",
@@ -315,7 +364,8 @@ export function registerDeploymentActions(): () => void {
const paths = actionTargets(arg);
const target = paths[0] ?? projectRoot();
if (!target) return;
- void pickServer("Sync with Deployed to").then((server) => server && openSync(server, target));
+ const targets = paths.length ? paths : [target];
+ void pickServer("Sync with Deployed to", targets).then((server) => server && openSync(server, targets));
},
},
{
diff --git a/src/features/deployment/store.ts b/src/features/deployment/store.ts
index d7edd3505..7d7dce02c 100644
--- a/src/features/deployment/store.ts
+++ b/src/features/deployment/store.ts
@@ -1,6 +1,6 @@
/** Session state of the deployment feature: the Sync dialog, the SSH secret prompt and the Remote Host tree. */
import { create } from "zustand";
-import type { RemoteEntry, RequestId, SyncEntry } from "@/platform/ipc";
+import type { TransferReport, RemoteEntry, RequestId, SyncEntry } from "@/platform/ipc";
import type { FocusedPart, SyncChoice } from "./model";
export const REMOTE_HOST_WINDOW = "remoteHost";
@@ -8,8 +8,9 @@ export const REMOTE_HOST_WINDOW = "remoteHost";
export interface SyncDialogState {
server: string;
serverName: string;
- /** Absolute local path compared (file or folder). */
- path: string;
+ /** Absolute local paths selected for comparison. */
+ paths: string[];
+ skipped: TransferReport["errors"];
request: RequestId | null;
entries: SyncEntry[] | null;
error: string | null;
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index a48b7fbf9..55b239873 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -5308,5 +5308,10 @@
"Architecture": "架构",
"Compiler": "编译器",
"No CMake executable target for this file": "此文件没有对应的 CMake 可执行目标",
- "Run CMake Configure from the Run selector, then choose the executable target. Files in a CMake project are built with their target.": "请从运行选择器执行 CMake Configure,然后选择可执行目标。CMake 项目中的文件由所属目标构建,不会单独编译。"
+ "Run CMake Configure from the Run selector, then choose the executable target. Files in a CMake project are built with their target.": "请从运行选择器执行 CMake Configure,然后选择可执行目标。CMake 项目中的文件由所属目标构建,不会单独编译。",
+ "Cannot check deployment mappings": "无法检查部署映射",
+ "No selected paths can be deployed to {server}": "所选路径均无法部署到 {server}",
+ "No deployment server covers the selected paths": "没有部署服务器覆盖所选路径",
+ "Not covered by this server's mappings": "此服务器的映射未覆盖该路径",
+ "Excluded from deployment": "已从部署中排除"
}