Separate read and write operations on lastKnownGood.json

sources/Engine.ts

@@ -1,5 +1,4 @@
 import {UsageError}                                           from 'clipanion';
-import type {FileHandle}                                      from 'fs/promises';
 import fs                                                     from 'fs';
 import path                                                   from 'path';
 import process                                                from 'process';
@@ -25,50 +24,58 @@ export type PackageManagerRequest = {
   binaryVersion: string | null;
 };
 
-export function getLastKnownGoodFile(flag = `r`) {
-  return fs.promises.open(path.join(folderUtils.getCorepackHomeFolder(), `lastKnownGood.json`), flag);
-}
-async function createLastKnownGoodFile() {
-  await fs.promises.mkdir(folderUtils.getCorepackHomeFolder(), {recursive: true});
-  return getLastKnownGoodFile(`w`);
+function getLastKnownGoodFilePath() {
+  return path.join(folderUtils.getCorepackHomeFolder(), `lastKnownGood.json`);
 }
 
-export async function getJSONFileContent(fh: FileHandle) {
-  let lastKnownGood: unknown;
+export async function getLastKnownGood(): Promise<Record<string, string>> {
+  let raw: string;
   try {
-    lastKnownGood = JSON.parse(await fh.readFile(`utf8`));
+    raw = await fs.promises.readFile(getLastKnownGoodFilePath(), `utf8`);
+  } catch (err) {
+    if ((err as NodeError)?.code === `ENOENT`) return {};
+    throw err;
+  }
+
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed) return {};
+    if (typeof parsed !== `object`) return {};
+    Object.entries(parsed).forEach(([key, value]) => {
+      if (typeof value !== `string`) {
+        // Ensure that all entries are strings.
+        delete parsed[key];
+      }
+    });
+    return parsed;
   } catch {
     // Ignore errors; too bad
-    return undefined;
+    return {};
   }
-
-  return lastKnownGood;
 }
 
