Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
63 changes: 44 additions & 19 deletions src/client/activation/jedi/languageServerProxy.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -51,45 +55,66 @@ export class JediLanguageServerProxy implements ILanguageServerProxy {
this.lsVersion =
(options.middleware ? (<JediLanguageClientMiddleware>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.');
}
}

@traceDecoratorVerbose('Stopping language server')
public async stop(): Promise<void> {
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<void> {
// 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();
}
}

Expand Down
21 changes: 18 additions & 3 deletions src/client/activation/jedi/manager.ts
Original file line number Diff line number Diff line change
Expand Up @@ -31,6 +31,10 @@ export class JediLanguageServerManager implements ILanguageServerManager {

private connected = false;

private started = false;

private restartQueue: Promise<void> = Promise.resolve();

private lsVersion: string | undefined;

constructor(
Expand All @@ -43,7 +47,7 @@ export class JediLanguageServerManager implements ILanguageServerManager {
JediLanguageServerManager.commandDispose.dispose();
}
JediLanguageServerManager.commandDispose = commandManager.registerCommand(Commands.RestartLS, () => {
this.restartLanguageServer().ignoreErrors();
return this.restartLanguageServer();
});
}

Expand All @@ -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());
Expand Down Expand Up @@ -85,6 +90,7 @@ export class JediLanguageServerManager implements ILanguageServerManager {

await this.analysisOptions.initialize(resource, interpreter);
await this.startLanguageServer();
this.started = true;
}

public connect(): void {
Expand All @@ -109,8 +115,17 @@ export class JediLanguageServerManager implements ILanguageServerManager {
@traceDecoratorError('Failed to restart language server')
@traceDecoratorVerbose('Restarting language server')
protected async restartLanguageServer(): Promise<void> {
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(
Expand Down
175 changes: 175 additions & 0 deletions src/test/activation/jedi/jediLanguageServerManager.unit.test.ts
Original file line number Diff line number Diff line change
@@ -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> | void) | undefined;
let analysisOptions: ILanguageServerAnalysisOptions;
let onDidChangeEventEmitter: EventEmitter<void>;
let languageServerProxy: ILanguageServerProxy;
let serviceContainer: IServiceContainer;

setup(() => {
onDidChangeEventEmitter = new EventEmitter<void>();
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> | 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);
});
});
});