Split download.ts into three files

Install code, download code, and exec code.

Author: code-asher

src/download.test.ts

@@ -1,40 +1,10 @@
-import * as assert from "assert"
+// import * as assert from "assert"
 import * as vscode from "vscode"
-import * as download from "./download"
+// import * as download from "./download"
 
 suite("Download", () => {
   vscode.window.showInformationMessage("Start download tests.")
 
-  teardown(() => {
-    delete process.env.CODER_MOCK_STATE
-  })
-
-  test("binaryExists", async () => {
-    assert.strictEqual(await download.binaryExists("sh"), true)
-    assert.strictEqual(await download.binaryExists("surely-no-binary-named-like-this-exists"), false)
-  })
-
-  test("execCoder", async () => {
-    assert.strictEqual(await download.execCoder("--help"), "help\n")
-
-    // This will attempt to authenticate first, which will fail.
-    process.env.CODER_MOCK_STATE = "fail"
-    await assert.rejects(download.execCoder("--help"), {
-      name: "Error",
-      message: /Command failed: .+ --help\nstderr message from fail state\n/,
-    })
-  })
-
-  test("install", async () => {
-    await assert.rejects(download.install("false", []), {
-      name: "Error",
-      message: `Command "false" failed with code 1`,
-    })
-    // TODO: Test successful download.
-  })
-
   // TODO: Implement.
-  test("maybeInstall")
   test("download")
-  test("maybeDownload")
 })

src/download.ts

@@ -1,85 +1,17 @@
-import * as cp from "child_process"
 import { promises as fs } from "fs"
 import * as path from "path"
-import { promisify } from "util"
 import * as vscode from "vscode"
-import * as nodeWhich from "which"
 import { requestResponse } from "./request"
-import { context, debug, extractTar, extractZip, getAssetUrl, onLine, outputChannel, wrapExit } from "./utils"
+import { debug, extractTar, extractZip, getAssetUrl } from "./utils"
 
 /**
- * Options for installing and authenticating the Coder CLI.
+ * Inner function for `download` so it can wrap with a singleton promise.
  */
