Merge #3534

3534: Feature: vscode impl nightlies download and installation r=Veetaha a=Veetaha

I need to test things more, but the core shape of the code is quite well-formed.
The main problem is that we save the release date only for nightlies and there are no means to get the release date of the stable extension (i.e. for this we would need to consult the github releases via a network request, or we would need to somehow save this info into package.json or any other file accessible from the extension code during the deployment step, but this will be very hard I guess).
So there is an invariant that the users can install nightly only from our extension and they can't do it manually, because when installing the nightly `.vsix` we actually save its release date to `globalState`

Closes: #3402

TODO:
- [x] More manual tests and documentation

cc @matklad @lnicola 

Co-authored-by: Veetaha <[email protected]>
Co-authored-by: Veetaha <[email protected]>

Author: 3 people

docs/user/readme.adoc

@@ -65,6 +65,25 @@ Note that we only support the latest version of VS Code.
 
 The extension will be updated automatically as new versions become available. It will ask your permission to download the matching language server version binary if needed.
 
+===== Nightly
+
+We ship nightly releases for VS Code. To help us out with testing the newest code and follow the bleeding edge of our `master`, please use the following config:
+
+[source,json]
+----
+{ "rust-analyzer.updates.channel": "nightly" }
+----
+
+You will be prompted to install the `nightly` extension version. Just click `Download now` and from that moment you will get automatic updates each 24 hours.
+
+If you don't want to be asked for `Download now` every day when the new nightly version is released add the following to your `settings.json`:
+[source,json]
+----
+{ "rust-analyzer.updates.askBeforeDownload": false }
+----
+
+NOTE: Nightly extension should **only** be installed via the `Download now` action from VS Code.
+
 ==== Building From Source
 
 Alternatively, both the server and the plugin can be installed from source:

editors/code/package-lock.json

@@ -6,7 +6,7 @@
     "private": true,
     "icon": "icon.png",
     "//": "The real version is in release.yaml, this one just needs to be bigger",
-    "version": "0.2.20200211-dev",
+    "version": "0.2.20200309-nightly",
     "publisher": "matklad",
     "repository": {
         "url": "https://github.com/rust-analyzer/rust-analyzer.git",
@@ -219,6 +219,19 @@
                         }
                     }
                 },
+                "rust-analyzer.updates.channel": {
+                    "type": "string",
+                    "enum": [
+                        "stable",
+                        "nightly"
+                    ],
+                    "default": "stable",
+                    "markdownEnumDescriptions": [
+                        "`\"stable\"` updates are shipped weekly, they don't contain cutting-edge features from VSCode proposed APIs but have less bugs in general",
+                        "`\"nightly\"` updates are shipped daily, they contain cutting-edge features and latest bug fixes. These releases help us get your feedback very quickly and speed up rust-analyzer development **drastically**"
+                    ],
+                    "markdownDescription": "Choose `\"nightly\"` updates to get the latest features and bug fixes every day. While `\"stable\"` releases occur weekly and don't contain cutting-edge features from VSCode proposed APIs"
+                },
                 "rust-analyzer.updates.askBeforeDownload": {
                     "type": "boolean",
                     "default": true,
@@ -235,7 +248,7 @@
                         "string"
                     ],
                     "default": null,
