implement heuristic

Author: Hweinstock

packages/core/src/amazonq/lsp/workspaceInstaller.ts

@@ -4,33 +4,43 @@
  */
 
 import path from 'path'
-import { LspResolution, LspResolver } from '../../shared/lsp/types'
+import { LspResolution, LspResolver, LspVersion } from '../../shared/lsp/types'
 import { ManifestResolver } from '../../shared/lsp/manifestResolver'
 import { LanguageServerResolver } from '../../shared/lsp/lspResolver'
-import { Range } from 'semver'
+import { Range, sort } from 'semver'
 import { getNodeExecutableName } from '../../shared/lsp/utils/platform'
 import { fs } from '../../shared/fs/fs'
+import { partition } from '../../shared/utilities/tsUtils'
 
 const manifestUrl = 'https://aws-toolkit-language-servers.amazonaws.com/q-context/manifest.json'
 // this LSP client in Q extension is only going to work with these LSP server versions
-const supportedLspServerVersions = '0.1.32'
+export const supportedLspServerVersions = '0.1.32'
+export const lspWorkspaceName = 'AmazonQ-Workspace'
 
 export class WorkspaceLSPResolver implements LspResolver {
+    public constructor(
+        private readonly options = {
+            versionRange: new Range(supportedLspServerVersions),
+            cleanUp: true,
+        }
+    ) {}
+
     async resolve(): Promise<LspResolution> {
-        const name = 'AmazonQ-Workspace'
-        const manifest = await new ManifestResolver(manifestUrl, name).resolve()
+        const manifest = await new ManifestResolver(manifestUrl, lspWorkspaceName).resolve()
         const installationResult = await new LanguageServerResolver(
             manifest,
-            name,
-            new Range(supportedLspServerVersions)
+            lspWorkspaceName,
+            this.options.versionRange
         ).resolve()
 
         const nodeName =
             process.platform === 'win32' ? getNodeExecutableName() : `node-${process.platform}-${process.arch}`
         const nodePath = path.join(installationResult.assetDirectory, nodeName)
         await fs.chmod(nodePath, 0o755)
 
-        // TODO Cleanup old versions of language servers
+        if (this.options.cleanUp) {
+            await this.cleanUp(manifest.versions, path.dirname(installationResult.assetDirectory))
+        }
         return {
             ...installationResult,
             resourcePaths: {
@@ -42,4 +52,31 @@ export class WorkspaceLSPResolver implements LspResolver {
             },
         }
     }
+
+    private async getDownloadedVersions(downloadDirectory: string): Promise<string[]> {
+        return (await fs.readdir(downloadDirectory)).map(([f, _], __) => f)
+    }
+
+    private isDelisted(manifestVersions: LspVersion[], targetVersion: string): boolean {
+        return manifestVersions.find((v) => v.serverVersion === targetVersion)?.isDelisted ?? false
+    }
+
+    /**
+     * Delete all delisted versions and keep the two newest versions that remain
+     * @param manifest
+     * @param downloadDirectory
+     */
+    async cleanUp(manifestVersions: LspVersion[], downloadDirectory: string): Promise<void> {
+        const downloadedVersions = await this.getDownloadedVersions(downloadDirectory)
+        const [delistedVersions, remainingVersions] = partition(downloadedVersions, (v: string) =>
+            this.isDelisted(manifestVersions, v)
+        )
+        for (const v of delistedVersions) {
+            await fs.delete(path.join(downloadDirectory, v), { force: true, recursive: true })
+        }
+
+        for (const v of sort(remainingVersions).slice(0, -2)) {
+            await fs.delete(path.join(downloadDirectory, v), { force: true, recursive: true })
+        }
+    }
 }

packages/core/src/shared/lsp/lspResolver.ts

@@ -14,6 +14,7 @@ import { getApplicationSupportFolder } from '../vscode/env'
 import { createHash } from '../crypto'
 import request from '../request'
 
+export const langugeServerDefaultDir = path.join(getApplicationSupportFolder(), `aws/toolkits/language-servers`)
 export class LanguageServerResolver {
     constructor(
         private readonly manifest: Manifest,
@@ -340,8 +341,7 @@ export class LanguageServerResolver {
     }
 
     defaultDownloadFolder() {
-        const applicationSupportFolder = getApplicationSupportFolder()
-        return path.join(applicationSupportFolder, `aws/toolkits/language-servers/${this.lsName}`)
+        return path.join(langugeServerDefaultDir, `${this.lsName}`)
     }
 
     private getDownloadDirectory(version: string) {

packages/core/src/shared/utilities/tsUtils.ts

@@ -94,6 +94,15 @@ export function createFactoryFunction<T extends new (...args: any[]) => any>(cto
     return (...args) => new ctor(...args)
 }
 
+export function partition<T>(lst: T[], pred: (arg: T) => boolean): [T[], T[]] {
+    return lst.reduce(
+        ([leftAcc, rightAcc], item) => {
+            return pred(item) ? [[...leftAcc, item], rightAcc] : [leftAcc, [...rightAcc, item]]
+        },
+        [[], []] as [T[], T[]]
+    )
+}
+
 type NoSymbols<T> = { [Property in keyof T]: Property extends symbol ? never : Property }[keyof T]
 export type InterfaceNoSymbol<T> = Pick<T, NoSymbols<T>>
 /**

packages/core/src/test/amazonq/lsp/workspaceinstaller.test.ts

@@ -0,0 +1,58 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Uri } from 'vscode'
+import { fs } from '../../../shared'
+import { createTestWorkspaceFolder } from '../../testUtil'
+import path from 'path'
+import { WorkspaceLSPResolver } from '../../../amazonq/lsp/workspaceInstaller'
+import assert from 'assert'
+
+async function fakeInstallVersion(version: string, installationDir: string): Promise<void> {
+    const versionDir = path.join(installationDir, version)
+    await fs.mkdir(versionDir)
+    await fs.writeFile(path.join(versionDir, 'file.txt'), 'content')
+}
+
+describe('workspaceInstaller', function () {
+    describe('cleanUp', function () {
+        let installationDir: Uri
+        let versions: string[]
+
+        before(async function () {
+            installationDir = (await createTestWorkspaceFolder()).uri
+            versions = ['1.0.0', '1.0.1', '1.1.1', '2.1.1']
+        })
+
+        beforeEach(async function () {
+            for (const v of versions) {
+                await fakeInstallVersion(v, installationDir.fsPath)
+            }
+        })
+
+        after(async function () {
+            await fs.delete(installationDir, { force: true, recursive: true })
+        })
+        it('keeps two newest versions', async function () {
+            const wsr = new WorkspaceLSPResolver()
+            await wsr.cleanUp([], installationDir.fsPath)
+
+            const result = (await fs.readdir(installationDir.fsPath)).map(([filename, _filetype], _index) => filename)
+            assert.strictEqual(result.length, 2)
+            assert.ok(result.includes('2.1.1'))
+            assert.ok(result.includes('1.1.1'))
+        })
+
+        it('deletes delisted versions', async function () {
+            const wsr = new WorkspaceLSPResolver()
+            await wsr.cleanUp([{ serverVersion: '1.1.1', isDelisted: true, targets: [] }], installationDir.fsPath)
+
+            const result = (await fs.readdir(installationDir.fsPath)).map(([filename, _filetype], _index) => filename)
+            assert.strictEqual(result.length, 2)
+            assert.ok(result.includes('2.1.1'))
+            assert.ok(result.includes('1.0.1'))
+        })
+    })
+})

packages/core/src/testInteg/amazonq/lsp/workspaceInstaller.test.ts

@@ -0,0 +1,61 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Range } from 'semver'
+import assert from 'assert'
+import { WorkspaceLSPResolver } from '../../../amazonq/lsp/workspaceInstaller'
+import { fs } from '../../../shared/fs/fs'
+import path from 'path'
+import * as sinon from 'sinon'
+import { langugeServerDefaultDir } from '../../../shared/lsp/lspResolver'
+
+async function installVersion(version: string, cleanUp: boolean = false) {
+    const resolver = new WorkspaceLSPResolver({ versionRange: new Range(version), cleanUp: cleanUp })
+    return await resolver.resolve()
+}
+
+/**
+ * Installs all versions, only running 'cleanUp' on the last install.
+ * @param versions
+ * @returns
+ */
+async function testInstallVersions(versions: string[]) {
+    await Promise.all(versions.slice(0, -1).map(async (version) => await installVersion(version)))
+    const finalVersionResult = await installVersion(versions[versions.length - 1], true)
+    const allVersions = path.dirname(finalVersionResult.assetDirectory)
+    const versionsDownloaded = (await fs.readdir(allVersions)).map(([f, _], __) => f)
+    return versionsDownloaded
+}
+
+describe('workspaceInstaller', function () {
+    before(async function () {
+        await fs.delete(langugeServerDefaultDir, { force: true, recursive: true })
+    })
+
+    it('removes all but the latest two versions', async function () {
+        const versionsToInstall = ['0.1.25', '0.1.26', '0.1.27', '0.1.28']
+        const versionsDownloaded = await testInstallVersions(versionsToInstall)
+
+        assert.strictEqual(versionsDownloaded.length, 2)
+        assert.ok(versionsDownloaded.includes('0.1.28'))
+        assert.ok(versionsDownloaded.includes('0.1.29'))
+    })
+
+    it('removes delisted versions then keeps 2 remaining most recent', async function () {
+        const isDelisted = sinon.stub(WorkspaceLSPResolver.prototype, 'isDelisted' as any)
+        isDelisted.callsFake((_manifestVersions, version) => {
+            return version === '0.1.27' || version === '0.1.29'
+        })
+
+        const versionsToInstall = ['0.1.25', '0.1.26', '0.1.27', '0.1.28']
+        const versionsDownloaded = await testInstallVersions(versionsToInstall)
+
+        console.log(versionsDownloaded)
+        assert.strictEqual(versionsDownloaded.length, 2)
+        assert.ok(versionsDownloaded.includes('0.1.28'))
+        assert.ok(versionsDownloaded.includes('0.1.26'))
+        isDelisted.restore()
+    })
+})