Manage potential conflicts with other running sessions (#696)

Start debug
* Check in configuration provider if a new session could conflict with an already running one. For example if starting attach config for CPU already connected in a launch. User needs to confirm.
* Let's exact matches pass and leaves them to existing VS Code handling.

Stop debug sesion
* Detect on terminate, disconnect requests if other related sessions are still running and in danger of becoming unstable. For example if a stopped launch connection closes the server for a still running attach connection.
* Only informs the user, no way to stop VS Code from ending it (worst case by terminating process).

Author: jreineckearm

__mocks__/vscode.js

@@ -72,8 +72,9 @@ module.exports = {
             error: jest.fn(),
         })),
         registerTreeDataProvider: jest.fn(() => ({ dispose: jest.fn() })),
-        showWarningMessage: jest.fn(),
         showErrorMessage: jest.fn(),
+        showInformationMessage: jest.fn(),
+        showWarningMessage: jest.fn(),
         createStatusBarItem: jest.fn(),
         showQuickPick: jest.fn(),
     },

src/__test__/vscode.factory.ts

@@ -70,10 +70,11 @@ export function extensionContextFactory(): jest.Mocked<vscode.ExtensionContext>
 };
 
 export function debugSessionFactory(
-    configuration: vscode.DebugConfiguration
+    configuration: vscode.DebugConfiguration,
+    id: string = '{session-id}'
 ): jest.Mocked<vscode.DebugSession> {
     return {
-        id: '{session-id}',
+        id,
         name: configuration.name,
         type: configuration.type,
         workspaceFolder: undefined,

src/debug-configuration/gdbtarget-configuration-provider.test.ts

@@ -15,20 +15,21 @@
  */
 
 import { GDBTargetConfiguration, GDBTargetConfigurationProvider } from '.'; // use index.ts to cover it in one test
-import { extensionContextFactory } from '../__test__/vscode.factory';
+import { debugSessionFactory, extensionContextFactory } from '../__test__/vscode.factory';
 
 import * as vscode from 'vscode';
 import { URI } from 'vscode-uri';
-import { debugConfigurationFactory } from './debug-configuration.factory';
+import { debugConfigurationFactory, gdbTargetConfiguration } from './debug-configuration.factory';
 import { BuiltinToolPath } from '../desktop/builtin-tool-path';
-import { isWindows } from '../utils';
+import { isWindows, waitForMs } from '../utils';
+import { GDBTargetDebugSession, GDBTargetDebugTracker } from '../debug-session';
 
 jest.mock('../desktop/builtin-tool-path');
 const BuiltinToolPathMock = BuiltinToolPath as jest.MockedClass<typeof BuiltinToolPath>;
 
 describe('GDBTargetConfigurationProvider', () => {
 
-    it('should activate', async () => {
+    it('should activate', () => {
         const configProvider = new GDBTargetConfigurationProvider([]);
         const contextMock = extensionContextFactory();
 
@@ -38,6 +39,18 @@ describe('GDBTargetConfigurationProvider', () => {
         expect(vscode.debug.registerDebugConfigurationProvider as jest.Mock).toHaveBeenCalledWith('gdbtarget', configProvider);
     });
 
+    it('should activate with debug tracker', () => {
+        const debugTracker = new GDBTargetDebugTracker();
+        const configProvider = new GDBTargetConfigurationProvider([]);
+        const contextMock = extensionContextFactory();
+
+        configProvider.activate(contextMock, debugTracker);
+
+        // 1 for the config provider, 2 for the debug tracker
+        expect(contextMock.subscriptions).toHaveLength(1+2);
+        expect(vscode.debug.registerDebugConfigurationProvider as jest.Mock).toHaveBeenCalledWith('gdbtarget', configProvider);
+    });
+
     it('resolveDebugConfiguration', async () => {
         const configProvider = new GDBTargetConfigurationProvider([]);
         const debugConfig = debugConfigurationFactory();
@@ -97,4 +110,112 @@ describe('GDBTargetConfigurationProvider', () => {
         expect(resolvedDebugConfig).toBeDefined();
         expect(resolvedDebugConfig.gdb).toEqual(expectedGdbPath);
     });
+
+    describe('tests with sessions', () => {
+        let debugTracker: GDBTargetDebugTracker;
+        let configProvider: GDBTargetConfigurationProvider;
+        let contextMock: vscode.ExtensionContext;
+
+        const createLaunchConfig = (name: string) => gdbTargetConfiguration({
+            name,
+            request: 'launch'
+        });
+
+        const createAttachConfig = (name: string) => gdbTargetConfiguration({
+            name,
+            request: 'attach'
+        });
+
+        const createLaunchSession = (name: string) => new GDBTargetDebugSession(
+            debugSessionFactory(createLaunchConfig(name))
+        );
+
+        const createAttachSession = (name: string) => new GDBTargetDebugSession(
+            debugSessionFactory(createAttachConfig(name))
+        );
+
+        beforeEach(() => {
+            debugTracker = new GDBTargetDebugTracker();
+            configProvider = new GDBTargetConfigurationProvider([]);
+            contextMock = extensionContextFactory();
+
+            configProvider.activate(contextMock, debugTracker);
+
+            (vscode.window.showInformationMessage as jest.Mock).mockClear();
+        });
+
+        it('can add and remove sessions', async () => {
+            const debugSession = createLaunchSession('testSession');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (debugTracker as any)._onWillStartSession.fire(debugSession);
+            await waitForMs(0);
+            expect(configProvider['activeSessions'].size).toBe(1);
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (debugTracker as any)._onWillStopSession.fire(debugSession);
+            await waitForMs(0);
+            expect(configProvider['activeSessions'].size).toBe(0);
+        });
+
+        it('starts independent sessions', async () => {
+            const launchSession = createLaunchSession('pname session@1 (launch)');
+            const attachSession = createAttachSession('pname session@2 (attach)');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (debugTracker as any)._onWillStartSession.fire(launchSession);
+            await waitForMs(0);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (debugTracker as any)._onWillStartSession.fire(attachSession);
+            await waitForMs(0);
+        });
+
+        it.each([
+            { dialogResponse: undefined, undefinedResult: true },
+            { dialogResponse: 'Yes', undefinedResult: false },
+        ])('asks for confirmation if starting sessions with same config base name (dialog response $dialogResponse)', async ({ dialogResponse, undefinedResult }) => {
+            (vscode.window.showInformationMessage as jest.Mock).mockResolvedValueOnce(dialogResponse);
+            const launchSession = createLaunchSession('pname session@1 (launch)');
+            const attachConfig = createAttachConfig('pname session@1 (attach)');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (debugTracker as any)._onWillStartSession.fire(launchSession);
+            await waitForMs(0);
+            expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
+            const result = await configProvider.resolveDebugConfigurationWithSubstitutedVariables(
+                undefined,
+                attachConfig
+            );
+            expect(vscode.window.showInformationMessage).toHaveBeenCalledTimes(1);
+            if (undefinedResult) {
+                expect(result).toBeUndefined();
+            } else {
+                expect(result).toBeDefined();
+            }
+        });
+
+        it('does not ask for confirmation if same config starts again (VS Code will do later)', async () => {
+            const launchSession = createLaunchSession('pname session@1 (launch)');
+            const otherLaunchConfig = createLaunchConfig('pname session@1 (launch)');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (debugTracker as any)._onWillStartSession.fire(launchSession);
+            await waitForMs(0);
+            expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
+            const result = await configProvider.resolveDebugConfigurationWithSubstitutedVariables(
+                undefined,
+                otherLaunchConfig
+            );
+            expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
+            expect(result).toBeDefined();
+        });
+
+        it('does not ask for confirmation if no other session running', async () => {
+            const launchConfig = createLaunchConfig('pname session@1 (launch)');
+            expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
+            const result = await configProvider.resolveDebugConfigurationWithSubstitutedVariables(
+                undefined,
+                launchConfig
+            );
+            expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
+            expect(result).toBeDefined();
+        });
+    });
+
 });

src/debug-configuration/gdbtarget-configuration-provider.ts

@@ -26,6 +26,8 @@ import {
 } from './subproviders';
 import { BuiltinToolPath } from '../desktop/builtin-tool-path';
 import { resolveToolPath } from '../desktop/tool-path-utils';
+import { GDBTargetDebugSession, GDBTargetDebugTracker } from '../debug-session';
+import { getManagedConfigBaseName, hasManagedConfigEnding } from './managed-config-utils';
 
 const GDB_TARGET_DEBUGGER_TYPE = 'gdbtarget';
 const ARM_NONE_EABI_GDB_NAME = 'arm-none-eabi-gdb';
@@ -49,15 +51,22 @@ const GENERIC_SUBPROVIDER: GDBTargetConfigurationSubProvider = { serverRegExp: /
 
 export class GDBTargetConfigurationProvider implements vscode.DebugConfigurationProvider {
     protected builtinArmNoneEabiGdb = new BuiltinToolPath(ARM_NONE_EABI_GDB_BUILTIN_PATH);
+    protected activeSessions = new Set<GDBTargetDebugSession>();
 
     public constructor(
         protected subProviders: GDBTargetConfigurationSubProvider[] = SUPPORTED_SUBPROVIDERS
     ) {}
 
-    public activate(context: vscode.ExtensionContext) {
+    public activate(context: vscode.ExtensionContext, debugTracker?: GDBTargetDebugTracker) {
         context.subscriptions.push(
             vscode.debug.registerDebugConfigurationProvider(GDB_TARGET_DEBUGGER_TYPE, this)
         );
+        if (debugTracker) {
+            context.subscriptions.push(
+                debugTracker.onWillStartSession(session => this.activeSessions.add(session)),
+                debugTracker.onWillStopSession(session => this.activeSessions.delete(session))
+            );
+        }
     }
 
     private logDebugConfiguration(resolverType: ResolverType, config: vscode.DebugConfiguration, message = '') {
@@ -111,6 +120,33 @@ export class GDBTargetConfigurationProvider implements vscode.DebugConfiguration
         return relevantProvider;
     }
 
+    private async shouldCancel(debugConfiguration: vscode.DebugConfiguration): Promise<boolean> {
+        if (!hasManagedConfigEnding(debugConfiguration.name)) {
+            // Not a managed config
+            return false;
+        }
+        const managedSessions = Array.from(this.activeSessions).filter(session => hasManagedConfigEnding(session.session.name));
+        if (!managedSessions.length) {
+            // No other running managed sessions
+            return false;
+        }
+        const configNameBase = getManagedConfigBaseName(debugConfiguration.name);
+        const alreadyRunning = managedSessions.find(session => {
+            return getManagedConfigBaseName(session.session.name) === configNameBase;
+        })?.session.name;
+        if (!alreadyRunning || alreadyRunning === debugConfiguration.name) {
+            // Nothing suitable running, or exact match which should be handled by VS Code built-in mechanism
+            return false;
+        }
+        const continueOption = 'Yes';
+        const result = await vscode.window.showInformationMessage(
+            `'${alreadyRunning}' is already running and may conflict with new session. Do you want to start '${debugConfiguration.name}' anyway?`,
+            { modal: true },
+            continueOption
+        );
+        return result !== continueOption;
+    }
+
     private async resolveDebugConfigurationByResolverType(
         resolverType: ResolverType,
         folder: vscode.WorkspaceFolder | undefined,
@@ -146,11 +182,15 @@ export class GDBTargetConfigurationProvider implements vscode.DebugConfiguration
         return this.resolveDebugConfigurationByResolverType('resolveDebugConfiguration', folder, debugConfiguration, token);
     }
 
-    public resolveDebugConfigurationWithSubstitutedVariables(
+    public async resolveDebugConfigurationWithSubstitutedVariables(
         folder: vscode.WorkspaceFolder | undefined,
         debugConfiguration: vscode.DebugConfiguration,
         token?: vscode.CancellationToken
     ): Promise<vscode.DebugConfiguration | null | undefined> {
+        // Check only with substituted variables in case name contains one
+        if (await this.shouldCancel(debugConfiguration)) {
+            return undefined;
+        }
         // Only resolve GDB path once, otherwise regexp check will fail
         logger.debug('resolveDebugConfigurationWithSubstitutedVariables: Resolve GDB path');
         debugConfiguration.gdb = resolveToolPath(debugConfiguration.gdb, ARM_NONE_EABI_GDB_NAME, ARM_NONE_EABI_GDB_EXECUTABLE_ONLY_REGEXP, this.builtinArmNoneEabiGdb);

src/debug-configuration/index.ts

@@ -16,3 +16,4 @@
 
 export * from './gdbtarget-configuration';
 export * from './gdbtarget-configuration-provider';
+export * from './managed-config-utils';

src/debug-configuration/managed-config-utils.test.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright 2025 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { getManagedConfigBaseName, hasManagedConfigEnding } from './managed-config-utils';
+
+describe('Managed Config Utils', () => {
+
+    describe('hasManagedConfigEnding', () => {
+
+        it('returns true for \'(launch)\' and \'(attach)\' ending', () => {
+            expect(hasManagedConfigEnding('My Config (launch)')).toBe(true);
+            expect(hasManagedConfigEnding('My Config (attach)')).toBe(true);
+        });
+
+        it('returns false without \'(launch)\' or \'(attach)\' ending', () => {
+            expect(hasManagedConfigEnding('My Config')).toBe(false);
+        });
+
+        it('returns false with \'(launch)\' or \'(attach)\' but not at the end', () => {
+            expect(hasManagedConfigEnding('My Config (launch something)')).toBe(false);
+            expect(hasManagedConfigEnding('My Config (attach) xyz')).toBe(false);
+        });
+
+    });
+
+    describe('getManagedConfigBaseName', () => {
+
+        it('returns base name without \'(launch)\' or \'(attach)\' ending', () => {
+            expect(getManagedConfigBaseName('My Launch Config (launch)')).toBe('My Launch Config');
+            expect(getManagedConfigBaseName('My Attach Config (attach)')).toBe('My Attach Config');
+        });
+
+        it('returns full name if no \'(launch)\' or \'(attach)\' ending', () => {
+            expect(getManagedConfigBaseName('My (launch) Config')).toBe('My (launch) Config');
+            expect(getManagedConfigBaseName('My Config (attach')).toBe('My Config (attach');
+            expect(getManagedConfigBaseName('My Config')).toBe('My Config');
+        });
+
+    });
+
+});

src/debug-configuration/managed-config-utils.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2025 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const DEBUG_CONFIG_REQTYPES = [ '(launch)', '(attach)' ];
+
+/**
+ * Check if configuration name ends with typical ending for CMSIS managed debug configs.
+ *
+ * @param configName debug configuration name
+ * @returns true if configuration name ends with managed config type endings
+ */
+export const hasManagedConfigEnding = (configName: string): boolean => DEBUG_CONFIG_REQTYPES.some(req => configName.endsWith(req));
+
+/**
+ * Get base name of managed configuration by removing the request type ending.
+ *
+ * @param configName debug configuration name
+ * @returns base name of managed configuration
+ */
+export const getManagedConfigBaseName = (configName: string): string => {
+    if (!hasManagedConfigEnding(configName)) {
+        return configName;
+    }
+    return configName.split(' ').slice(0, -1).join(' ');
+};

src/debug-session/__snapshots__/gdbtarget-debug-session.test.ts.snap

@@ -1,6 +1,6 @@
 // Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
 
-exports[`GDBTargetDebugSession returns a cbuild object after parsing one 1`] = `
+exports[`GDBTargetDebugSession with launch configuration returns a cbuild object and cbuild run path after parsing one 1`] = `
 CbuildRunReader {
   "cbuildRun": {
     "compiler": "AC6",