-export interface CoderOptions {
-  accessUri?: string
-  token?: string
-  version?: string
-}
-
-/**
- * Return "true" if the binary is found in $PATH.
- */
-export const binaryExists = async (bin: string): Promise<boolean> => {
-  return new Promise((res) => {
-    nodeWhich(bin, (err) => res(!err))
-  })
-}
-
-/**
- * Run a command with the Coder CLI after making sure it is installed and
- * authenticated.  On success stdout is returned.  On failure the error will
- * include stderr in the message.
- */
-export const execCoder = async (command: string, opts?: CoderOptions): Promise<string> => {
-  debug(`Run command: ${command}`)
-  const coderBinary = await preflight(opts?.version)
-  const output = await promisify(cp.exec)(coderBinary + " " + command)
-  return output.stdout
-}
-
-/**
- * How to invoke the Coder CLI.
- *
- * The CODER_BINARY environment variable is meant for tests.
- */
-const coderInvocation = (): { cmd: string; args: string[] } => {
-  if (process.env.CODER_BINARY) {
-    return JSON.parse(process.env.CODER_BINARY)
-  }
-  return { cmd: process.platform === "win32" ? "coder.exe" : "coder", args: [] }
-}
-
-/**
- * Download the Coder CLI to the provided location and return that location.
- */
-export const download = async (version: string, downloadPath: string): Promise<string> => {
-  const assetUrl = getAssetUrl(version)
-  const response = await requestResponse(assetUrl)
-
-  await (assetUrl.endsWith(".tar.gz")
-    ? extractTar(response, path.dirname(downloadPath))
-    : extractZip(response, path.dirname(downloadPath)))
-
-  return downloadPath
-}
-
-/**
- * Download the Coder CLI if necessary to a temporary location and return that
- * location.  If it has already been downloaded it will be reused without regard
- * to its version (it can be updated to match later).
- */
-export const maybeDownload = async (version = "latest"): Promise<string> => {
-  const invocation = coderInvocation()
-  if (await binaryExists(invocation.cmd)) {
-    debug(`  - Found "${invocation.cmd}" on PATH`)
-    return [invocation.cmd, ...invocation.args].join(" ")
-  }
-
+const doDownload = async (version: string, downloadPath: string): Promise<string> => {
   // See if we already downloaded it.
-  const downloadPath = path.join(await context().globalStoragePath, invocation.cmd)
   try {
     await fs.access(downloadPath)
-    debug(`  - Using previously downloaded "${invocation.cmd}"`)
+    debug(`  - Using previously downloaded: ${downloadPath}`)
     return downloadPath
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   } catch (error: any) {
@@ -88,125 +20,44 @@ export const maybeDownload = async (version = "latest"): Promise<string> => {
     }
   }
 
-  debug(`  - Downloading "${invocation.cmd}" ${version}`)
+  debug(`  - Downloading ${version} to ${downloadPath}`)
   return vscode.window.withProgress(
     {
       location: vscode.ProgressLocation.Notification,
       title: `Installing Coder CLI ${version}`,
     },
-    () => download(version, downloadPath),
-  )
-}
-
-/**
- * Download then copy the Coder CLI to the specified location.
- */
-export const downloadAndInstall = async (version: string, destination: string): Promise<void> => {
-  const source = await maybeDownload(version)
-  await fs.mkdir(destination, { recursive: true })
-  await fs.rename(source, path.join(destination, "coder"))
-}
-
-/**
- * Install the Coder CLI using the provided command.
- */
-export const install = async (cmd: string, args: string[]): Promise<void> => {
-  outputChannel.show()
-  outputChannel.appendLine(cmd + " " + args.join(" "))
-
-  const proc = cp.spawn(cmd, args)
-  onLine(proc.stdout, outputChannel.appendLine.bind(outputChannel))
-  onLine(proc.stderr, outputChannel.appendLine.bind(outputChannel))
-
-  try {
-    await wrapExit(proc)
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  } catch (error: any) {
-    outputChannel.appendLine(error.message)
-    throw error
-  }
-}
-
-/**
- * Ask the user whether to install the Coder CLI if not already installed.
- *
- * Return the invocation for the binary for use with `cp.exec()`.
- *
- * @TODO Currently unused.  Should call after connecting to the workspace
- * although it might be fine to just keep using the downloaded version?
- */
-export const maybeInstall = async (version: string): Promise<string> => {
-  const invocation = coderInvocation()
-  if (await binaryExists(invocation.cmd)) {
-    return [invocation.cmd, ...invocation.args].join(" ")
-  }
-
-  const actions: string[] = []
-
-  // TODO: This will require sudo or we will need to install to a writable
-  // location and ask the user to add it to their PATH if they have not already.
-  const destination = "/usr/local/bin"
-  // actions.push(`Install to ${destination}`)
-
-  if (await binaryExists("brew")) {
-    actions.push("Install with `brew`")
-  }
-
-  if (actions.length === 0) {
-    throw new Error(`"${invocation.cmd}" not found in $PATH.`)
-  }
+    async () => {
+      const assetUrl = getAssetUrl(version)
+      const response = await requestResponse(assetUrl)
 
-  const action = await vscode.window.showInformationMessage(`"${invocation.cmd}" was not found in $PATH.`, ...actions)
-  if (!action) {
-    throw new Error(`"${invocation.cmd}" not found in $PATH.`)
-  }
+      await (assetUrl.endsWith(".tar.gz")
+        ? extractTar(response, path.dirname(downloadPath))
+        : extractZip(response, path.dirname(downloadPath)))
 
-  await vscode.window.withProgress(
-    {
-      location: vscode.ProgressLocation.Notification,
-      title: `Installing Coder CLI`,
-    },
-    async () => {
-      switch (action) {
-        case `Install to ${destination}`:
-          return downloadAndInstall(version, destination)
-        case "Install with `brew`":
-          return install("brew", ["install", "cdr/coder/coder-cli@${version}"])
-      }
+      return downloadPath
     },
   )
-
-  // See if we can now find it via the path.
-  if (await binaryExists(invocation.cmd)) {
-    return [invocation.cmd, ...invocation.args].join(" ")
-  } else {
-    throw new Error(`"${invocation.cmd}" still not found in $PATH.`)
-  }
 }
 
-/** Only one preflight request at a time. */
-let _preflight: Promise<string> | undefined
+/** Only one request at a time. */
+let promise: Promise<string> | undefined
 
 /**
- * Check that Coder is installed.  If not try installing.
- *
- * Return the appropriate invocation for the binary.
+ * Download the Coder CLI if necessary to the provided location while showing a
+ * progress bar then return that location.  If it has already been downloaded it
+ * will be reused without regard to its version (it can be updated to match
+ * later).  This function is safe to call multiple times concurrently.
  */
-export const preflight = async (version = "latest"): Promise<string> => {
-  if (!_preflight) {
-    _preflight = (async (): Promise<string> => {
+export const download = async (version: string, downloadPath: string): Promise<string> => {
+  if (!promise) {
+    promise = (async (): Promise<string> => {
       try {
-        return await maybeDownload(version)
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      } catch (error: any) {
-        throw new Error(`${error.message}. Please [install manually](https://coder.com/docs/cli/installation).`)
+        return await doDownload(version, downloadPath)
       } finally {
-        // Clear after completion so we can try again in the case of errors, if
-        // the binary is removed, etc.
-        _preflight = undefined
+        promise = undefined
       }
     })()
   }
 
-  return _preflight
+  return promise
 }

src/exec.test.ts

@@ -0,0 +1,72 @@
+import * as assert from "assert"
+import * as cp from "child_process"
+import * as vscode from "vscode"
+import * as exec from "./exec"
+
+suite("Exec", () => {
+  vscode.window.showInformationMessage("Start exec tests.")
+
+  teardown(() => {
+    delete process.env.CODER_MOCK_STATE
+  })
+
+  test("execCoder", async () => {
+    assert.strictEqual(await exec.execCoder("--help"), "help\n")
+
+    // This will attempt to authenticate first, which will fail.
+    process.env.CODER_MOCK_STATE = "fail"
+    await assert.rejects(exec.execCoder("--help"), {
+      name: "Error",
+      message: /Command failed: .+ --help\nstderr message from fail state\n/,
+    })
+  })
+
+  test("onLine", async () => {
+    // Try from zero to multiple lines.
+    const lines = ["a", "b", "d", "e"]
+    for (let i = 0; i < lines.length; ++i) {
+      // Try both ending and not ending with a newline.
+      for (const ending of ["\n", ""]) {
+        const expected = lines.slice(0, i)
+        if (ending === "\n" || i === 0) {
+          expected.push("")
+        }
+
+        // Windows requires wrapping single quotes or the `\n` becomes just `n`.
+        const arg = expected.join("\n")
+        const proc = cp.spawn("printf", [process.platform === "win32" ? `'${arg}'` : arg])
+
+        await new Promise<void>((resolve) => {
+          exec.onLine(proc.stdout, (d) => {
+            assert.strictEqual(d, expected.shift())
+            if (expected.length === 0) {
+              resolve()
+            }
+          })
+        })
+      }
+    }
+  })
+
+  test("wrapExit", async () => {
+    assert.deepStrictEqual(await exec.wrapExit(cp.spawn("printf", ["stdout"])), undefined)
+    assert.deepStrictEqual(await exec.wrapExit(cp.spawn("bash", ["-c", ">&2 printf stderr"])), undefined)
+    await assert.rejects(exec.wrapExit(cp.spawn("false")), {
+      name: "Error",
+      message: `Command "false" failed with code 1`,
+    })
+    await assert.rejects(exec.wrapExit(cp.spawn("bash", ["-c", ">&2 printf stderr && exit 42"])), {
+      name: "Error",
+      message: `Command "bash" failed with code 42: stderr`,
+    })
+    await assert.rejects(exec.wrapExit(cp.spawn("surely-no-executable-named-like-this-exists")), {
+      name: "Error",
+      message: `spawn surely-no-executable-named-like-this-exists ENOENT`,
+    })
+  })
+
+  test("binaryExists", async () => {
+    assert.strictEqual(await exec.binaryExists("sh"), true)
+    assert.strictEqual(await exec.binaryExists("surely-no-binary-named-like-this-exists"), false)
+  })
+})