From 87d4f4f21e9265bd04c4ba60438e10db56640c62 Mon Sep 17 00:00:00 2001 From: Wasim Date: Tue, 17 Nov 2026 16:57:36 +0530 Subject: [PATCH] Serialize Jedi language server restarts and clean up in-flight starts (fixes #26296) When changing interpreters and restarting the Jedi language server in quick succession, overlapping start/stop calls can leave orphan run-jedi-language-server.py processes running. Additionally, restarting before the server has finished its initial start spawns an unconnected server, and python.analysis.restartLanguageServer failed to return its restart promise. This change: 1. Returns the restart promise from the python.analysis.restartLanguageServer command. 2. Tracks started state and safely no-ops if restart is triggered before initial start. 3. Serializes overlapping restart calls sequentially through an execution queue. 4. Cleans up and kills in-flight language client processes if stop() is called while start() is awaiting client creation/startup in JediLanguageServerProxy. 5. Adds unit tests covering command return value, serialization, and proxy in-flight stop. --- .../activation/jedi/languageServerProxy.ts | 63 +++++-- src/client/activation/jedi/manager.ts | 21 ++- .../jediLanguageServerManager.unit.test.ts | 175 ++++++++++++++++++ 3 files changed, 237 insertions(+), 22 deletions(-) create mode 100644 src/test/activation/jedi/jediLanguageServerManager.unit.test.ts diff --git a/src/client/activation/jedi/languageServerProxy.ts b/src/client/activation/jedi/languageServerProxy.ts index d7ffe8328b9e..d7f5045cbfe7 100644 --- a/src/client/activation/jedi/languageServerProxy.ts +++ b/src/client/activation/jedi/languageServerProxy.ts @@ -18,6 +18,10 @@ import { traceDecoratorError, traceDecoratorVerbose, traceError } from '../../lo export class JediLanguageServerProxy implements ILanguageServerProxy { private languageClient: LanguageClient | undefined; + private startingClient: LanguageClient | undefined; + + private isStopped = false; + private readonly disposables: Disposable[] = []; private lsVersion: string | undefined; @@ -51,13 +55,28 @@ export class JediLanguageServerProxy implements ILanguageServerProxy { this.lsVersion = (options.middleware ? (options.middleware).serverVersion : undefined) ?? '0.19.3'; + this.isStopped = false; try { const client = await this.factory.createLanguageClient(resource, interpreter, options); + if (this.isStopped) { + await this.disposeClient(client); + return; + } + this.startingClient = client; this.registerHandlers(client); await client.start(); + if (this.isStopped) { + await this.disposeClient(client); + return; + } this.languageClient = client; + this.startingClient = undefined; } catch (ex) { + this.startingClient = undefined; + if (this.isStopped) { + return; + } traceError('Failed to start language server:', ex); throw new Error('Launching Jedi language server using python failed, see output.'); } @@ -65,31 +84,37 @@ export class JediLanguageServerProxy implements ILanguageServerProxy { @traceDecoratorVerbose('Stopping language server') public async stop(): Promise { + this.isStopped = true; while (this.disposables.length > 0) { const d = this.disposables.shift()!; d.dispose(); } - if (this.languageClient) { - const client = this.languageClient; - this.languageClient = undefined; - - // eslint-disable-next-line @typescript-eslint/no-explicit-any - const pid: number | undefined = ((client as any)._serverProcess as ChildProcess)?.pid; - const killServer = () => { - if (pid) { - killPid(pid); - } - }; - - try { - await client.stop(); - await client.dispose(); - killServer(); - } catch (ex) { - traceError('Stopping language client failed', ex); - killServer(); + const clientToStop = this.languageClient ?? this.startingClient; + this.languageClient = undefined; + this.startingClient = undefined; + + if (clientToStop) { + await this.disposeClient(clientToStop); + } + } + + private async disposeClient(client: LanguageClient): Promise { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const pid: number | undefined = ((client as any)._serverProcess as ChildProcess)?.pid; + const killServer = () => { + if (pid) { + killPid(pid); } + }; + + try { + await client.stop(); + await client.dispose(); + killServer(); + } catch (ex) { + traceError('Stopping language client failed', ex); + killServer(); } } diff --git a/src/client/activation/jedi/manager.ts b/src/client/activation/jedi/manager.ts index bafdcc735a12..73c08cceb0d4 100644 --- a/src/client/activation/jedi/manager.ts +++ b/src/client/activation/jedi/manager.ts @@ -31,6 +31,10 @@ export class JediLanguageServerManager implements ILanguageServerManager { private connected = false; + private started = false; + + private restartQueue: Promise = Promise.resolve(); + private lsVersion: string | undefined; constructor( @@ -43,7 +47,7 @@ export class JediLanguageServerManager implements ILanguageServerManager { JediLanguageServerManager.commandDispose.dispose(); } JediLanguageServerManager.commandDispose = commandManager.registerCommand(Commands.RestartLS, () => { - this.restartLanguageServer().ignoreErrors(); + return this.restartLanguageServer(); }); } @@ -54,6 +58,7 @@ export class JediLanguageServerManager implements ILanguageServerManager { } public dispose(): void { + this.started = false; this.stopLanguageServer().ignoreErrors(); JediLanguageServerManager.commandDispose.dispose(); this.disposables.forEach((d) => d.dispose()); @@ -85,6 +90,7 @@ export class JediLanguageServerManager implements ILanguageServerManager { await this.analysisOptions.initialize(resource, interpreter); await this.startLanguageServer(); + this.started = true; } public connect(): void { @@ -109,8 +115,17 @@ export class JediLanguageServerManager implements ILanguageServerManager { @traceDecoratorError('Failed to restart language server') @traceDecoratorVerbose('Restarting language server') protected async restartLanguageServer(): Promise { - await this.stopLanguageServer(); - await this.startLanguageServer(); + if (!this.started) { + return; + } + this.restartQueue = this.restartQueue.then(async () => { + if (!this.started) { + return; + } + await this.stopLanguageServer(); + await this.startLanguageServer(); + }); + return this.restartQueue; } @captureTelemetry( diff --git a/src/test/activation/jedi/jediLanguageServerManager.unit.test.ts b/src/test/activation/jedi/jediLanguageServerManager.unit.test.ts new file mode 100644 index 000000000000..b6db752ed143 --- /dev/null +++ b/src/test/activation/jedi/jediLanguageServerManager.unit.test.ts @@ -0,0 +1,175 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +import * as assert from 'assert'; +import * as sinon from 'sinon'; +import { EventEmitter } from 'vscode'; +import { LanguageClient, LanguageClientOptions } from 'vscode-languageclient/node'; +import { Commands } from '../../../client/activation/commands'; +import { ICommandManager } from '../../../client/common/application/types'; +import { IServiceContainer } from '../../../client/ioc/types'; +import { PythonEnvironment } from '../../../client/pythonEnvironments/info'; +import { JediLanguageServerManager } from '../../../client/activation/jedi/manager'; +import { JediLanguageServerProxy } from '../../../client/activation/jedi/languageServerProxy'; +import { ILanguageClientFactory, ILanguageServerAnalysisOptions, ILanguageServerProxy } from '../../../client/activation/types'; + +suite('Language Server - Jedi LS Manager and Proxy', () => { + let sandbox: sinon.SinonSandbox; + + setup(() => { + sandbox = sinon.createSandbox(); + }); + + teardown(() => { + sandbox.restore(); + }); + + suite('JediLanguageServerManager', () => { + let commandManager: ICommandManager; + let registeredCommandHandler: (() => Promise | void) | undefined; + let analysisOptions: ILanguageServerAnalysisOptions; + let onDidChangeEventEmitter: EventEmitter; + let languageServerProxy: ILanguageServerProxy; + let serviceContainer: IServiceContainer; + + setup(() => { + onDidChangeEventEmitter = new EventEmitter(); + analysisOptions = { + onDidChange: onDidChangeEventEmitter.event, + initialize: sandbox.stub().resolves(), + getAnalysisOptions: sandbox.stub().resolves({} as LanguageClientOptions), + dispose: sandbox.stub(), + }; + languageServerProxy = { + start: sandbox.stub().resolves(), + stop: sandbox.stub().resolves(), + dispose: sandbox.stub(), + loadExtension: sandbox.stub(), + }; + commandManager = ({ + registerCommand: (command: string, handler: () => Promise | void) => { + if (command === Commands.RestartLS) { + registeredCommandHandler = handler; + } + return { dispose: () => {} }; + }, + } as unknown) as ICommandManager; + serviceContainer = ({ + get: sandbox.stub(), + } as unknown) as IServiceContainer; + }); + + teardown(() => { + onDidChangeEventEmitter.dispose(); + }); + + test('RestartLS command returns a promise that resolves when restart finishes', async () => { + const manager = new JediLanguageServerManager( + serviceContainer, + analysisOptions, + languageServerProxy, + commandManager, + ); + + assert.notStrictEqual(registeredCommandHandler, undefined); + + // Before start is called, executing restart should return a promise that safely no-ops + const resultBeforeStart = registeredCommandHandler!(); + assert.ok(resultBeforeStart instanceof Promise); + await resultBeforeStart; + assert.strictEqual((languageServerProxy.start as sinon.SinonStub).called, false); + + // Now start the manager + await manager.start(undefined, { path: 'python' } as PythonEnvironment); + assert.strictEqual((languageServerProxy.start as sinon.SinonStub).callCount, 1); + + // Calling restart command should return the restart promise and execute stop/start + const restartPromise = registeredCommandHandler!(); + assert.ok(restartPromise instanceof Promise); + await restartPromise; + assert.strictEqual((languageServerProxy.stop as sinon.SinonStub).callCount, 1); + assert.strictEqual((languageServerProxy.start as sinon.SinonStub).callCount, 2); + + manager.dispose(); + }); + + test('Overlapping restart calls are queued and serialized sequentially', async () => { + const manager = new JediLanguageServerManager( + serviceContainer, + analysisOptions, + languageServerProxy, + commandManager, + ); + + await manager.start(undefined, { path: 'python' } as PythonEnvironment); + (languageServerProxy.start as sinon.SinonStub).resetHistory(); + (languageServerProxy.stop as sinon.SinonStub).resetHistory(); + + let concurrentStarts = 0; + let maxConcurrentStarts = 0; + + (languageServerProxy.start as sinon.SinonStub).callsFake(async () => { + concurrentStarts += 1; + maxConcurrentStarts = Math.max(maxConcurrentStarts, concurrentStarts); + await new Promise((resolve) => setTimeout(resolve, 10)); + concurrentStarts -= 1; + }); + + // Trigger two restarts concurrently + const p1 = registeredCommandHandler!(); + const p2 = registeredCommandHandler!(); + + await Promise.all([p1, p2]); + + // They should run sequentially, never exceeding 1 concurrent start + assert.strictEqual(maxConcurrentStarts, 1); + assert.strictEqual((languageServerProxy.stop as sinon.SinonStub).callCount, 2); + assert.strictEqual((languageServerProxy.start as sinon.SinonStub).callCount, 2); + + manager.dispose(); + }); + }); + + suite('JediLanguageServerProxy', () => { + test('Stops and disposes client if stop() is called while start() is awaiting', async () => { + let startCalled = false; + let stopCalled = false; + let disposeCalled = false; + + const fakeClient = ({ + _serverProcess: { pid: 12345 }, + onNotification: () => ({ dispose: () => {} }), + start: async () => { + startCalled = true; + // Simulate delay during client.start() + await new Promise((resolve) => setTimeout(resolve, 20)); + }, + stop: async () => { + stopCalled = true; + }, + dispose: async () => { + disposeCalled = true; + }, + } as unknown) as LanguageClient; + + const clientFactory: ILanguageClientFactory = { + createLanguageClient: sandbox.stub().resolves(fakeClient), + }; + + const proxy = new JediLanguageServerProxy(clientFactory); + + // Trigger start + const startPromise = proxy.start(undefined, undefined, {} as LanguageClientOptions); + + // Call stop while start() is in flight + await new Promise((resolve) => setTimeout(resolve, 5)); + await proxy.stop(); + + await startPromise; + + assert.strictEqual(startCalled, true); + assert.strictEqual(stopCalled, true); + assert.strictEqual(disposeCalled, true); + }); + }); +});