Merge pull request #299 from WorldSEnder/connection-issues

Use local files on connection failure, closes #298

Author: lukel97

package.json

@@ -151,6 +151,22 @@
           "type": "string",
           "default": "",
           "description": "Manually set a language server executable. Can be something on the $PATH or a path to an executable itself. Works with ~, ${HOME} and ${workspaceFolder}."
+        },
+        "haskell.updateBehavior": {
+          "scope": "machine",
+          "type": "string",
+          "enum": [
+            "keep-up-to-date",
+            "prompt",
+            "never-check"
+          ],
+          "enumDescriptions": [
+            "Always download the latest available version when it is published",
+            "Prompt before upgrading to a newer version",
+            "Don't check for newer versions"
+          ],
+          "default": "keep-up-to-date",
+          "markdownDescription": "Only applicable with `#haskell.languageServerVariant#` set to `haskell-language-server`. Determine what to do when a new version of the language server is available."
         }
       }
     },

src/hlsBinaries.ts

@@ -3,12 +3,14 @@ import * as fs from 'fs';
 import * as https from 'https';
 import * as os from 'os';
 import * as path from 'path';
-import { env, ExtensionContext, ProgressLocation, Uri, window, WorkspaceFolder } from 'vscode';
-import { downloadFile, executableExists, userAgentHeader } from './utils';
+import { promisify } from 'util';
+import { env, ExtensionContext, ProgressLocation, Uri, window, workspace, WorkspaceFolder } from 'vscode';
+import { downloadFile, executableExists, httpsGetSilently } from './utils';
+import * as validate from './validation';
 
 /** GitHub API release */
 interface IRelease {
-  assets: [IAsset];
+  assets: IAsset[];
   tag_name: string;
   prerelease: boolean;
 }
@@ -18,6 +20,23 @@ interface IAsset {
   name: string;
 }
 
+type UpdateBehaviour = 'keep-up-to-date' | 'prompt' | 'never-check';
+
+const assetValidator: validate.Validator<IAsset> = validate.object({
+  browser_download_url: validate.string(),
+  name: validate.string(),
+});
+
+const releaseValidator: validate.Validator<IRelease> = validate.object({
+  assets: validate.array(assetValidator),
+  tag_name: validate.string(),
+  prerelease: validate.boolean(),
+});
+
+const githubReleaseApiValidator: validate.Validator<IRelease[]> = validate.array(releaseValidator);
+
+const cachedReleaseValidator: validate.Validator<IRelease | null> = validate.optional(releaseValidator);
+
 // On Windows the executable needs to be stored somewhere with an .exe extension
 const exeExt = process.platform === 'win32' ? '.exe' : '';
 
@@ -140,6 +159,75 @@ async function getProjectGhcVersion(context: ExtensionContext, dir: string, rele
   return callWrapper(downloadedWrapper);
 }
 
