Allow LS to be bundled, versioned (#12034)

Co-authored-by: Eric Snow <ericsnowcurrently@gmail.com>

Author: jakebailey

.gitignore

@@ -42,4 +42,4 @@ ptvsd*.log
 pydevd*.log
 nodeLanguageServer/**
 nodeLanguageServer.*/**
-
+bundledLanguageServer/**

.vscodeignore

@@ -58,6 +58,8 @@ webpack.datascience-*.config.js
 .vscode test/**
 languageServer/**
 languageServer.*/**
+nodeLanguageServer/**
+nodeLanguageServer.*/**
 bin/**
 build/**
 BuildOutput/**

src/client/activation/common/downloader.ts

@@ -14,6 +14,7 @@ import { createDeferred } from '../../common/utils/async';
 import { Common, LanguageService } from '../../common/utils/localize';
 import { StopWatch } from '../../common/utils/stopWatch';
 import { IServiceContainer } from '../../ioc/types';
+import { traceError } from '../../logging';
 import { sendTelemetryEvent } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
 import {
@@ -58,6 +59,12 @@ export class LanguageServerDownloader implements ILanguageServerDownloader {
     }
 
     public async downloadLanguageServer(destinationFolder: string, resource: Resource): Promise<void> {
+        if (this.lsFolderService.isBundled()) {
+            // Sanity check; a bundled LS should never be downloaded.
+            traceError('Attempted to download bundled language server');
+            return;
+        }
+
         const [downloadUri, lsVersion, lsName] = await this.getDownloadInfo(resource);
         const timer: StopWatch = new StopWatch();
         let success: boolean = true;

src/client/activation/common/languageServerFolderService.ts

@@ -26,6 +26,10 @@ export abstract class LanguageServerFolderService implements ILanguageServerFold
         @unmanaged() protected readonly languageServerFolder: string
     ) {}
 
+    public isBundled(): boolean {
+        return false;
+    }
+
     @traceDecorators.verbose('Get language server folder name')
     public async getLanguageServerFolderName(resource: Resource): Promise<string> {
         const currentFolder = await this.getCurrentLanguageServerDirectory();

src/client/activation/languageServer/languageServerFolderService.ts

@@ -10,7 +10,7 @@ import { LanguageServerFolderService } from '../common/languageServerFolderServi
 import { DotNetLanguageServerFolder } from '../types';
 
 // Must match languageServerVersion* keys in package.json
-const DotNetLanguageServerMinVersionKey = 'languageServerVersion';
+export const DotNetLanguageServerMinVersionKey = 'languageServerVersion';
 
 @injectable()
 export class DotNetLanguageServerFolderService extends LanguageServerFolderService {

src/client/activation/node/languageServerFolderService.ts

@@ -4,17 +4,89 @@
 'use strict';
 
 import { inject, injectable } from 'inversify';
+import * as semver from 'semver';
+import { IApplicationEnvironment, IWorkspaceService } from '../../common/application/types';
+import { NugetPackage } from '../../common/nuget/types';
+import { IConfigurationService, Resource } from '../../common/types';
 import { IServiceContainer } from '../../ioc/types';
+import { traceWarning } from '../../logging';
 import { LanguageServerFolderService } from '../common/languageServerFolderService';
-import { NodeLanguageServerFolder } from '../types';
+import {
+    BundledLanguageServerFolder,
+    FolderVersionPair,
+    ILanguageServerFolderService,
+    NodeLanguageServerFolder
+} from '../types';
 
-@injectable()
-export class NodeLanguageServerFolderService extends LanguageServerFolderService {
-    constructor(@inject(IServiceContainer) serviceContainer: IServiceContainer) {
+// Must match languageServerVersion* keys in package.json
+export const NodeLanguageServerVersionKey = 'languageServerVersionV2';
+
+class FallbackNodeLanguageServerFolderService extends LanguageServerFolderService {
+    constructor(serviceContainer: IServiceContainer) {
         super(serviceContainer, NodeLanguageServerFolder);
     }
 
     protected getMinimalLanguageServerVersion(): string {
         return '0.0.0';
     }
 }
+
+@injectable()
+export class NodeLanguageServerFolderService implements ILanguageServerFolderService {
+    private readonly _bundledVersion: semver.SemVer | undefined;
+    private readonly fallback: FallbackNodeLanguageServerFolderService;
+
+    constructor(
+        @inject(IServiceContainer) serviceContainer: IServiceContainer,
+        @inject(IConfigurationService) configService: IConfigurationService,
+        @inject(IWorkspaceService) workspaceService: IWorkspaceService,
+        @inject(IApplicationEnvironment) appEnv: IApplicationEnvironment
+    ) {
+        this.fallback = new FallbackNodeLanguageServerFolderService(serviceContainer);
+
+        // downloadLanguageServer is a bit of a misnomer; if false then this indicates that a local
+        // development copy should be run instead of a "real" build, telemetry discarded, etc.
+        // So, we require it to be true, even though in the bundled case no real download happens.
+        if (
+            configService.getSettings().downloadLanguageServer &&
+            !workspaceService.getConfiguration('python').get<string>('packageName')
+        ) {
+            const ver = appEnv.packageJson[NodeLanguageServerVersionKey] as string;
+            this._bundledVersion = semver.parse(ver) || undefined;
+            if (this._bundledVersion === undefined) {
+                traceWarning(
+                    `invalid language server version ${ver} in package.json (${NodeLanguageServerVersionKey})`
+                );
+            }
+        }
+    }
+
+    public get bundledVersion(): semver.SemVer | undefined {
+        return this._bundledVersion;
+    }
+
+    public isBundled(): boolean {
+        return this._bundledVersion !== undefined;
+    }
+
+    public async getLanguageServerFolderName(resource: Resource): Promise<string> {
+        if (this._bundledVersion) {
+            return BundledLanguageServerFolder;
+        }
+        return this.fallback.getLanguageServerFolderName(resource);
+    }
+
+    public async getLatestLanguageServerVersion(resource: Resource): Promise<NugetPackage | undefined> {
+        if (this._bundledVersion) {
+            return undefined;
+        }
+        return this.fallback.getLatestLanguageServerVersion(resource);
+    }
+
+    public async getCurrentLanguageServerDirectory(): Promise<FolderVersionPair | undefined> {
+        if (this._bundledVersion) {
+            return { path: BundledLanguageServerFolder, version: this._bundledVersion };
+        }
+        return this.fallback.getCurrentLanguageServerDirectory();
+    }
+}

src/client/activation/node/languageServerProxy.ts

@@ -79,8 +79,8 @@ export class NodeLanguageServerProxy implements ILanguageServerProxy {
         options: LanguageClientOptions
     ): Promise<void> {
         if (!this.languageClient) {
-            const lsVersion = await this.folderService.getLatestLanguageServerVersion(resource);
-            this.lsVersion = lsVersion?.version.format();
+            const directory = await this.folderService.getCurrentLanguageServerDirectory();
+            this.lsVersion = directory?.version.format();
 
             this.cancellationStrategy = new FileBasedCancellationStrategy();
             options.connectionOptions = { cancellationStrategy: this.cancellationStrategy };

src/client/activation/types.ts

@@ -72,6 +72,7 @@ export enum LanguageServerType {
 
 export const DotNetLanguageServerFolder = 'languageServer';
 export const NodeLanguageServerFolder = 'nodeLanguageServer';
+export const BundledLanguageServerFolder = 'bundledLanguageServer';
 
 // tslint:disable-next-line: interface-name
 export interface DocumentHandler {
@@ -116,6 +117,7 @@ export interface ILanguageServerFolderService {
     getLanguageServerFolderName(resource: Resource): Promise<string>;
     getLatestLanguageServerVersion(resource: Resource): Promise<NugetPackage | undefined>;
     getCurrentLanguageServerDirectory(): Promise<FolderVersionPair | undefined>;
+    isBundled(): boolean;
 }
 
 export const ILanguageServerDownloader = Symbol('ILanguageServerDownloader');

src/test/activation/languageServer/downloader.unit.test.ts

@@ -260,12 +260,29 @@ suite('Language Server Activation - Downloader', () => {
                 throw failure;
             }
         }
+        class LanguageServeBundledTest extends LanguageServerDownloader {
+            // tslint:disable-next-line:no-unnecessary-override
+            public async downloadLanguageServer(destinationFolder: string, res?: Resource): Promise<void> {
+                return super.downloadLanguageServer(destinationFolder, res);
+            }
+            // tslint:disable-next-line:no-unnecessary-override
+            public async getDownloadInfo(_res?: Resource): Promise<string[]> {
+                throw failure;
+            }
+            public async downloadFile(): Promise<string> {
+                throw failure;
+            }
+            protected async unpackArchive(_extensionPath: string, _tempFilePath: string): Promise<void> {
+                throw failure;
+            }
+        }
         let output: TypeMoq.IMock<IOutputChannel>;
         let appShell: TypeMoq.IMock<IApplicationShell>;
         let fs: TypeMoq.IMock<IFileSystem>;
         let platformData: TypeMoq.IMock<IPlatformData>;
         let languageServerDownloaderTest: LanguageServerDownloaderTest;
         let languageServerExtractorTest: LanguageServerExtractorTest;
+        let languageServerBundledTest: LanguageServeBundledTest;
         setup(() => {
             appShell = TypeMoq.Mock.ofType<IApplicationShell>(undefined, TypeMoq.MockBehavior.Strict);
             folderService = TypeMoq.Mock.ofType<ILanguageServerFolderService>(undefined, TypeMoq.MockBehavior.Strict);
@@ -293,8 +310,18 @@ suite('Language Server Activation - Downloader', () => {
                 workspaceService.object,
                 undefined as any
             );
+            languageServerBundledTest = new LanguageServeBundledTest(
+                lsOutputChannel.object,
+                undefined as any,
+                folderService.object,
+                appShell.object,
+                fs.object,
+                workspaceService.object,
+                undefined as any
+            );
         });
         test('Display error message if LS downloading fails', async () => {
+            folderService.setup((f) => f.isBundled()).returns(() => false);
             const pkg = makePkgInfo('ls', 'xyz');
             folderService.setup((f) => f.getLatestLanguageServerVersion(resource)).returns(() => Promise.resolve(pkg));
             output.setup((o) => o.appendLine(LanguageService.downloadFailedOutputMessage()));
@@ -318,6 +345,7 @@ suite('Language Server Activation - Downloader', () => {
             platformData.verifyAll();
         });
         test('Display error message if LS extraction fails', async () => {
+            folderService.setup((f) => f.isBundled()).returns(() => false);
             const pkg = makePkgInfo('ls', 'xyz');
             folderService.setup((f) => f.getLatestLanguageServerVersion(resource)).returns(() => Promise.resolve(pkg));
             output.setup((o) => o.appendLine(LanguageService.extractionFailedOutputMessage()));
@@ -340,6 +368,17 @@ suite('Language Server Activation - Downloader', () => {
             fs.verifyAll();
             platformData.verifyAll();
         });
+        test('No download if bundled', async () => {
+            folderService.setup((f) => f.isBundled()).returns(() => true);
+
+            await languageServerBundledTest.downloadLanguageServer('', resource);
+
+            folderService.verifyAll();
+            output.verifyAll();
+            appShell.verifyAll();
+            fs.verifyAll();
+            platformData.verifyAll();
+        });
     });
 });
 

src/test/activation/languageServer/languageServerFolderService.unit.test.ts

@@ -267,4 +267,15 @@ suite('Language Server Folder Service', () => {
             assert.deepEqual(result, expectedLSDirectory);
         });
     });
+
+    suite('Method isBundled()', () => {
+        setup(() => {
+            serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
+            languageServerFolderService = new DotNetLanguageServerFolderService(serviceContainer.object);
+        });
+
+        test('isBundled is false', () => {
+            expect(languageServerFolderService.isBundled()).to.be.equal(false, 'isBundled should be false');
+        });
+    });
 });