Extract metadata into deedicated file

Author: fendor

src/hlsBinaries.ts

@@ -1,8 +1,5 @@
 import * as fs from 'fs';
-import * as https from 'https';
 import * as path from 'path';
-import { match } from 'ts-pattern';
-import { promisify } from 'util';
 import { ConfigurationTarget, ExtensionContext, window, workspace, WorkspaceFolder } from 'vscode';
 import { Logger } from 'vscode-languageclient';
 import { HlsError, MissingToolError, NoMatchingHls } from './errors';
@@ -11,18 +8,19 @@ import {
   callAsync,
   comparePVP,
   executableExists,
-  httpsGetSilently,
   IEnvVars,
   resolvePathPlaceHolders,
 } from './utils';
 import { ToolConfig, Tool, initDefaultGHCup, GHCup } from './ghcup';
+import { getHlsMetadata } from './metadata';
 export { IEnvVars };
 
 type ManageHLS = 'GHCup' | 'PATH';
 let manageHLS = workspace.getConfiguration('haskell').get('manageHLS') as ManageHLS;
 
 export type Context = {
   manageHls: ManageHLS;
+  storagePath: string;
   serverExecutable?: HlsExecutable;
   logger: Logger;
 };
@@ -47,7 +45,7 @@ function findServerExecutable(logger: Logger, folder?: WorkspaceFolder): string
 
 /** Searches the PATH. Fails if nothing is found.
  */
