Merge #3629

3629: Alternative aproach to plugin auto update r=matklad a=matklad

This is very much WIP (as in, I haven't run this once), but I like the result so far.

cc @Veetaha 

The primary focus here on simplification:

* local simplification of data structures and control-flow: using union of strings instead of an enum, using unwrapped GitHub API responses
* global simplification of control flow: all logic is now in `main.ts`, implemented as linear functions without abstractions. This is stateful side-effective code, so arguments from [Carmack](http://number-none.com/blow/john_carmack_on_inlined_code.html) very much apply. We need all user interractions, all mutations, and all network requests to happen in a single file. 
* as a side-effect of condensing everything to functions, we can get rid of various enums. The enums were basically a reified control flow:

```
enum E { A, B }

fn foo() -> E {
    if cond { E::A } else { E::B }
}

fn bar(e: E) {
    match e {
        E::A => do_a(),
        E::B => do_b(),
    }
}

==>>

fn all() {
    if cond { do_a() } else { do_b() }
}
```

* simplification of model: we don't need to reinstall on settings update, we can just ask the user to reload, we don't need to handle nightly=>stable fallback, we can ask the user to reinstall extension, (todo) we don't need to parse out the date from the version, we can use build id for nightly and for stable we can write the info directly into package.json.

Co-authored-by: Aleksey Kladov <[email protected]>

1 files changed, 138 insertions, 20 deletions

diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 94ecd4dab..d907f3e6f 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -1,15 +1,18 @@
 import * as vscode from 'vscode';
+import * as path from "path";
+import * as os from "os";
+import { promises as fs } from "fs";
 
 import * as commands from './commands';
 import { activateInlayHints } from './inlay_hints';
 import { activateStatusDisplay } from './status_display';
 import { Ctx } from './ctx';
 import { activateHighlighting } from './highlighting';
-import { ensureServerBinary } from './installation/server';
-import { Config } from './config';
-import { log } from './util';
-import { ensureProperExtensionVersion } from './installation/extension';
+import { Config, NIGHTLY_TAG } from './config';
+import { log, assert } from './util';
 import { PersistentState } from './persistent_state';
+import { fetchRelease, download } from './net';
+import { spawnSync } from 'child_process';
 
 let ctx: Ctx | undefined;
 
@@ -35,27 +38,14 @@ export async function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(defaultOnEnter);
 
     const config = new Config(context);
-    const state = new PersistentState(context);
-
-    vscode.workspace.onDidChangeConfiguration(() => ensureProperExtensionVersion(config, state).catch(log.error));
-
-    // Don't await the user response here, otherwise we will block the lsp server bootstrap
-    void ensureProperExtensionVersion(config, state).catch(log.error);
-
-    const serverPath = await ensureServerBinary(config, state);
-
-    if (serverPath == null) {
-        throw new Error(
-            "Rust Analyzer Language Server is not available. " +
-            "Please, ensure its [proper installation](https://rust-analyzer.github.io/manual.html#installation)."
-        );
-    }
+    const state = new PersistentState(context.globalState);
+    const serverPath = await bootstrap(config, state);
 
     // Note: we try to start the server before we activate type hints so that it
     // registers its `onDidChangeDocument` handler before us.
     //
     // This a horribly, horribly wrong way to deal with this problem.
-    ctx = await Ctx.create(config, state, context, serverPath);
+    ctx = await Ctx.create(config, context, serverPath);
 
     // Commands which invokes manually via command palette, shortcut, etc.
     ctx.registerCommand('reload', (ctx) => {
@@ -109,3 +99,131 @@ export async function deactivate() {
     await ctx?.client?.stop();
     ctx = undefined;
 }
+
+async function bootstrap(config: Config, state: PersistentState): Promise<string> {
+    await fs.mkdir(config.globalStoragePath, { recursive: true });
+
+    await bootstrapExtension(config, state);
+    const path = await bootstrapServer(config, state);
+
+    return path;
+}
+
+async function bootstrapExtension(config: Config, state: PersistentState): Promise<void> {
+    if (config.channel === "stable") {
+        if (config.extensionReleaseTag === NIGHTLY_TAG) {
+            vscode.window.showWarningMessage(`You are running a nightly version of rust-analyzer extension.
+To switch to stable, uninstall the extension and re-install it from the marketplace`);
+        }
+        return;
+    };
+
+    const lastCheck = state.lastCheck;
+    const now = Date.now();
+
+    const anHour = 60 * 60 * 1000;
+    const shouldDownloadNightly = state.releaseId === undefined || (now - (lastCheck ?? 0)) > anHour;
+
+    if (!shouldDownloadNightly) return;
+
+    const release = await fetchRelease("nightly").catch((e) => {
+        log.error(e);
+        if (state.releaseId === undefined) { // Show error only for the initial download
+            vscode.window.showErrorMessage(`Failed to download rust-analyzer nightly ${e}`);
+        }
+        return undefined;
+    });
+    if (release === undefined || release.id === state.releaseId) return;
+
+    const userResponse = await vscode.window.showInformationMessage(
+        "New version of rust-analyzer (nightly) is available (requires reload).",
+        "Update"
+    );
+    if (userResponse !== "Update") return;
+
+    const artifact = release.assets.find(artifact => artifact.name === "rust-analyzer.vsix");
+    assert(!!artifact, `Bad release: ${JSON.stringify(release)}`);
+
+    const dest = path.join(config.globalStoragePath, "rust-analyzer.vsix");
+    await download(artifact.browser_download_url, dest, "Downloading rust-analyzer extension");
+
+    await vscode.commands.executeCommand("workbench.extensions.installExtension", vscode.Uri.file(dest));
+    await fs.unlink(dest);
+
+    await state.updateReleaseId(release.id);
+    await state.updateLastCheck(now);
+    await vscode.commands.executeCommand("workbench.action.reloadWindow");
+}
+
+async function bootstrapServer(config: Config, state: PersistentState): Promise<string> {
+    const path = await getServer(config, state);
+    if (!path) {
+        throw new Error(
+            "Rust Analyzer Language Server is not available. " +
+            "Please, ensure its [proper installation](https://rust-analyzer.github.io/manual.html#installation)."
+        );
+    }
+
+    const res = spawnSync(path, ["--version"], { encoding: 'utf8' });
+    log.debug("Checked binary availability via --version", res);
+    log.debug(res, "--version output:", res.output);
+    if (res.status !== 0) {
+        throw new Error(
+            `Failed to execute ${path} --version`
+        );
+    }
+
+    return path;
+}
+
+async function getServer(config: Config, state: PersistentState): Promise<string | undefined> {
+    const explicitPath = process.env.__RA_LSP_SERVER_DEBUG ?? config.serverPath;
+    if (explicitPath) {
+        if (explicitPath.startsWith("~/")) {
+            return os.homedir() + explicitPath.slice("~".length);
+        }
+        return explicitPath;
+    };
+
+    let binaryName: string | undefined = undefined;
+    if (process.arch === "x64" || process.arch === "x32") {
+        if (process.platform === "linux") binaryName = "rust-analyzer-linux";
+        if (process.platform === "darwin") binaryName = "rust-analyzer-mac";
+        if (process.platform === "win32") binaryName = "rust-analyzer-windows.exe";
+    }
+    if (binaryName === undefined) {
+        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 undefined;
+    }
+
+    const dest = path.join(config.globalStoragePath, binaryName);
+    const exists = await fs.stat(dest).then(() => true, () => false);
+    if (!exists) {
+        await state.updateServerVersion(undefined);
+    }
+
+    if (state.serverVersion === config.packageJsonVersion) return dest;
+
+    if (config.askBeforeDownload) {
+        const userResponse = await vscode.window.showInformationMessage(
+            `Language server version ${config.packageJsonVersion} for rust-analyzer is not installed.`,
+            "Download now"
+        );
+        if (userResponse !== "Download now") return dest;
+    }
+
+    const release = await fetchRelease(config.extensionReleaseTag);
+    const artifact = release.assets.find(artifact => artifact.name === binaryName);
+    assert(!!artifact, `Bad release: ${JSON.stringify(release)}`);
+
+    await download(artifact.browser_download_url, dest, "Downloading rust-analyzer server", { mode: 0o755 });
+    await state.updateServerVersion(config.packageJsonVersion);
+    return dest;
+}