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(run): drop a removed workspace member's sessions and Services groups (#1289)
Qing19a245fa0464
diff --git a/src/features/run/index.ts b/src/features/run/index.tsindex c51262f7f..e32a1eec6 100644--- a/src/features/run/index.ts+++ b/src/features/run/index.ts@@ -40,7 +40,7 @@ import { registerGoActions } from "./goActions";import { invalidateGoModules } from "./goModules";import { RunWidget } from "./RunWidget";import { runConfigsRunAnything } from "./runAnything";-import { recordRun, runServiceProvider } from "./services";+import { cleanupRemovedProject, recordRun, runServiceProvider } from "./services";import { runBeforeLaunch } from "./beforeLaunch";import { compoundChildren } from "./configs";import { remoteDebugBlocked } from "./remote";@@ -299,6 +299,15 @@ export function activate(): () => void {listenForApplicationDeactivation(),trackRecentConfigurations(),useDebugRunSessions.subscribe(() => setContext("run.updatableRunning", updatableSessions().length > 0)),+ // A removed workspace member (or a closed project) takes its sessions,+ // temporary configurations and Services groups with it.+ // Only while the same project stays open: closing it tears its runs down separately.+ useProject.subscribe((s, prev) => {+ if (!s.project || s.project.root !== prev.project?.root) return;+ const before = prev.project.workspace?.projects ?? [];+ const after = s.project.workspace?.projects ?? [];+ for (const root of before) if (!after.includes(root)) void cleanupRemovedProject(root);+ }),registerEditorContribution({ id: "run.targets", order: 55, extensions: runGutter }),registerEditorContribution({ id: "run.npmScripts", order: 58, extensions: npmGutter }),registerMenuGroup({diff --git a/src/features/run/services.test.ts b/src/features/run/services.test.tsindex 8a5ceb93e..2072ecf8e 100644--- a/src/features/run/services.test.ts+++ b/src/features/run/services.test.ts@@ -1,8 +1,25 @@-import { beforeEach, describe, expect, it } from "vitest";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";import type { RunConfig } from "@/platform/ipc";-import { DEFAULT_TYPES, readRan, readTypes, runServiceItems, sessionDetail, sessionStatus } from "./services";+import { useProject } from "@/platform/project";++const ipc = vi.hoisted(() => ({ runConfigs: vi.fn() }));+vi.mock("@/platform/ipc", async (importOriginal) => ({+ ...(await importOriginal<typeof import("@/platform/ipc")>()),+ isTauri: () => true,+ commands: ipc,+}));++import {+ cleanupRemovedProject,+ DEFAULT_TYPES,+ readRan,+ readTypes,+ runServiceItems,+ sessionDetail,+ sessionStatus,+} from "./services";import { startedPort } from "./serverPort";-import type { RunSession } from "./store";+import { useRun, type RunSession } from "./store";import type { DebugServiceSession } from "@/workbench/contributions";const config = (id: string, kind: string): RunConfig => ({@@ -248,9 +265,58 @@ describe("embedded web server port", () => {expect(startedPort("o.s.b.web.embedded.netty.NettyWebServer : Netty started on port 9090")).toBe(9090);expect(startedPort("Netty started on port(s): 9091")).toBe(9091);expect(startedPort("Undertow started on port(s) 8082 (http)")).toBe(8082);- expect(startedPort("Jetty started on port 8083 (http/1.1) with context path '/'")).toBe(8083);+ expect(startedPort("Jetty started on port 9083 (http/1.1) with context path '/'")).toBe(9083);expect(startedPort("Tomcat initialized with port 8080 (http)")).toBeNull();expect(startedPort("Started DemoApplication in 1.2 seconds")).toBeNull();expect(startedPort("Tomcat started on port 99999")).toBeNull();});});++describe("removing a workspace member from Services", () => {+ const main = { ...config("app", "spring-boot"), cwd: "/w/main" };+ const vue = { ...config("dev", "npm"), cwd: "/w/vue" };++ beforeEach(() => {+ localStorage.clear();+ useProject.setState({ project: { root: "/w/main" } as never });+ ipc.runConfigs.mockImplementation(async () => ({ status: "ok", data: [main] }));+ });+ afterEach(() => {+ useProject.setState({ project: null });+ useRun.setState({ configs: [], sessions: [], temporary: [], selectedId: null });+ });++ it("stops and forgets the member's sessions and drops its empty type groups", async () => {+ useRun.setState({+ configs: [main, vue],+ temporary: ["dev"],+ sessions: [session("s1", main, "finished", 1), session("s2", vue, "running", 2, { runId: 7 })],+ });+ localStorage.setItem("openidea.services.runTypes:/w/main", JSON.stringify(["spring-boot", "npm"]));+ localStorage.setItem("openidea.services.ran:/w/main", JSON.stringify(["app", "dev"]));++ await cleanupRemovedProject("/w/vue");++ const s = useRun.getState();+ expect(s.sessions.map((x) => x.id)).toEqual(["s1"]);+ expect(s.configs.map((c) => c.id)).toEqual(["app"]);+ expect(s.temporary).toEqual([]);+ expect(readTypes("/w/main")).toEqual(["spring-boot"]);+ expect(readRan("/w/main")).toEqual(["app"]);+ expect(ipc.runConfigs).toHaveBeenCalled();+ });++ it("keeps a type another project still uses, and a sibling with a shared prefix", async () => {+ const other = { ...config("serve", "npm"), cwd: "/w/main" };+ const sibling = { ...config("dev2", "npm"), cwd: "/w/vue2" };+ useRun.setState({ configs: [main, other, vue, sibling], sessions: [] });+ localStorage.setItem("openidea.services.runTypes:/w/main", JSON.stringify(["npm"]));+ // What the backend lists once /w/vue is no longer a workspace member.+ ipc.runConfigs.mockImplementation(async () => ({ status: "ok", data: [main, other, sibling] }));++ await cleanupRemovedProject("/w/vue");++ expect(useRun.getState().configs.map((c) => c.id)).toEqual(["app", "serve", "dev2"]);+ expect(readTypes("/w/main")).toEqual(["npm"]);+ });+});diff --git a/src/features/run/services.tsx b/src/features/run/services.tsxindex a7644d643..41af0d17d 100644--- a/src/features/run/services.tsx+++ b/src/features/run/services.tsx@@ -29,7 +29,7 @@ import { commandLine, configIcon, KIND_OPTIONS, kindLabel } from "./configs";import { SessionPanel } from "./RunView";import { showApplicationUpdate } from "./applicationUpdate";import { isUpdatable } from "./updatePolicies";-import { startRun, useRun, type RunSession } from "./store";+import { loadConfigs, persistTemporary, startRun, stopSession, useRun, type RunSession } from "./store";import {currentServiceSession,currentServiceSessions,@@ -137,6 +137,65 @@ export function recordRun(configId: string) {}}+// ---------------------------------------------------------------------------+// Project removal: a workspace member's data leaves with it++/** Whether `path` is inside the directory `root` (a removed member, not a sibling with a shared prefix). */+function insideRoot(path: string, root: string): boolean {+ return path === root || path.startsWith(`${root}/`);+}++/**+ * Drops a removed workspace member's data from Services: stops and forgets its+ * sessions (a finished one still groups the tree), removes its temporary+ * configurations, reloads (the backend no longer lists the member) and clears+ * the added types and remembered runs that would otherwise render empty groups.+ */+export async function cleanupRemovedProject(removedRoot: string): Promise<void> {+ const { configs, sessions, temporary } = useRun.getState();+ const ofRemoved = (c: RunConfig) => !!c.cwd && insideRoot(c.cwd, removedRoot);+ const removedIds = new Set(configs.filter(ofRemoved).map((c) => c.id));++ const removedSessions = sessions.filter((s) => removedIds.has(s.config.id));+ for (const s of removedSessions) if (busy(s)) await stopSession(s.id);+ if (removedSessions.length) {+ const ids = new Set(removedSessions.map((s) => s.id));+ useRun.setState((s) => ({ sessions: s.sessions.filter((x) => !ids.has(x.id)) }));+ }++ if (temporary.some((id) => removedIds.has(id))) {+ const temporaryLeft = temporary.filter((id) => !removedIds.has(id));+ useRun.setState({+ configs: useRun.getState().configs.filter((c) => !removedIds.has(c.id)),+ temporary: temporaryLeft,+ });+ persistTemporary();+ }++ // The kinds the member had configurations of; after the reload those that are+ // left without any (and without a session) are removed from the added types.+ const kinds = new Set(configs.filter(ofRemoved).map((c) => c.kind));+ await loadConfigs();++ const { configs: fresh, sessions: liveSessions } = useRun.getState();+ const liveKinds = new Set([...fresh.map((c) => c.kind), ...liveSessions.map((s) => s.config.kind)]);+ for (const kind of kinds) if (!liveKinds.has(kind)) removeType(kind);++ const root = useProject.getState().project?.root ?? null;+ if (root) {+ const freshIds = new Set(fresh.map((c) => c.id));+ const ids = ranIds(root).filter((id) => freshIds.has(id));+ if (ids.length !== ranIds(root).length) {+ useRanConfigs.setState({ root, ids });+ try {+ localStorage.setItem(RAN_KEY + root, JSON.stringify(ids));+ } catch {+ /* storage unavailable */+ }+ }+ }+}+// ---------------------------------------------------------------------------// Treediff --git a/src/features/run/store.ts b/src/features/run/store.tsindex ef8616d3b..ff4ae8450 100644--- a/src/features/run/store.ts+++ b/src/features/run/store.ts@@ -342,7 +342,7 @@ function writeTemporary(root: string, configs: RunConfig[]) {let persisting = 0;-function persistTemporary() {+export function persistTemporary() {const root = useProject.getState().project?.root;if (!root) return;const { configs, temporary } = useRun.getState();