6 files changed, 250 insertions, 115 deletions

diff --git a/editors/code/src/installation/download_artifact.ts b/editors/code/src/installation/download_artifact.ts
deleted file mode 100644
index 97e4d67c2..000000000
--- a/editors/code/src/installation/download_artifact.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import * as vscode from "vscode";
-import * as path from "path";
-import { promises as fs } from "fs";
-
-import { ArtifactReleaseInfo } from "./interfaces";
-import { downloadFile } from "./download_file";
-import { assert } from "../util";
-
-/**
- * Downloads artifact from given `downloadUrl`.
- * Creates `installationDir` if it is not yet created and put 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 downloadArtifact(
-    { downloadUrl, releaseName }: ArtifactReleaseInfo,
-    artifactFileName: string,
-    installationDir: string,
-    displayName: string,
-) {
-    await fs.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 ${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;
-            });
-        }
-    );
-}
diff --git a/editors/code/src/installation/download_file.ts b/editors/code/src/installation/downloads.ts
index ee8949d61..7ce2e2960 100644
--- a/editors/code/src/installation/download_file.ts
+++ b/editors/code/src/installation/downloads.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;
+            });
+        }
+    );
+}
diff --git a/editors/code/src/installation/extension.ts b/editors/code/src/installation/extension.ts
new file mode 100644
index 000000000..eea6fded2
--- /dev/null
+++ b/editors/code/src/installation/extension.ts
@@ -0,0 +1,144 @@
+import * as vscode from "vscode";
+import * as path from "path";
+import { promises as fs } from 'fs';
+
+import { vscodeReinstallExtension, vscodeReloadWindow, log, vscodeInstallExtensionFromVsix, assert, notReentrant } from "../util";
+import { Config, UpdatesChannel } from "../config";
+import { ArtifactReleaseInfo, ArtifactSource } from "./interfaces";
+import { downloadArtifactWithProgressUi } from "./downloads";
+import { fetchArtifactReleaseInfo } from "./fetch_artifact_release_info";
+
+const HEURISTIC_NIGHTLY_RELEASE_PERIOD_IN_HOURS = 25;
+
+/**
+ * Installs `stable` or latest `nightly` version or does nothing if the current
+ * extension version is what's needed according to `desiredUpdateChannel`.
+ */
+export async function ensureProperExtensionVersion(config: Config): Promise<never | void> {
+    // User has built lsp server from sources, she should manage updates manually
+    if (config.serverSource?.type === ArtifactSource.Type.ExplicitPath) return;
+
+    const currentUpdChannel = config.installedExtensionUpdateChannel;
+    const desiredUpdChannel = config.updatesChannel;
+
+    if (currentUpdChannel === UpdatesChannel.Stable) {
+        // Release date is present only when we are on nightly
+        await config.installedNightlyExtensionReleaseDate.set(null);
+    }
+
+    if (desiredUpdChannel === UpdatesChannel.Stable) {
+        // VSCode should handle updates for stable channel
+        if (currentUpdChannel === UpdatesChannel.Stable) return;
+
+        if (!await askToDownloadProperExtensionVersion(config)) return;
+
+        await vscodeReinstallExtension(config.extensionId);
+        await vscodeReloadWindow(); // never returns
+    }
+
+    if (currentUpdChannel === UpdatesChannel.Stable) {
+        if (!await askToDownloadProperExtensionVersion(config)) return;
+
+        return await tryDownloadNightlyExtension(config);
+    }
+
+    const currentExtReleaseDate = config.installedNightlyExtensionReleaseDate.get();
+
+    if (currentExtReleaseDate === null) {
+        void vscode.window.showErrorMessage(
+            "Nightly release date must've been set during the installation. " +
+            "Did you download and install the nightly .vsix package manually?"
+        );
+        throw new Error("Nightly release date was not set in globalStorage");
+    }
+
+    const dateNow = new Date;
+    const hoursSinceLastUpdate = diffInHours(currentExtReleaseDate, dateNow);
+    log.debug(
+        "Current rust-analyzer nightly was downloaded", hoursSinceLastUpdate,
+        "hours ago, namely:", currentExtReleaseDate, "and now is", dateNow
+    );
+
+    if (hoursSinceLastUpdate < HEURISTIC_NIGHTLY_RELEASE_PERIOD_IN_HOURS) {
+        return;
+    }
+    if (!await askToDownloadProperExtensionVersion(config, "The installed nightly version is most likely outdated. ")) {
+        return;
+    }
+
+    await tryDownloadNightlyExtension(config, releaseInfo => {
+        assert(
+            currentExtReleaseDate.getTime() === config.installedNightlyExtensionReleaseDate.get()?.getTime(),
+            "Other active VSCode instance has reinstalled the extension"
+        );
+
+        if (releaseInfo.releaseDate.getTime() === currentExtReleaseDate.getTime()) {
+            vscode.window.showInformationMessage(
+                "Whoops, it appears that your nightly version is up-to-date. " +
+                "There might be some problems with the upcomming nightly release " +
+                "or you traveled too far into the future. Sorry for that 😅! "
+            );
+            return false;
+        }
+        return true;
+    });
+}
+
+async function askToDownloadProperExtensionVersion(config: Config, reason = "") {
+    if (!config.askBeforeDownload) return true;
+
+    const stableOrNightly = config.updatesChannel === UpdatesChannel.Stable ? "stable" : "latest nightly";
+
+    // In case of reentering this function and showing the same info message
+    // (e.g. after we had shown this message, the user changed the config)
+    // vscode will dismiss the already shown one (i.e. return undefined).
+    // This behaviour is what we want, but likely it is not documented
+
+    const userResponse = await vscode.window.showInformationMessage(
+        reason + `Do you want to download the ${stableOrNightly} rust-analyzer extension ` +
+        `version and reload the window now?`,
+        "Download now", "Cancel"
+    );
+    return userResponse === "Download now";
+}
+
+/**
+ * Shutdowns the process in case of success (i.e. reloads the window) or throws an error.
+ *
+ * ACHTUNG!: this function has a crazy amount of state transitions, handling errors during
+ * each of them would result in a ton of code (especially accounting for cross-process
+ * shared mutable `globalState` access). Enforcing no reentrancy for this is best-effort.
+ */
+const tryDownloadNightlyExtension = notReentrant(async (
+    config: Config,
+    shouldDownload: (releaseInfo: ArtifactReleaseInfo) => boolean = () => true
+): Promise<never | void> => {
+    const vsixSource = config.nightlyVsixSource;
+    try {
+        const releaseInfo = await fetchArtifactReleaseInfo(vsixSource.repo, vsixSource.file, vsixSource.tag);
+
+        if (!shouldDownload(releaseInfo)) return;
+
+        await downloadArtifactWithProgressUi(releaseInfo, vsixSource.file, vsixSource.dir, "nightly extension");
+
+        const vsixPath = path.join(vsixSource.dir, vsixSource.file);
+
+        await vscodeInstallExtensionFromVsix(vsixPath);
+        await config.installedNightlyExtensionReleaseDate.set(releaseInfo.releaseDate);
+        await fs.unlink(vsixPath);
+
+        await vscodeReloadWindow(); // never returns
+    } catch (err) {
+        log.downloadError(err, "nightly extension", vsixSource.repo.name);
+    }
+});
+
+function diffInHours(a: Date, b: Date): number {
+    // Discard the time and time-zone information (to abstract from daylight saving time bugs)
+    // https://stackoverflow.com/a/15289883/9259330
+
+    const utcA = Date.UTC(a.getFullYear(), a.getMonth(), a.getDate());
+    const utcB = Date.UTC(b.getFullYear(), b.getMonth(), b.getDate());
+
+    return (utcA - utcB) / (1000 * 60 * 60);
+}
diff --git a/editors/code/src/installation/fetch_artifact_release_info.ts b/editors/code/src/installation/fetch_artifact_release_info.ts
index b1b5a3485..1ad3b8338 100644
--- a/editors/code/src/installation/fetch_artifact_release_info.ts
+++ b/editors/code/src/installation/fetch_artifact_release_info.ts
@@ -59,12 +59,15 @@ export async function fetchArtifactReleaseInfo(
 
     return {
         releaseName: release.name,
+        releaseDate: new Date(release.published_at),
         downloadUrl: artifact.browser_download_url
     };
 
     // We omit declaration of tremendous amount of fields that we are not using here
     interface GithubRelease {
         name: string;
+        // eslint-disable-next-line camelcase
+        published_at: string;
         assets: Array<{
             name: string;
             // eslint-disable-next-line camelcase
diff --git a/editors/code/src/installation/interfaces.ts b/editors/code/src/installation/interfaces.ts
index 50b635921..1a8ea0884 100644
--- a/editors/code/src/installation/interfaces.ts
+++ b/editors/code/src/installation/interfaces.ts
@@ -1,5 +1,3 @@
-import * as vscode from "vscode";
-
 export interface GithubRepo {
     name: string;
     owner: string;
@@ -9,6 +7,7 @@ export interface GithubRepo {
  * Metadata about particular artifact retrieved from GitHub releases.
  */
 export interface ArtifactReleaseInfo {
+    releaseDate: Date;
     releaseName: string;
     downloadUrl: string;
 }
@@ -42,6 +41,9 @@ export namespace ArtifactSource {
          */
         repo: GithubRepo;
 
+
+        // FIXME: add installationPath: string;
+
         /**
          * Directory on the filesystem where the bundled binary is stored.
          */
@@ -57,17 +59,5 @@ export namespace ArtifactSource {
          * Tag of github release that denotes a version required by this extension.
          */
         tag: string;
-
-        /**
-         * Object that provides `get()/update()` operations to store metadata
-         * about the actual binary, e.g. its actual version.
-         */
-        storage: vscode.Memento;
-
-        /**
-         * Ask for the user permission before downloading the artifact.
-         */
-        askBeforeDownload: boolean;
     }
-
 }
diff --git a/editors/code/src/installation/server.ts b/editors/code/src/installation/server.ts
index ef1c45ff6..05730a778 100644
--- a/editors/code/src/installation/server.ts
+++ b/editors/code/src/installation/server.ts
@@ -1,14 +1,16 @@
 import * as vscode from "vscode";
 import * as path from "path";
-import { promises as dns } from "dns";
 import { spawnSync } from "child_process";
 
 import { ArtifactSource } from "./interfaces";
 import { fetchArtifactReleaseInfo } from "./fetch_artifact_release_info";
-import { downloadArtifact } from "./download_artifact";
-import { log, assert } from "../util";
+import { downloadArtifactWithProgressUi } from "./downloads";
+import { log, assert, notReentrant } from "../util";
+import { Config, NIGHTLY_TAG } from "../config";
+
+export async function ensureServerBinary(config: Config): Promise<null | string> {
+    const source = config.serverSource;
 
-export async function ensureServerBinary(source: null | ArtifactSource): Promise<null | string> {
     if (!source) {
         vscode.window.showErrorMessage(
             "Unfortunately we don't ship binaries for your platform yet. " +
@@ -35,18 +37,11 @@ export async function ensureServerBinary(source: null | ArtifactSource): Promise
             return null;
         }
         case ArtifactSource.Type.GithubRelease: {
-            const prebuiltBinaryPath = path.join(source.dir, source.file);
-
-            const installedVersion: null | string = getServerVersion(source.storage);
-            const requiredVersion: string = source.tag;
-
-            log.debug("Installed version:", installedVersion, "required:", requiredVersion);
-
-            if (isBinaryAvailable(prebuiltBinaryPath) && installedVersion === requiredVersion) {
-                return prebuiltBinaryPath;
+            if (!shouldDownloadServer(source, config)) {
+                return path.join(source.dir, source.file);
             }
 
-            if (source.askBeforeDownload) {
+            if (config.askBeforeDownload) {
                 const userResponse = await vscode.window.showInformationMessage(
                     `Language server version ${source.tag} for rust-analyzer is not installed. ` +
                     "Do you want to download it now?",
@@ -55,38 +50,56 @@ export async function ensureServerBinary(source: null | ArtifactSource): Promise
                 if (userResponse !== "Download now") return null;
             }
 
-            if (!await downloadServer(source)) return null;
-
-            return prebuiltBinaryPath;
+            return await downloadServer(source, config);
         }
     }
 }
 
-async function downloadServer(source: ArtifactSource.GithubRelease): Promise<boolean> {
+function shouldDownloadServer(
+    source: ArtifactSource.GithubRelease,
+    config: Config
+): boolean {
+    if (!isBinaryAvailable(path.join(source.dir, source.file))) return true;
+
+    const installed = {
+        tag: config.serverReleaseTag.get(),
+        date: config.serverReleaseDate.get()
+    };
+    const required = {
+        tag: source.tag,
+        date: config.installedNightlyExtensionReleaseDate.get()
+    };
+
+    log.debug("Installed server:", installed, "required:", required);
+
+    if (required.tag !== NIGHTLY_TAG || installed.tag !== NIGHTLY_TAG) {
+        return required.tag !== installed.tag;
+    }
+
+    assert(required.date !== null, "Extension release date should have been saved during its installation");
+    assert(installed.date !== null, "Server release date should have been saved during its installation");
+
+    return installed.date.getTime() !== required.date.getTime();
+}
+
+/**
+ * Enforcing no reentrancy for this is best-effort.
+ */
+const downloadServer = notReentrant(async (
+    source: ArtifactSource.GithubRelease,
+    config: Config,
+): Promise<null | string> => {
     try {
         const releaseInfo = await fetchArtifactReleaseInfo(source.repo, source.file, source.tag);
 
-        await downloadArtifact(releaseInfo, source.file, source.dir, "language server");
-        await setServerVersion(source.storage, releaseInfo.releaseName);
+        await downloadArtifactWithProgressUi(releaseInfo, source.file, source.dir, "language server");
+        await Promise.all([
+            config.serverReleaseTag.set(releaseInfo.releaseName),
+            config.serverReleaseDate.set(releaseInfo.releaseDate)
+        ]);
     } catch (err) {
-        vscode.window.showErrorMessage(
-            `Failed to download language server from ${source.repo.name} ` +
-            `GitHub repository: ${err.message}`
-        );
-
-        log.error(err);
-
-        dns.resolve('example.com').then(
-            addrs => log.debug("DNS resolution for example.com was successful", addrs),
-            err => {
-                log.error(
-                    "DNS resolution for example.com failed, " +
-                    "there might be an issue with Internet availability"
-                );
-                log.error(err);
-            }
-        );
-        return false;
+        log.downloadError(err, "language server", source.repo.name);
+        return null;
     }
 
     const binaryPath = path.join(source.dir, source.file);
@@ -101,8 +114,8 @@ async function downloadServer(source: ArtifactSource.GithubRelease): Promise<boo
         "Rust analyzer language server was successfully installed 🦀"
     );
 
-    return true;
-}
+    return binaryPath;
+});
 
 function isBinaryAvailable(binaryPath: string): boolean {
     const res = spawnSync(binaryPath, ["--version"]);
@@ -115,14 +128,3 @@ function isBinaryAvailable(binaryPath: string): boolean {
 
     return res.status === 0;
 }
-
-function getServerVersion(storage: vscode.Memento): null | string {
-    const version = storage.get<null | string>("server-version", null);
-    log.debug("Get server-version:", version);
-    return version;
-}
-
-async function setServerVersion(storage: vscode.Memento, version: string): Promise<void> {
-    log.debug("Set server-version:", version);
-    await storage.update("server-version", version.toString());
-}