-async function overwriteJSONFileContent(fh: FileHandle, content: unknown) {
-  await fh.truncate(0);
-  await fh.write(`${JSON.stringify(content, null, 2)}\n`, 0);
+async function createLastKnownGoodFile(lastKnownGood: Record<string, string>) {
+  const content = `${JSON.stringify(lastKnownGood, null, 2)}\n`;
+  await fs.promises.mkdir(folderUtils.getCorepackHomeFolder(), {recursive: true});
+  await fs.promises.writeFile(getLastKnownGoodFilePath(), content, `utf8`);
 }
 
-export function getLastKnownGoodFromFileContent(lastKnownGood: unknown, packageManager: string) {
-  if (typeof lastKnownGood === `object` && lastKnownGood !== null &&
-    Object.hasOwn(lastKnownGood, packageManager)) {
-    const override = (lastKnownGood as any)[packageManager];
-    if (typeof override === `string`) {
-      return override;
-    }
-  }
+export function getLastKnownGoodFromFileContent(lastKnownGood: Record<string, string>, packageManager: string) {
+  if (Object.hasOwn(lastKnownGood, packageManager))
+    return lastKnownGood[packageManager];
   return undefined;
 }
 
-export async function activatePackageManagerFromFileHandle(lastKnownGoodFile: FileHandle, lastKnownGood: unknown, locator: Locator) {
-  if (typeof lastKnownGood !== `object` || lastKnownGood === null)
-    lastKnownGood = {};
+export async function activatePackageManager(lastKnownGood: Record<string, string>, locator: Locator) {
+  if (lastKnownGood[locator.name] === locator.reference) {
+    debugUtils.log(`${locator.name}@${locator.reference} is already Last Known Good version`);
+    return;
+  }
 
-  (lastKnownGood as Record<string, string>)[locator.name] = locator.reference;
+  lastKnownGood[locator.name] = locator.reference;
 
   debugUtils.log(`Setting ${locator.name}@${locator.reference} as Last Known Good version`);
-  await overwriteJSONFileContent(lastKnownGoodFile, lastKnownGood);
+  await createLastKnownGoodFile(lastKnownGood);
 }
 
 export class Engine {
@@ -150,54 +157,32 @@ export class Engine {
     if (typeof definition === `undefined`)
       throw new UsageError(`This package manager (${packageManager}) isn't supported by this corepack build`);
 
-    let lastKnownGoodFile = await getLastKnownGoodFile(`r+`).catch(err => {
-      if ((err as NodeError)?.code !== `ENOENT` && (err as NodeError)?.code !== `EROFS`) {
-        throw err;
-      }
-    });
-    try {
-      const lastKnownGood = lastKnownGoodFile == null || await getJSONFileContent(lastKnownGoodFile!);
-      const lastKnownGoodForThisPackageManager = getLastKnownGoodFromFileContent(lastKnownGood, packageManager);
-      if (lastKnownGoodForThisPackageManager)
-        return lastKnownGoodForThisPackageManager;
-
-      if (process.env.COREPACK_DEFAULT_TO_LATEST === `0`)
-        return definition.default;
-
-      const reference = await corepackUtils.fetchLatestStableVersion(definition.fetchLatestFrom);
-
-      try {
-        lastKnownGoodFile ??= await createLastKnownGoodFile();
-        await activatePackageManagerFromFileHandle(lastKnownGoodFile, lastKnownGood, {
-          name: packageManager,
-          reference,
-        });
-      } catch {
-        // If for some reason, we cannot update the last known good file, we
-        // ignore the error.
-      }
+    const lastKnownGood = await getLastKnownGood();
+    const lastKnownGoodForThisPackageManager = getLastKnownGoodFromFileContent(lastKnownGood, packageManager);
+    if (lastKnownGoodForThisPackageManager)
+      return lastKnownGoodForThisPackageManager;
 
-      return reference;
-    } finally {
-      await lastKnownGoodFile?.close();
-    }
-  }
+    if (process.env.COREPACK_DEFAULT_TO_LATEST === `0`)
+      return definition.default;
 
-  async activatePackageManager(locator: Locator) {
-    let emptyFile = false;
-    const lastKnownGoodFile = await getLastKnownGoodFile(`r+`).catch(err => {
-      if ((err as NodeError)?.code === `ENOENT`) {
-        emptyFile = true;
-        return getLastKnownGoodFile(`w`);
-      }
+    const reference = await corepackUtils.fetchLatestStableVersion(definition.fetchLatestFrom);
 
-      throw err;
-    });
     try {
-      await activatePackageManagerFromFileHandle(lastKnownGoodFile, emptyFile || await getJSONFileContent(lastKnownGoodFile), locator);
-    } finally {
-      await lastKnownGoodFile.close();
+      await activatePackageManager(lastKnownGood, {
+        name: packageManager,
+        reference,
+      });
+    } catch {
+      // If for some reason, we cannot update the last known good file, we
+      // ignore the error.
     }
+
+    return reference;
+  }
+
+  async activatePackageManager(locator: Locator) {
+    const lastKnownGood = await getLastKnownGood();
+    await activatePackageManager(lastKnownGood, locator);
   }
 
   async ensurePackageManager(locator: Locator) {

sources/corepackUtils.ts

@@ -1,6 +1,5 @@
 import {createHash}                                            from 'crypto';
 import {once}                                                  from 'events';
-import {FileHandle}                                            from 'fs/promises';
 import fs                                                      from 'fs';
 import type {Dir}                                              from 'fs';
 import Module                                                  from 'module';
@@ -325,26 +324,14 @@ export async function installVersion(installTarget: string, locator: Locator, {s
   }
 
   if (locatorIsASupportedPackageManager && process.env.COREPACK_DEFAULT_TO_LATEST !== `0`) {
-    let lastKnownGoodFile: FileHandle;
-    try {
-      lastKnownGoodFile = await engine.getLastKnownGoodFile(`r+`);
-      const lastKnownGood = await engine.getJSONFileContent(lastKnownGoodFile);
-      const defaultVersion = engine.getLastKnownGoodFromFileContent(lastKnownGood, locator.name);
-      if (defaultVersion) {
-        const currentDefault = semver.parse(defaultVersion)!;
-        const downloadedVersion = locatorReference as semver.SemVer;
-        if (currentDefault.major === downloadedVersion.major && semver.lt(currentDefault, downloadedVersion)) {
-          await engine.activatePackageManagerFromFileHandle(lastKnownGoodFile, lastKnownGood, locator);
-        }
-      }
-    } catch (err) {
-      // ENOENT would mean there are no lastKnownGoodFile, in which case we can ignore.
-      if ((err as nodeUtils.NodeError)?.code !== `ENOENT`) {
-        throw err;
+    const lastKnownGood = await engine.getLastKnownGood();
+    const defaultVersion = engine.getLastKnownGoodFromFileContent(lastKnownGood, locator.name);
+    if (defaultVersion) {
+      const currentDefault = semver.parse(defaultVersion)!;
+      const downloadedVersion = locatorReference as semver.SemVer;
+      if (currentDefault.major === downloadedVersion.major && semver.lt(currentDefault, downloadedVersion)) {
+        await engine.activatePackageManager(lastKnownGood, locator);
       }
-    } finally {
-      // @ts-expect-error used before assigned
-      await lastKnownGoodFile?.close();
     }
   }
 

tests/main.test.ts

@@ -476,6 +476,84 @@ it(`should support disabling the network accesses from the environment`, async (
   });
 });
 
+describe(`read-only and offline environment`, () => {
+  it(`should support running in project scope`, async () => {
+    await xfs.mktempPromise(async cwd => {
+      // Reset to default
+      delete process.env.COREPACK_DEFAULT_TO_LATEST;
+
+      // Prepare fake project
+      await xfs.writeJsonPromise(ppath.join(cwd, `package.json` as Filename), {
+        packageManager: `yarn@2.2.2`,
+      });
+
+      // $ corepack install
+      await expect(runCli(cwd, [`install`])).resolves.toMatchObject({
+        stdout: `Adding yarn@2.2.2 to the cache...\n`,
+        stderr: ``,
+        exitCode: 0,
+      });
+
+      // Let corepack discover the latest yarn version.
+      // BUG: This should not be necessary with a fully specified version in package.json plus populated corepack cache.
+      // Engine.executePackageManagerRequest needs to defer the fallback work. This requires a big refactoring.
+      await expect(runCli(cwd, [`yarn`, `--version`])).resolves.toMatchObject({
+        exitCode: 0,
+      });
+
+      // Make COREPACK_HOME ro
+      const home = npath.toPortablePath(folderUtils.getCorepackHomeFolder());
+      await xfs.chmodPromise(ppath.join(home, `lastKnownGood.json`), 0o444);
+      await xfs.chmodPromise(home, 0o555);
+
+      // Use fake proxies to simulate offline mode
+      process.env.HTTP_PROXY = `0.0.0.0`;
+      process.env.HTTPS_PROXY = `0.0.0.0`;
+
+      // $ corepack yarn --version
+      await expect(runCli(cwd, [`yarn`, `--version`])).resolves.toMatchObject({
+        stdout: `2.2.2\n`,
+        stderr: ``,
+        exitCode: 0,
+      });
+    });
+  });
+
+  it(`should support running globally`, async () => {
+    await xfs.mktempPromise(async installDir => {
+      // Reset to default
+      delete process.env.COREPACK_DEFAULT_TO_LATEST;
+
+      await expect(runCli(installDir, [`enable`, `--install-directory`, npath.fromPortablePath(installDir), `yarn`])).resolves.toMatchObject({
+        stdout: ``,
+        stderr: ``,
+        exitCode: 0,
+      });
+
+      await expect(runCli(installDir, [`install`, `--global`, `yarn@2.2.2`])).resolves.toMatchObject({
+        stdout: `Installing yarn@2.2.2...\n`,
+        stderr: ``,
+        exitCode: 0,
+      });
+
+      // Make COREPACK_HOME ro
+      const home = npath.toPortablePath(folderUtils.getCorepackHomeFolder());
+      await xfs.chmodPromise(ppath.join(home, `lastKnownGood.json`), 0o444);
+      await xfs.chmodPromise(home, 0o555);
+
+      // Use fake proxies to simulate offline mode
+      process.env.HTTP_PROXY = `0.0.0.0`;
+      process.env.HTTPS_PROXY = `0.0.0.0`;
+
+      await expect(runCli(installDir, [`yarn`, `--version`])).resolves.toMatchObject({
+        stdout: `2.2.2\n`,
+        stderr: ``,
+        exitCode: 0,
+      });
+    });
+  });
+});
+
 it(`should support hydrating package managers from cached archives`, async () => {
   await xfs.mktempPromise(async cwd => {
     await expect(runCli(cwd, [`pack`, `yarn@2.2.2`])).resolves.toMatchObject({