vscode: amended config to use binary from globalStoragePath, added ui for downloading

4 files changed, 218 insertions, 0 deletions

diff --git a/editors/code/src/installation/download_file.ts b/editors/code/src/installation/download_file.ts
new file mode 100644
index 000000000..7b537e114
--- /dev/null
+++ b/editors/code/src/installation/download_file.ts
@@ -0,0 +1,26 @@
+import fetch from "node-fetch";
+import { throttle } from "throttle-debounce";
+import * as fs from "fs";
+
+export async function downloadFile(
+    url: string,
+    destFilePath: fs.PathLike,
+    onProgress: (readBytes: number, totalBytes: number) => void
+): Promise<void> {
+    onProgress = throttle(1000, /* noTrailing: */ true, onProgress);
+
+    const response = await fetch(url);
+
+    const totalBytes = Number(response.headers.get('content-length'));
+    let readBytes = 0;
+
+    return new Promise<void>((resolve, reject) => response.body
+        .on("data", (chunk: Buffer) => {
+            readBytes += chunk.length;
+            onProgress(readBytes, totalBytes);
+        })
+        .on("end", resolve)
+        .on("error", reject)
+        .pipe(fs.createWriteStream(destFilePath))
+    );
+}
diff --git a/editors/code/src/installation/fetch_latest_artifact_metadata.ts b/editors/code/src/installation/fetch_latest_artifact_metadata.ts
new file mode 100644
index 000000000..f07431aac
--- /dev/null
+++ b/editors/code/src/installation/fetch_latest_artifact_metadata.ts
@@ -0,0 +1,47 @@
+import fetch from "node-fetch";
+import { GithubRepo, ArtifactMetadata } from "./interfaces";
+
+const GITHUB_API_ENDPOINT_URL = "https://api.github.com";
+
+export interface FetchLatestArtifactMetadataOpts {
+    repo: GithubRepo;
+    artifactFileName: string;
+}
+
+export async function fetchLatestArtifactMetadata(
+    opts: FetchLatestArtifactMetadataOpts
+): Promise<null | ArtifactMetadata> {
+
+    const repoOwner = encodeURIComponent(opts.repo.owner);
+    const repoName  = encodeURIComponent(opts.repo.name);
+
+    const apiEndpointPath = `/repos/${repoOwner}/${repoName}/releases/latest`;
+    const requestUrl = GITHUB_API_ENDPOINT_URL + apiEndpointPath;
+
+    // We skip runtime type checks for simplicity (here we cast from `any` to `Release`)
+
+    const response: GithubRelease = await fetch(requestUrl, {
+            headers: { Accept: "application/vnd.github.v3+json" }
+        })
+        .then(res => res.json());
+
+    const artifact = response.assets.find(artifact => artifact.name === opts.artifactFileName);
+
+    return !artifact ? null : {
+        releaseName: response.name,
+        downloadUrl: artifact.browser_download_url
+    };
+
+    // Noise denotes tremendous amount of data that we are not using here
+    interface GithubRelease {
+        name: string;
+        assets: Array<{
+            browser_download_url: string;
+
+            [noise: string]: unknown;
+        }>;
+
+        [noise: string]: unknown;
+    }
+
+}
diff --git a/editors/code/src/installation/interfaces.ts b/editors/code/src/installation/interfaces.ts
new file mode 100644
index 000000000..f54e24e26
--- /dev/null
+++ b/editors/code/src/installation/interfaces.ts
@@ -0,0 +1,26 @@
+export interface GithubRepo {
+    name: string;
+    owner: string;
+}
+
+export interface ArtifactMetadata {
+    releaseName: string;
+    downloadUrl: string;
+}
+
+
+export enum BinarySourceType { ExplicitPath, GithubBinary }
+
+export type BinarySource = EplicitPathSource | GithubBinarySource;
+
+export interface EplicitPathSource {
+    type: BinarySourceType.ExplicitPath;
+    path: string;
+}
+
+export interface GithubBinarySource {
+    type: BinarySourceType.GithubBinary;
+    repo: GithubRepo;
+    dir: string;
+    file: string;
+}
diff --git a/editors/code/src/installation/language_server.ts b/editors/code/src/installation/language_server.ts
new file mode 100644
index 000000000..2b3ce6621
--- /dev/null
+++ b/editors/code/src/installation/language_server.ts
@@ -0,0 +1,119 @@
+import { unwrapNotNil } from "ts-not-nil";
+import { spawnSync } from "child_process";
+import * as vscode from "vscode";
+import * as path from "path";
+import { strict as assert } from "assert";
+import { promises as fs } from "fs";
+
+import { BinarySource, BinarySourceType, GithubBinarySource } from "./interfaces";
+import { fetchLatestArtifactMetadata } from "./fetch_latest_artifact_metadata";
+import { downloadFile } from "./download_file";
+
+export async function downloadLatestLanguageServer(
+    {file: artifactFileName, dir: installationDir, repo}: GithubBinarySource
+) {
+    const binaryMetadata = await fetchLatestArtifactMetadata({ artifactFileName, repo });
+
+    const {
+        releaseName,
+        downloadUrl
+    } = unwrapNotNil(binaryMetadata, `Latest GitHub release lacks "${artifactFileName}" file`);
+
+    await fs.mkdir(installationDir).catch(err => assert.strictEqual(
+        err && err.code,
+        "EEXIST",
+        `Couldn't create directory "${installationDir}" to download `+
+        `language server binary: ${err.message}`
+    ));
+
+    const installationPath = path.join(installationDir, artifactFileName);
+
+    await vscode.window.withProgress(
+        {
+            location: vscode.ProgressLocation.Notification,
+            cancellable: false, // FIXME: add support for canceling download?
+            title: `Downloading language server ${releaseName}`
+        },
+        async (progress, _) => {
+            let lastPrecentage = 0;
+            await downloadFile(downloadUrl, installationPath, (readBytes, totalBytes) => {
+                const newPercentage = (readBytes / totalBytes) * 100;
+                progress.report({
+                    message: newPercentage.toFixed(0) + "%",
+                    increment: newPercentage - lastPrecentage
+                });
+
+                lastPrecentage = newPercentage;
+            });
+        }
+    );
+
+    await fs.chmod(installationPath, 111); // Set xxx permissions
+}
+export async function ensureLanguageServerBinary(
+    langServerSource: null | BinarySource
+): Promise<null | string> {
+
+    if (!langServerSource) {
+        vscode.window.showErrorMessage(
+            "Unfortunately we don't ship binaries for your platform yet. " +
+            "You need to manually clone rust-analyzer repository and " +
+            "run `cargo xtask install --server` to build the language server from sources. " +
+            "If you feel that your platform should be supported, please create an issue " +
+            "about that [here](https://github.com/rust-analyzer/rust-analyzer/issues) and we " +
+            "will consider it."
+        );
+        return null;
+    }
+
+    switch (langServerSource.type) {
+        case BinarySourceType.ExplicitPath: {
+            if (isBinaryAvailable(langServerSource.path)) {
+                return langServerSource.path;
+            }
+            vscode.window.showErrorMessage(
+                `Unable to execute ${'`'}${langServerSource.path} --version${'`'}. ` +
+                "To use the bundled language server, set `rust-analyzer.raLspServerPath` " +
+                "value to `null` or remove it from the settings to use it by default."
+            );
+            return null;
+        }
+        case BinarySourceType.GithubBinary: {
+            const bundledBinaryPath = path.join(langServerSource.dir, langServerSource.file);
+
+            if (!isBinaryAvailable(bundledBinaryPath)) {
+                const userResponse = await vscode.window.showInformationMessage(
+                    `Language server binary for rust-analyzer was not found. ` +
+                    `Do you want to download it now?`,
+                    "Download now", "Cancel"
+                );
+                if (userResponse !== "Download now") return null;
+
+                try {
+                    await downloadLatestLanguageServer(langServerSource);
+                } catch (err) {
+                    await vscode.window.showErrorMessage(
+                        `Failed to download language server from ${langServerSource.repo.name} ` +
+                        `GitHub repository: ${err.message}`
+                    );
+                    return null;
+                }
+
+
+                assert(
+                    isBinaryAvailable(bundledBinaryPath),
+                    "Downloaded language server binary is not functional"
+                );
+
+                vscode.window.showInformationMessage(
+                    "Rust analyzer language server was successfully installed"
+                );
+            }
+            return bundledBinaryPath;
+        }
+    }
+
+    function isBinaryAvailable(binaryPath: string) {
+        return spawnSync(binaryPath, ["--version"]).status === 0;
+    }
+}