Added coursier installation support for mac based environments (#38)

OpenJDK java does not appear on mac based system
https://get-coursier.io/docs/cli-java#managed-jvms in managed jvm.
Also the installation URL are different for Mac
https://get-coursier.io/docs/cli-installation#native-launcher

Here depending on the OS architecture we decide which coursier url and
java version to pick.

For test we use `proxyquire` as dependency to mock os environment.

Updated yarn lock file and changed the rule prefixes from `node/` to
`n/` to match the current naming convention of the eslint-plugin-n
package (formerly eslint-plugin-node)


Test:

Tested the installation on mac and linux environments
Also checked test runs there

Author: shuklahy

.eslintrc.json

@@ -1,12 +1,13 @@
 {
   "extends": "./node_modules/gts/",
   "rules": {
-    "node/no-unpublished-import": 0,
-    "node/no-extraneous-import": 0,
+    "n/no-unpublished-import": 0,
+    "n/no-unpublished-require": 0,
+    "n/no-extraneous-import": 0,
+    "n/no-process-exit": 0,
     "eqeqeq": 0,
     "@typescript-eslint/no-explicit-any": 0,
     "@typescript-eslint/no-unused-vars": 0,
-    "prefer-const": 0,
-    "no-process-exit": 0
+    "prefer-const": 0
   }
 }

package.json

@@ -128,15 +128,18 @@
   "devDependencies": {
     "@types/mocha": "^10.0.6",
     "@types/node": "18.x",
+    "@types/proxyquire": "^1.3.31",
     "@types/vscode": "^1.89.0",
     "@typescript-eslint/eslint-plugin": "^5.50.0",
     "@typescript-eslint/parser": "^7.0.2",
     "@vscode/test-cli": "^0.0.6",
     "@vscode/test-electron": "^2.3.9",
     "eslint": "^8.56.0",
+    "eslint-plugin-n": "^17.16.1",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^5.0.0",
     "gts": "^5.2.0",
+    "proxyquire": "^2.1.3",
     "sinon": "^15.1.0",
     "typescript": "4.9",
     "vsce": "^2.15.0"

src/server/install.ts

@@ -5,7 +5,6 @@ import * as os from 'os'
 import * as axios from 'axios'
 import * as vscode from 'vscode'
 import {Inject} from '@nestjs/common'
-
 import {Utils} from '../utils/utils'
 import {
   EXTENSION_CONTEXT_TOKEN,
@@ -21,7 +20,13 @@ export const INSTALL_BSP_COMMAND = 'bazelbsp.install'
 
 const MAVEN_PACKAGE = 'org.jetbrains.bsp:bazel-bsp'
 const INSTALL_METHOD = 'org.jetbrains.bsp.bazel.install.Install'
-const COURSIER_URL = 'https://git.io/coursier-cli'
+const COURSIER_URL_DEFAULT = 'https://git.io/coursier-cli'
+const COURSIER_URL_APPLE_SILICON =
+  'https://github.com/coursier/coursier/releases/latest/download/cs-aarch64-apple-darwin.gz'
+const COURSIER_URL_APPLE_INTEL =
+  'https://github.com/coursier/launchers/raw/master/cs-x86_64-apple-darwin.gz'
+const OPEN_JDK_JAVA_17 = 'openjdk:1.17.0'
+const TEMURIN_JAVA_17 = 'temurin:1.17.0.0'
 
 export interface InstallConfig {
   bazelProjectFilePath: string
@@ -121,13 +126,30 @@ export class BazelBSPInstaller {
     const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'coursier-'))
     const coursierPath = path.join(tempDir, 'coursier')
 
-    this.outputChannel.appendLine(`Downloading Coursier from ${COURSIER_URL}`)
+    let coursierUrl: string
+    coursierUrl =
+      os.platform() === 'darwin'
+        ? os.arch() === 'arm64'
+          ? COURSIER_URL_APPLE_SILICON
+          : COURSIER_URL_APPLE_INTEL
+        : COURSIER_URL_DEFAULT
+
+    this.outputChannel.appendLine(`Downloading Coursier from ${coursierUrl}`)
+
     try {
-      const response = await axios.default.get(COURSIER_URL, {
+      const response = await axios.default.get(coursierUrl, {
         responseType: 'arraybuffer',
       })
 
-      await fs.writeFile(coursierPath, response.data)
+      let fileData = response.data
+
+      // Decompress if downloading a gzipped file
+      if (coursierUrl.endsWith('.gz')) {
+        this.outputChannel.appendLine('Using gzipped Coursier')
+        fileData = await Utils.gunzip(fileData)
+      }
+
+      await fs.writeFile(coursierPath, fileData)
       await fs.chmod(coursierPath, 0o755)
     } catch (e) {
       this.outputChannel.appendLine(`Failed to download Coursier: ${e}`)
@@ -168,8 +190,10 @@ export class BazelBSPInstaller {
       .map(([key, value]) => `${key} "${value}"`)
       .join(' ')
 
-    // Full install command including flags.
-    const installCommand = `"${coursierPath}" launch --jvm openjdk:1.17.0 ${MAVEN_PACKAGE}:${config.serverVersion} -M ${INSTALL_METHOD} -- ${flagsString}`
+    const javaVersion =
+      os.platform() === 'darwin' ? TEMURIN_JAVA_17 : OPEN_JDK_JAVA_17
+    this.outputChannel.appendLine(`Using Java version: ${javaVersion}`)
+    const installCommand = `"${coursierPath}" launch --jvm ${javaVersion} ${MAVEN_PACKAGE}:${config.serverVersion} -M ${INSTALL_METHOD} -- ${flagsString}`
 
     // Report progress in output channel.
     const installProcess = cp.spawn(installCommand, {cwd: root, shell: true})

src/test/suite/install.test.ts

@@ -8,6 +8,8 @@ import * as bsp from '../../bsp/bsp'
 import * as axios from 'axios'
 import fs from 'fs/promises'
 import cp from 'child_process'
+import * as zlib from 'zlib'
+const proxyquire = require('proxyquire')
 
 import {BazelBSPBuildClient} from '../../test-explorer/client'
 import {
@@ -29,34 +31,22 @@ suite('BSP Installer', () => {
   let sampleConn: MessageConnection
   let clientOutputChannel: vscode.LogOutputChannel
   let spawnStub: sinon.SinonStub
+  let osMock: any
 
   const sandbox = sinon.createSandbox()
 
-  beforeEach(async () => {
-    let process = cp.spawn('echo')
-    spawnStub = sandbox.stub(cp, 'spawn').returns(process)
+  interface InstallTestConfig {
+    platform: string
+    arch: string
+    isGzipped: boolean
+    javaVersion: string
+  }
 
-    // Return a fixed workspace root to avoid impact of local environment.
-    sandbox.stub(Utils, 'getWorkspaceGitRoot').resolves('/repo/root')
+  const setupInstallTest = (config: InstallTestConfig) => {
+    // Set up OS mock values
+    osMock.platform = () => config.platform
+    osMock.arch = () => config.arch
 
-    // Set up the testing app which includes injected dependnecies and the stubbed BuildServerManager
-    ctx = {subscriptions: []} as unknown as vscode.ExtensionContext
-    const moduleRef = await Test.createTestingModule({
-      providers: [
-        outputChannelProvider,
-        contextProviderFactory(ctx),
-        BazelBSPInstaller,
-      ],
-    }).compile()
-    bazelBSPInstaller = moduleRef.get(BazelBSPInstaller)
-  })
-
-  afterEach(() => {
-    sandbox.restore()
-  })
-
-  test('spawn install process', async () => {
-    // User selection to install BSP
     sandbox
       .stub(vscode.window, 'showErrorMessage')
       .resolves({title: 'Install BSP'})
@@ -80,29 +70,113 @@ load("@rules_python//python:defs.bzl", "PyInfo", "PyRuntimeInfo")
 load("//aspects:utils/utils.bzl", "create_struct", "file_location", "to_file_location")`
     )
 
-    // Simulated data returned by coursier download request.
-    const sampleData = 'sample data'
-    sandbox.stub(axios.default, 'get').resolves({data: sampleData} as any)
+    const originalData = 'sample data'
+    const responseData = config.isGzipped
+      ? zlib.gzipSync(Buffer.from(originalData))
+      : originalData
 
-    const writeFileSpy = sandbox.spy(fs, 'writeFile')
-    const installResult = await bazelBSPInstaller.install()
+    sandbox.stub(axios.default, 'get').resolves({
+      data: responseData,
+    } as any)
 
-    // Confirm that the coursier data was written to a file.
-    const coursierPath = writeFileSpy.getCalls()[0].args[0]
-    const writtenData = writeFileSpy.getCalls()[0].args[1]
-    assert.equal(writtenData, sampleData)
-    assert.equal(spawnStub.callCount, 1)
+    return {originalData}
+  }
 
-    // Just confirm that coursier path was part of the spawn call, to leave flexibility for other changes to the command.
-    assert.ok(spawnStub.getCalls()[0].args[0].includes(coursierPath))
-    assert.ok(spawnStub.getCalls()[0].args[0].includes('--jvm openjdk:1.17.0'))
-    assert.ok(installResult)
+  beforeEach(async () => {
+    let process = cp.spawn('echo')
+    spawnStub = sandbox.stub(cp, 'spawn').returns(process)
+    sandbox.stub(Utils, 'getWorkspaceGitRoot').resolves('/repo/root')
+
+    osMock = {
+      platform: () => 'darwin',
+      arch: () => 'arm64',
+    }
+
+    // Use proxyquire to inject the OS mock
+    const BazelBSPInstallerProxy = proxyquire('../../server/install', {
+      os: osMock,
+    }).BazelBSPInstaller
+
+    ctx = {subscriptions: []} as unknown as vscode.ExtensionContext
+    const moduleRef = await Test.createTestingModule({
+      providers: [
+        outputChannelProvider,
+        contextProviderFactory(ctx),
+        {
+          provide: BazelBSPInstaller,
+          useClass: BazelBSPInstallerProxy,
+        },
+      ],
+    }).compile()
+    bazelBSPInstaller = moduleRef.get(BazelBSPInstaller)
+  })
 
-    const updatedContents = writeFileSpy.getCalls()[1].args[1]
-    const expectedContents = `load("@rules_python//python:defs.bzl", "PyInfo", "PyRuntimeInfo")
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  const testConfigs: {[key: string]: InstallTestConfig} = {
+    macArm64: {
+      platform: 'darwin',
+      arch: 'arm64',
+      isGzipped: true,
+      javaVersion: 'temurin:1.17.0.0',
+    },
+    macIntel: {
+      platform: 'darwin',
+      arch: 'x64',
+      isGzipped: true,
+      javaVersion: 'temurin:1.17.0.0',
+    },
+    linux: {
+      platform: 'linux',
+      arch: 'x64',
+      isGzipped: false,
+      javaVersion: 'openjdk:1.17.0',
+    },
+  }
+
+  Object.entries(testConfigs).forEach(([name, config]) => {
+    test(`spawn install process - ${name}`, async () => {
+      const {originalData} = setupInstallTest(config)
+
+      const writeFileSpy = sandbox.spy(fs, 'writeFile')
+      const chmodSpy = sandbox.spy(fs, 'chmod')
+      const installResult = await bazelBSPInstaller.install()
+
+      // Verify coursier download and permissions
+      assert.equal(writeFileSpy.callCount, 2)
+      const coursierPath = writeFileSpy.getCalls()[0].args[0]
+      const writtenData = writeFileSpy.getCalls()[0].args[1]
+
+      if (config.isGzipped) {
+        assert.equal(writtenData.toString(), originalData)
+      } else {
+        assert.equal(writtenData, originalData)
+      }
+
+      assert.equal(chmodSpy.callCount, 1)
+      assert.equal(chmodSpy.getCalls()[0].args[0], coursierPath)
+      assert.equal(chmodSpy.getCalls()[0].args[1], 0o755)
+
+      // Verify spawn command
+      const updatedContents = writeFileSpy.getCalls()[1].args[1]
+      const expectedContents = `load("@rules_python//python:defs.bzl", "PyInfo", "PyRuntimeInfo")
 
 load("//aspects:utils/utils.bzl", "create_struct", "file_location", "to_file_location")`
-    assert.equal(updatedContents, expectedContents)
+
+      assert.equal(updatedContents, expectedContents)
+      assert.equal(spawnStub.callCount, 1)
+      const spawnCall = spawnStub.getCalls()[0]
+      assert.ok(spawnCall.args[0].includes(coursierPath))
+      assert.ok(spawnCall.args[0].includes(`--jvm ${config.javaVersion}`))
+      assert.ok(spawnCall.args[0].includes('org.jetbrains.bsp:bazel-bsp:2.0.0'))
+      assert.deepStrictEqual(spawnCall.args[1], {
+        cwd: '/repo/root',
+        shell: true,
+      })
+      assert.ok(installResult)
+    })
   })
 
   test('failed coursier download', async () => {

src/test/suite/utils.test.ts

@@ -2,6 +2,7 @@ import * as vscode from 'vscode'
 import * as assert from 'assert'
 import sinon from 'sinon'
 import {afterEach} from 'mocha'
+import * as zlib from 'zlib'
 
 import {Deferred, Utils} from '../../utils/utils'
 
@@ -99,6 +100,25 @@ suite('Utils Test Suite', () => {
       )
     })
   })
+
+  test('gunzip successful decompression', async () => {
+    const originalData = 'Hello, World!'
+    const compressedData = zlib.gzipSync(Buffer.from(originalData))
+
+    const result = await Utils.gunzip(compressedData)
+    assert.strictEqual(result.toString(), originalData)
+  })
+
+  test('gunzip handles invalid data', async () => {
+    const invalidData = Buffer.from('not compressed data')
+
+    try {
+      await Utils.gunzip(invalidData)
+      assert.fail('Should have thrown an error')
+    } catch (error) {
+      assert.ok(error instanceof Error)
+    }
+  })
 })
 
 suite('Deferred Promise Test Suite', () => {

src/utils/utils.ts

@@ -3,6 +3,7 @@ import * as path from 'path'
 import {promisify} from 'util'
 import {exec} from 'child_process'
 import * as fs from 'fs/promises'
+import * as zlib from 'zlib'
 
 const execAsync = promisify(exec)
 
@@ -55,6 +56,15 @@ export class Utils {
     return Utils.getGitRootFromPath(workspaceRoot.fsPath)
   }
 
+  static async gunzip(data: Buffer): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      zlib.gunzip(data, (err, result) => {
+        if (err) reject(err)
+        else resolve(result)
+      })
+    })
+  }
+
   // Use wrapped file i/o operations for use in stubbing.
   static async readdir(path: string): Promise<string[]> {
     return fs.readdir(path)