+async function getLatestReleaseMetadata(context: ExtensionContext): Promise<IRelease | null> {
+  const opts: https.RequestOptions = {
+    host: 'api.github.com',
+    path: '/repos/haskell/haskell-language-server/releases',
+  };
+
+  const offlineCache = path.join(context.globalStoragePath, 'latestApprovedRelease.cache.json');
+
+  async function readCachedReleaseData(): Promise<IRelease | null> {
+    try {
+      const cachedInfo = await promisify(fs.readFile)(offlineCache, { encoding: 'utf-8' });
+      return validate.parseAndValidate(cachedInfo, cachedReleaseValidator);
+    } catch (err) {
+      // If file doesn't exist, return null, otherwise consider it a failure
+      if (err.code === 'ENOENT') {
+        return null;
+      }
+      throw err;
+    }
+  }
+  // Not all users want to upgrade right away, in that case prompt
+  const updateBehaviour = workspace.getConfiguration('haskell').get('updateBehavior') as UpdateBehaviour;
+
+  if (updateBehaviour === 'never-check') {
+    return readCachedReleaseData();
+  }
+
+  try {
+    const releaseInfo = await httpsGetSilently(opts);
+    const latestInfoParsed =
+      validate.parseAndValidate(releaseInfo, githubReleaseApiValidator).find((x) => !x.prerelease) || null;
+
+    if (updateBehaviour === 'prompt') {
+      const cachedInfoParsed = await readCachedReleaseData();
+
+      if (
+        latestInfoParsed !== null &&
+        (cachedInfoParsed === null || latestInfoParsed.tag_name !== cachedInfoParsed.tag_name)
+      ) {
+        const promptMessage =
+          cachedInfoParsed === null
+            ? 'No version of the haskell-language-server is installed, would you like to install it now?'
+            : 'A new version of the haskell-language-server is available, would you like to upgrade now?';
+
+        const decision = await window.showInformationMessage(promptMessage, 'Download', 'Nevermind');
+        if (decision !== 'Download') {
+          // If not upgrade, bail and don't overwrite cached version information
+          return cachedInfoParsed;
+        }
+      }
+    }
+
+    // Cache the latest successfully fetched release information
+    await promisify(fs.writeFile)(offlineCache, JSON.stringify(latestInfoParsed), { encoding: 'utf-8' });
+    return latestInfoParsed;
+  } catch (githubError) {
+    // Attempt to read from the latest cached file
+    try {
+      const cachedInfoParsed = await readCachedReleaseData();
+
+      window.showWarningMessage(
+        `Couldn't get the latest haskell-language-server releases from GitHub, used local cache instead:\n${githubError.message}`
+      );
+      return cachedInfoParsed;
+    } catch (fileError) {
+      throw new Error(`Couldn't get the latest haskell-language-server releases from GitHub:\n${githubError.message}`);
+    }
+  }
+}
 /**
  * Downloads the latest haskell-language-server binaries from GitHub releases.
  * Returns null if it can't find any that match.
@@ -149,27 +237,6 @@ export async function downloadHaskellLanguageServer(
   resource: Uri,
   folder?: WorkspaceFolder
 ): Promise<string | null> {
-  // Fetch the latest release from GitHub
-  const releases: IRelease[] = await new Promise((resolve, reject) => {
-    let data: string = '';
-    const opts: https.RequestOptions = {
-      host: 'api.github.com',
-      path: '/repos/haskell/haskell-language-server/releases',
-      headers: userAgentHeader,
-    };
-    https
-      .get(opts, (res) => {
-        res.on('data', (d) => (data += d));
-        res.on('error', reject);
-        res.on('close', () => {
-          resolve(JSON.parse(data));
-        });
-      })
-      .on('error', (e) => {
-        reject(new Error(`Couldn't get the latest haskell-language-server releases from GitHub:\n${e.message}`));
-      });
-  });
-
   // Make sure to create this before getProjectGhcVersion
   if (!fs.existsSync(context.globalStoragePath)) {
     fs.mkdirSync(context.globalStoragePath);
@@ -182,13 +249,20 @@ export async function downloadHaskellLanguageServer(
     return null;
   }
 
-  const release = releases.find((x) => !x.prerelease);
+  // Fetch the latest release from GitHub or from cache
+  const release = await getLatestReleaseMetadata(context);
   if (!release) {
-    window.showErrorMessage("Couldn't find any pre-built haskell-language-server binaries");
+    let message = "Couldn't find any pre-built haskell-language-server binaries";
+    const updateBehaviour = workspace.getConfiguration('haskell').get('updateBehavior') as UpdateBehaviour;
+    if (updateBehaviour === 'never-check') {
+      message += ' (and checking for newer versions is disabled)';
+    }
+    window.showErrorMessage(message);
     return null;
   }
-  const dir: string = folder?.uri?.fsPath ?? path.dirname(resource.fsPath);
 
+  // Figure out the ghc version to use or advertise an installation link for missing components
+  const dir: string = folder?.uri?.fsPath ?? path.dirname(resource.fsPath);
   let ghcVersion: string;
   try {
     ghcVersion = await getProjectGhcVersion(context, dir, release);
@@ -224,15 +298,8 @@ export async function downloadHaskellLanguageServer(
   const binaryDest = path.join(context.globalStoragePath, serverName);
 
   const title = `Downloading haskell-language-server ${release.tag_name} for GHC ${ghcVersion}`;
-  try {
-    await downloadFile(title, asset.browser_download_url, binaryDest);
-    return binaryDest;
-  } catch (e) {
-    if (e instanceof Error) {
-      window.showErrorMessage(e.message);
-    }
-    return null;
-  }
+  await downloadFile(title, asset.browser_download_url, binaryDest);
+  return binaryDest;
 }
 
 /** Get the OS label used by GitHub for the current platform */

src/utils.ts

@@ -6,14 +6,15 @@ import * as http from 'http';
 import * as https from 'https';
 import { extname } from 'path';
 import * as url from 'url';
+import { promisify } from 'util';
 import { ProgressLocation, window } from 'vscode';
 import * as yazul from 'yauzl';
 import { createGunzip } from 'zlib';
 
 /** When making http requests to github.com, use this header otherwise
  * the server will close the request
  */
-export const userAgentHeader = { 'User-Agent': 'vscode-haskell' };
+const userAgentHeader = { 'User-Agent': 'vscode-haskell' };
 
 /** downloadFile may get called twice on the same src and destination:
  * When this happens, we should only download the file once but return two
@@ -27,6 +28,36 @@ export const userAgentHeader = { 'User-Agent': 'vscode-haskell' };
  */
 const inFlightDownloads = new Map<string, Map<string, Thenable<void>>>();
 
+export async function httpsGetSilently(options: https.RequestOptions): Promise<string> {
+  const opts: https.RequestOptions = {
+    ...options,
+    headers: {
+      ...(options.headers ?? {}),
+      ...userAgentHeader,
+    },
+  };
+
+  return new Promise((resolve, reject) => {
+    let data: string = '';
+    https
+      .get(opts, (res) => {
+        res.on('data', (d) => (data += d));
+        res.on('error', reject);
+        res.on('close', () => {
+          resolve(data);
+        });
+      })
+      .on('error', reject);
+  });
+}
+
+async function ignoreFileNotExists(err: NodeJS.ErrnoException): Promise<void> {
+  if (err.code === 'ENOENT') {
+    return;
+  }
+  throw err;
+}
+
 export async function downloadFile(titleMsg: string, src: string, dest: string): Promise<void> {
   // Check to see if we're already in the process of downloading the same thing
   const inFlightDownload = inFlightDownloads.get(src)?.get(dest);
@@ -135,10 +166,10 @@ export async function downloadFile(titleMsg: string, src: string, dest: string):
     } else {
       inFlightDownloads.set(src, new Map([[dest, downloadTask]]));
     }
-    return downloadTask;
+    return await downloadTask;
   } catch (e) {
-    fs.unlinkSync(downloadDest);
-    throw new Error(`Failed to download ${url}`);
+    await promisify(fs.unlink)(downloadDest).catch(ignoreFileNotExists);
+    throw new Error(`Failed to download ${src}:\n${e.message}`);
   }
 }