-function findHlsInPath(_context: ExtensionContext, logger: Logger): string {
+function findHlsInPath(logger: Logger): string {
   // try PATH
   const exes: string[] = ['haskell-language-server-wrapper', 'haskell-language-server'];
   logger.info(`Searching for server executables ${exes.join(',')} in $PATH`);
@@ -117,11 +115,11 @@ export async function findHaskellLanguageServer(
     fs.mkdirSync(storagePath);
   }
 
-  // first plugin initialization
+  // first extension initialization
   manageHLS = await promptUserForManagingHls(context, manageHLS);
 
   if (manageHLS === 'PATH') {
-    const exe = findHlsInPath(context, logger);
+    const exe = findHlsInPath(logger);
     return {
       location: exe,
       tag: 'path',
@@ -243,7 +241,7 @@ export async function findHaskellLanguageServer(
     // now figure out the actual project GHC version and the latest supported HLS version
     // we need for it (e.g. this might in fact be a downgrade for old GHCs)
     if (projectHls === undefined || projectGhc === undefined) {
-      const res = await getLatestProjectHLS(ghcup, context, logger, workingDir, latestToolchainBindir);
+      const res = await getLatestProjectHls(ghcup, logger, storagePath, workingDir, latestToolchainBindir);
       if (projectHls === undefined) {
         projectHls = res[0];
       }
@@ -352,10 +350,10 @@ async function promptUserForManagingHls(context: ExtensionContext, manageHlsSett
   }
 }
 
-async function getLatestProjectHLS(
+async function getLatestProjectHls(
   ghcup: GHCup,
-  context: ExtensionContext,
   logger: Logger,
+  storagePath: string,
   workingDir: string,
   toolchainBindir: string,
 ): Promise<[string, string]> {
@@ -371,7 +369,7 @@ async function getLatestProjectHLS(
     : await callAsync(`ghc${exeExt}`, ['--numeric-version'], logger, undefined, undefined, false);
 
   // first we get supported GHC versions from available HLS bindists (whether installed or not)
-  const metadataMap = (await getHlsMetadata(context, logger)) || new Map<string, string[]>();
+  const metadataMap = (await getHlsMetadata(storagePath, logger)) || new Map<string, string[]>();
   // then we get supported GHC versions from currently installed HLS versions
   const ghcupMap = (await findAvailableHlsBinariesFromGHCup(ghcup)) || new Map<string, string[]>();
   // since installed HLS versions may support a different set of GHC versions than the bindists
@@ -394,7 +392,7 @@ async function getLatestProjectHLS(
 /**
  * Obtain the project ghc version from the HLS - Wrapper (which must be in PATH now).
  * Also, serves as a sanity check.
- * @param toolchainBindir Path to the toolchainn bin directory (added to PATH)
+ * @param toolchainBindir Path to the toolchain bin directory (added to PATH)
  * @param workingDir Directory to run the process, usually the root of the workspace.
  * @param logger Logger for feedback.
  * @returns The GHC version, or fail with an `Error`.
@@ -507,197 +505,6 @@ async function toolInstalled(ghcup: GHCup, tool: Tool, version: string): Promise
   return new InstalledTool(tool, version, b);
 }
 
-/**
- * Metadata of release information.
- *
- * Example of the expected format:
- *
- * ```
- * {
- *  "1.6.1.0": {
- *     "A_64": {
- *       "Darwin": [
- *         "8.10.6",
- *       ],
- *       "Linux_Alpine": [
- *         "8.10.7",
- *         "8.8.4",
- *       ],
- *     },
- *     "A_ARM": {
- *       "Linux_UnknownLinux": [
- *         "8.10.7"
- *       ]
- *     },
- *     "A_ARM64": {
- *       "Darwin": [
- *         "8.10.7"
- *       ],
- *       "Linux_UnknownLinux": [
- *         "8.10.7"
- *       ]
- *     }
- *   }
- * }
- * ```
- *
- * consult [ghcup metadata repo](https://github.com/haskell/ghcup-metadata/) for details.
- */
-export type ReleaseMetadata = Map<string, Map<string, Map<string, string[]>>>;
-
-/**
- * Compute Map of supported HLS versions for this platform.
- * Fetches HLS metadata information.
- *
- * @param context Context of the extension, required for metadata.
- * @param logger Logger for feedback
- * @returns Map of supported HLS versions or null if metadata could not be fetched.
- */
-async function getHlsMetadata(context: ExtensionContext, logger: Logger): Promise<Map<string, string[]> | null> {
-  const storagePath: string = getStoragePath(context);
-  const metadata = await getReleaseMetadata(storagePath, logger).catch(() => null);
-  if (!metadata) {
-    window.showErrorMessage('Could not get release metadata');
-    return null;
-  }
-  const plat: Platform | null = match(process.platform)
-    .with('darwin', () => 'Darwin' as Platform)
-    .with('linux', () => 'Linux_UnknownLinux' as Platform)
-    .with('win32', () => 'Windows' as Platform)
-    .with('freebsd', () => 'FreeBSD' as Platform)
-    .otherwise(() => null);
-  if (plat === null) {
-    throw new Error(`Unknown platform ${process.platform}`);
-  }
-  const arch: Arch | null = match(process.arch)
-    .with('arm', () => 'A_ARM' as Arch)
-    .with('arm64', () => 'A_ARM64' as Arch)
-    .with('ia32', () => 'A_32' as Arch)
-    .with('x64', () => 'A_64' as Arch)
-    .otherwise(() => null);
-  if (arch === null) {
-    throw new Error(`Unknown architecture ${process.arch}`);
-  }
-
-  return findSupportedHlsPerGhc(plat, arch, metadata, logger);
-}
-
-export type Platform = 'Darwin' | 'Linux_UnknownLinux' | 'Windows' | 'FreeBSD';
-
-export type Arch = 'A_ARM' | 'A_ARM64' | 'A_32' | 'A_64';
-
-/**
- * Find all supported GHC versions per HLS version supported on the given
- * platform and architecture.
- * @param platform Platform of the host.
- * @param arch Arch of the host.
- * @param metadata HLS Metadata information.
- * @param logger Logger.
- * @returns Map from HLS version to GHC versions that are supported.
- */
-export function findSupportedHlsPerGhc(
-  platform: Platform,
-  arch: Arch,
-  metadata: ReleaseMetadata,
-  logger: Logger,
-): Map<string, string[]> {
-  logger.info(`Platform constants: ${platform}, ${arch}`);
-  const newMap = new Map<string, string[]>();
-  metadata.forEach((supportedArch, hlsVersion) => {
-    const supportedOs = supportedArch.get(arch);
-    if (supportedOs) {
-      const ghcSupportedOnOs = supportedOs.get(platform);
-      if (ghcSupportedOnOs) {
-        logger.log(`HLS ${hlsVersion} compatible with GHC Versions: ${ghcSupportedOnOs.join(',')}`);
-        // copy supported ghc versions to avoid unintended modifications
-        newMap.set(hlsVersion, [...ghcSupportedOnOs]);
-      }
-    }
-  });
-
-  return newMap;
-}
-
-/**
- * Download GHCUP metadata.
- *
- * @param storagePath Path to put in binary files and caches.
- * @param logger Logger for feedback.
- * @returns Metadata of releases, or null if the cache can not be found.
- */
-async function getReleaseMetadata(storagePath: string, logger: Logger): Promise<ReleaseMetadata | null> {
-  const releasesUrl = workspace.getConfiguration('haskell').releasesURL
-    ? new URL(workspace.getConfiguration('haskell').releasesURL as string)
-    : undefined;
-  const opts: https.RequestOptions = releasesUrl
-    ? {
-        host: releasesUrl.host,
-        path: releasesUrl.pathname,
-      }
-    : {
-        host: 'raw.githubusercontent.com',
-        path: '/haskell/ghcup-metadata/master/hls-metadata-0.0.1.json',
-      };
-
-  const offlineCache = path.join(storagePath, 'ghcupReleases.cache.json');
-
-  /**
-   * Convert a json value to ReleaseMetadata.
-   * Assumes the json is well-formed and a valid Release-Metadata.
-   * @param someObj Release Metadata without any typing information but well-formed.
-   * @returns Typed ReleaseMetadata.
-   */
-  const objectToMetadata = (someObj: any): ReleaseMetadata => {
-    const obj = someObj as [string: [string: [string: string[]]]];
-    const hlsMetaEntries = Object.entries(obj).map(([hlsVersion, archMap]) => {
-      const archMetaEntries = Object.entries(archMap).map(([arch, supportedGhcVersionsPerOs]) => {
-        return [arch, new Map(Object.entries(supportedGhcVersionsPerOs))] as [string, Map<string, string[]>];
-      });
-      return [hlsVersion, new Map(archMetaEntries)] as [string, Map<string, Map<string, string[]>>];
-    });
-    return new Map(hlsMetaEntries);
-  };
-
-  async function readCachedReleaseData(): Promise<ReleaseMetadata | null> {
-    try {
-      logger.info(`Reading cached release data at ${offlineCache}`);
-      const cachedInfo = await promisify(fs.readFile)(offlineCache, { encoding: 'utf-8' });
-      // export type ReleaseMetadata = Map<string, Map<string, Map<string, string[]>>>;
-      const value: any = JSON.parse(cachedInfo);
-      return objectToMetadata(value);
-    } catch (err: any) {
-      // If file doesn't exist, return null, otherwise consider it a failure
-      if (err.code === 'ENOENT') {
-        logger.warn(`No cached release data found at ${offlineCache}`);
-        return null;
-      }
-      throw err;
-    }
-  }
-
-  try {
-    const releaseInfo = await httpsGetSilently(opts);
-    const releaseInfoParsed = JSON.parse(releaseInfo);
-
-    // Cache the latest successfully fetched release information
-    await promisify(fs.writeFile)(offlineCache, JSON.stringify(releaseInfoParsed), { encoding: 'utf-8' });
-    return objectToMetadata(releaseInfoParsed);
-  } catch (githubError: any) {
-    // 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: " +
-          githubError.message,
-      );
-      return cachedInfoParsed;
-    } catch (_fileError) {
-      throw new Error("Couldn't get the latest haskell-language-server releases from GitHub: " + githubError.message);
-    }
-  }
-}
-
 /**
  * Tracks the name, version and installation state of tools we need.
  */