-                    "description": "Path to rust-analyzer executable (points to bundled binary by default)"
+                    "description": "Path to rust-analyzer executable (points to bundled binary by default). If this is set, then \"rust-analyzer.updates.channel\" setting is not used"
                 },
                 "rust-analyzer.excludeGlobs": {
                     "type": "array",

editors/code/package.json

@@ -5,7 +5,7 @@ import { spawnSync } from 'child_process';
 
 export function serverVersion(ctx: Ctx): Cmd {
     return async () => {
-        const binaryPath = await ensureServerBinary(ctx.config.serverSource);
+        const binaryPath = await ensureServerBinary(ctx.config);
 
         if (binaryPath == null) {
             throw new Error(
@@ -18,4 +18,3 @@ export function serverVersion(ctx: Ctx): Cmd {
         vscode.window.showInformationMessage('rust-analyzer version : ' + version);
     };
 }
-

editors/code/src/commands/server_version.ts

@@ -1,7 +1,7 @@
 import * as os from "os";
 import * as vscode from 'vscode';
 import { ArtifactSource } from "./installation/interfaces";
-import { log } from "./util";
+import { log, vscodeReloadWindow } from "./util";
 
 const RA_LSP_DEBUG = process.env.__RA_LSP_SERVER_DEBUG;
 
@@ -23,25 +23,40 @@ export interface CargoFeatures {
     allFeatures: boolean;
     features: string[];
 }
+
+export const enum UpdatesChannel {
+    Stable = "stable",
+    Nightly = "nightly"
+}
+
+export const NIGHTLY_TAG = "nightly";
 export class Config {
-    private static readonly rootSection = "rust-analyzer";
-    private static readonly requiresReloadOpts = [
+    readonly extensionId = "matklad.rust-analyzer";
+
+    private readonly rootSection = "rust-analyzer";
+    private readonly requiresReloadOpts = [
+        "serverPath",
         "cargoFeatures",
         "cargo-watch",
         "highlighting.semanticTokens",
         "inlayHints",
     ]
-        .map(opt => `${Config.rootSection}.${opt}`);
+        .map(opt => `${this.rootSection}.${opt}`);
 
-    private static readonly extensionVersion: string = (() => {
-        const packageJsonVersion = vscode
-            .extensions
-            .getExtension("matklad.rust-analyzer")!
-            .packageJSON
-            .version as string; // n.n.YYYYMMDD
+    readonly packageJsonVersion = vscode
+        .extensions
+        .getExtension(this.extensionId)!
+        .packageJSON
+        .version as string; // n.n.YYYYMMDD[-nightly]
+
+    /**
+     * Either `nightly` or `YYYY-MM-DD` (i.e. `stable` release)
+     */
+    readonly extensionReleaseTag: string = (() => {
+        if (this.packageJsonVersion.endsWith(NIGHTLY_TAG)) return NIGHTLY_TAG;
 
         const realVersionRegexp = /^\d+\.\d+\.(\d{4})(\d{2})(\d{2})/;
-        const [, yyyy, mm, dd] = packageJsonVersion.match(realVersionRegexp)!;
+        const [, yyyy, mm, dd] = this.packageJsonVersion.match(realVersionRegexp)!;
 
         return `${yyyy}-${mm}-${dd}`;
     })();
@@ -54,16 +69,19 @@ export class Config {
     }
 
     private refreshConfig() {
-        this.cfg = vscode.workspace.getConfiguration(Config.rootSection);
+        this.cfg = vscode.workspace.getConfiguration(this.rootSection);
         const enableLogging = this.cfg.get("trace.extension") as boolean;
         log.setEnabled(enableLogging);
-        log.debug("Using configuration:", this.cfg);
+        log.debug(
+            "Extension version:", this.packageJsonVersion,
+            "using configuration:", this.cfg
+        );
     }
 
     private async onConfigChange(event: vscode.ConfigurationChangeEvent) {
         this.refreshConfig();
 
-        const requiresReloadOpt = Config.requiresReloadOpts.find(
+        const requiresReloadOpt = this.requiresReloadOpts.find(
             opt => event.affectsConfiguration(opt)
         );
 
@@ -75,7 +93,7 @@ export class Config {
         );
 
         if (userResponse === "Reload now") {
-            vscode.commands.executeCommand("workbench.action.reloadWindow");
+            await vscodeReloadWindow();
         }
     }
 
@@ -121,8 +139,14 @@ export class Config {
         }
     }
 
+    get installedExtensionUpdateChannel(): UpdatesChannel {
+        return this.extensionReleaseTag === NIGHTLY_TAG
+            ? UpdatesChannel.Nightly
+            : UpdatesChannel.Stable;
+    }
+
     get serverSource(): null | ArtifactSource {
-        const serverPath = RA_LSP_DEBUG ?? this.cfg.get<null | string>("serverPath");
+        const serverPath = RA_LSP_DEBUG ?? this.serverPath;
 
         if (serverPath) {
             return {
@@ -135,23 +159,42 @@ export class Config {
 
         if (!prebuiltBinaryName) return null;
 
+        return this.createGithubReleaseSource(
+            prebuiltBinaryName,
+            this.extensionReleaseTag
+        );
+    }
+
+    private createGithubReleaseSource(file: string, tag: string): ArtifactSource.GithubRelease {
         return {
             type: ArtifactSource.Type.GithubRelease,
+            file,
+            tag,
             dir: this.ctx.globalStoragePath,
-            file: prebuiltBinaryName,
-            storage: this.ctx.globalState,
-            tag: Config.extensionVersion,
-            askBeforeDownload: this.cfg.get("updates.askBeforeDownload") as boolean,
             repo: {
                 name: "rust-analyzer",
                 owner: "rust-analyzer",
             }
         };
     }
 
+    get nightlyVsixSource(): ArtifactSource.GithubRelease {
+        return this.createGithubReleaseSource("rust-analyzer.vsix", NIGHTLY_TAG);
+    }
+
+    readonly installedNightlyExtensionReleaseDate = new DateStorage(
+        "installed-nightly-extension-release-date",
+        this.ctx.globalState
+    );
+    readonly serverReleaseDate = new DateStorage("server-release-date", this.ctx.globalState);
+    readonly serverReleaseTag = new Storage<null | string>("server-release-tag", this.ctx.globalState, null);
+
     // We don't do runtime config validation here for simplicity. More on stackoverflow:
     // https://stackoverflow.com/questions/60135780/what-is-the-best-way-to-type-check-the-configuration-for-vscode-extension
 
+    private get serverPath() { return this.cfg.get("serverPath") as null | string; }
+    get updatesChannel() { return this.cfg.get("updates.channel") as UpdatesChannel; }
+    get askBeforeDownload() { return this.cfg.get("updates.askBeforeDownload") as boolean; }
     get highlightingSemanticTokens() { return this.cfg.get("highlighting.semanticTokens") as boolean; }
     get highlightingOn() { return this.cfg.get("highlightingOn") as boolean; }
     get rainbowHighlightingOn() { return this.cfg.get("rainbowHighlightingOn") as boolean; }
@@ -189,3 +232,37 @@ export class Config {
     // for internal use
     get withSysroot() { return this.cfg.get("withSysroot", true) as boolean; }
 }
+
+export class Storage<T> {
+    constructor(
+        private readonly key: string,
+        private readonly storage: vscode.Memento,
+        private readonly defaultVal: T
+    ) { }
+
+    get(): T {
+        const val = this.storage.get(this.key, this.defaultVal);
+        log.debug(this.key, "==", val);
+        return val;
+    }
+    async set(val: T) {
+        log.debug(this.key, "=", val);
+        await this.storage.update(this.key, val);
+    }
+}
+export class DateStorage {
+    inner: Storage<null | string>;
+
+    constructor(key: string, storage: vscode.Memento) {
+        this.inner = new Storage(key, storage, null);
+    }
+
+    get(): null | Date {
+        const dateStr = this.inner.get();
+        return dateStr ? new Date(dateStr) : null;
+    }
+
+    async set(date: null | Date) {
+        await this.inner.set(date ? date.toString() : null);
+    }
+}

editors/code/src/config.ts

@@ -1,8 +1,11 @@
 import fetch from "node-fetch";
+import * as vscode from "vscode";
+import * as path from "path";
 import * as fs from "fs";
 import * as stream from "stream";
 import * as util from "util";
 import { log, assert } from "../util";
+import { ArtifactReleaseInfo } from "./interfaces";
 
 const pipeline = util.promisify(stream.pipeline);
 
@@ -49,3 +52,46 @@ export async function downloadFile(
         // Issue at nodejs repo: https://github.com/nodejs/node/issues/31776
     });
 }
+
+/**
+ * Downloads artifact from given `downloadUrl`.
+ * Creates `installationDir` if it is not yet created and puts the artifact under
+ * `artifactFileName`.
+ * Displays info about the download progress in an info message printing the name
+ * of the artifact as `displayName`.
+ */
+export async function downloadArtifactWithProgressUi(
+    { downloadUrl, releaseName }: ArtifactReleaseInfo,
+    artifactFileName: string,
+    installationDir: string,
+    displayName: string,
+) {
+    await fs.promises.mkdir(installationDir).catch(err => assert(
+        err?.code === "EEXIST",
+        `Couldn't create directory "${installationDir}" to download ` +
+        `${artifactFileName} artifact: ${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 rust-analyzer ${displayName} (${releaseName})`
+        },
+        async (progress, _cancellationToken) => {
+            let lastPrecentage = 0;
+            const filePermissions = 0o755; // (rwx, r_x, r_x)
+            await downloadFile(downloadUrl, installationPath, filePermissions, (readBytes, totalBytes) => {
+                const newPercentage = (readBytes / totalBytes) * 100;
+                progress.report({
+                    message: newPercentage.toFixed(0) + "%",
+                    increment: newPercentage - lastPrecentage
+                });
+
+                lastPrecentage = newPercentage;
+            });
+        }
+    );
+}