Handle .zip archive binaries

This is different from just regular zip compression, since the Windows
binaries are distributed as zip archives now. So we can't just use zlib,
but need to pull in yauzl to handle the archive format

Author: lukel97

Changelog.md

@@ -1,3 +1,9 @@
+### 1.0.0
+
+- vscode-haskell now lives under the Haskell organisation
+- Can now download zip archived binaries, which the Windows binaries are now distributed as
+- Improve README (@pepeiborra @jaspervdj)
+
 ### 0.1.1
 
 - Fix the restart server and import identifier commands

package-lock.json

@@ -193,6 +193,7 @@
     "@types/lru-cache": "^4.1.2",
     "@types/node": "^14.0.3",
     "@types/request-promise-native": "^1.0.17",
+    "@types/yauzl": "^2.9.1",
     "husky": "^4.2.5",
     "prettier": "^2.0.5",
     "pretty-quick": "^2.0.1",
@@ -215,6 +216,7 @@
     "lru-cache": "^4.1.5",
     "request": "^2.88.2",
     "request-promise-native": "^1.0.8",
-    "vscode-languageclient": "6.1.3"
+    "vscode-languageclient": "6.1.3",
+    "yauzl": "^2.10.0"
   }
 }

package.json

@@ -1,6 +1,7 @@
 import * as child_process from 'child_process';
 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';
@@ -18,7 +19,7 @@ interface IAsset {
 }
 
 // On Windows the executable needs to be stored somewhere with an .exe extension
-const exeExtension = process.platform === 'win32' ? '.exe' : '';
+const exeExt = process.platform === 'win32' ? '.exe' : '';
 
 class MissingToolError extends Error {
   public readonly tool: string;
@@ -57,6 +58,17 @@ class MissingToolError extends Error {
   }
 }
 
+// tslint:disable-next-line: max-classes-per-file
+class NoBinariesError extends Error {
+  constructor(hlsVersion: string, ghcVersion?: string) {
+    if (ghcVersion) {
+      super(`haskell-language-server ${hlsVersion} for GHC ${ghcVersion} is not available on ${os.type()}`);
+    } else {
+      super(`haskell-language-server ${hlsVersion} is not available on ${os.type()}`);
+    }
+  }
+}
+
 /** Works out what the project's ghc version is, downloading haskell-language-server-wrapper
  * if needed. Returns null if there was an error in either downloading the wrapper or
  * in working out the ghc version
@@ -97,7 +109,7 @@ async function getProjectGhcVersion(context: ExtensionContext, dir: string, rele
 
   // Otherwise search to see if we previously downloaded the wrapper
 
-  const wrapperName = `haskell-language-server-wrapper-${release.tag_name}-${process.platform}${exeExtension}`;
+  const wrapperName = `haskell-language-server-wrapper-${release.tag_name}-${process.platform}${exeExt}`;
   const downloadedWrapper = path.join(context.globalStoragePath, wrapperName);
 
   if (executableExists(downloadedWrapper)) {
@@ -109,14 +121,14 @@ async function getProjectGhcVersion(context: ExtensionContext, dir: string, rele
   const githubOS = getGithubOS();
   if (githubOS === null) {
     // Don't have any binaries available for this platform
-    throw Error(`Couldn't find any haskell-language-server-wrapper binaries for ${process.platform}`);
+    throw new NoBinariesError(release.tag_name);
   }
 
-  const assetName = `haskell-language-server-wrapper-${githubOS}${exeExtension}.gz`;
-  const wrapperAsset = release.assets.find((x) => x.name === assetName);
+  const assetName = `haskell-language-server-wrapper-${githubOS}${exeExt}`;
+  const wrapperAsset = release.assets.find((x) => x.name.startsWith(assetName));
 
   if (!wrapperAsset) {
-    throw Error(`Couldn't find any ${assetName} binaries for release ${release.tag_name}`);
+    throw new NoBinariesError(release.tag_name);
   }
 
   await downloadFile(
@@ -186,23 +198,25 @@ export async function downloadHaskellLanguageServer(
       } else {
         await window.showErrorMessage(error.message);
       }
+    } else if (error instanceof NoBinariesError) {
+      window.showInformationMessage(error.message);
     } else {
       // We couldn't figure out the right ghc version to download
       window.showErrorMessage(`Couldn't figure out what GHC version the project is using:\n${error.message}`);
     }
     return null;
   }
 
-  const assetName = `haskell-language-server-${githubOS}-${ghcVersion}${exeExtension}.gz`;
-  const asset = release?.assets.find((x) => x.name === assetName);
+  // When searching for binaries, use startsWith because the compression may differ
+  // between .zip and .gz
+  const assetName = `haskell-language-server-${githubOS}-${ghcVersion}${exeExt}`;
+  const asset = release?.assets.find((x) => x.name.startsWith(assetName));
   if (!asset) {
-    window.showErrorMessage(
-      `Couldn't find any pre-built haskell-language-server binaries for ${githubOS} and ${ghcVersion}`
-    );
+    window.showInformationMessage(new NoBinariesError(release.tag_name, ghcVersion).message);
     return null;
   }
 
-  const serverName = `haskell-language-server-${release.tag_name}-${process.platform}-${ghcVersion}${exeExtension}`;
+  const serverName = `haskell-language-server-${release.tag_name}-${process.platform}-${ghcVersion}${exeExt}`;
   const binaryDest = path.join(context.globalStoragePath, serverName);
 
   const title = `Downloading haskell-language-server ${release.tag_name} for GHC ${ghcVersion}`;

src/hlsBinaries.ts

@@ -7,6 +7,7 @@ import * as https from 'https';
 import { extname } from 'path';
 import * as url from 'url';
 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
@@ -67,10 +68,39 @@ export async function downloadFile(titleMsg: string, src: string, dest: string):
           const fileStream = fs.createWriteStream(downloadDest, { mode: 0o744 });
           let curSize = 0;
 
-          // Decompress it if it's a gzip
-          const needsUnzip = res.headers['content-type'] === 'application/gzip' || extname(srcUrl.path ?? '') === '.gz';
-          if (needsUnzip) {
-            res.pipe(createGunzip()).pipe(fileStream);
+          // Decompress it if it's a gzip or zip
+          const needsGunzip =
+            res.headers['content-type'] === 'application/gzip' || extname(srcUrl.path ?? '') === '.gz';
+          const needsUnzip = res.headers['content-type'] === 'application/zip' || extname(srcUrl.path ?? '') === '.zip';
+          if (needsGunzip) {
+            const gunzip = createGunzip();
+            gunzip.on('error', reject);
+            res.pipe(gunzip).pipe(fileStream);
+          } else if (needsUnzip) {
+            const zipDest = downloadDest + '.zip';
+            const zipFs = fs.createWriteStream(zipDest);
+            zipFs.on('error', reject);
+            zipFs.on('close', () => {
+              yazul.open(zipDest, (err, zipfile) => {
+                if (err) {
+                  throw err;
+                }
+                if (!zipfile) {
+                  throw Error("Couldn't decompress zip");
+                }
+
+                // We only expect *one* file inside each zip
+                zipfile.on('entry', (entry: yazul.Entry) => {
+                  zipfile.openReadStream(entry, (err2, readStream) => {
+                    if (err2) {
+                      throw err2;
+                    }
+                    readStream?.pipe(fileStream);
+                  });
+                });
+              });
+            });
+            res.pipe(zipFs);
           } else {
             res.pipe(fileStream);
           }