@agoric/internal 0.3.3-dev-3dacdc3.0.3dacdc3 → 0.3.3-dev-2db363c.0.2db363c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/internal",
-  "version": "0.3.3-dev-3dacdc3.0.3dacdc3",
+  "version": "0.3.3-dev-2db363c.0.2db363c",
   "description": "Externally unsupported utilities internal to agoric-sdk",
   "type": "module",
   "main": "src/index.js",
@@ -20,7 +20,7 @@
     "lint:types": "yarn run -T tsc"
   },
   "dependencies": {
-    "@agoric/base-zone": "0.1.1-dev-3dacdc3.0.3dacdc3",
+    "@agoric/base-zone": "0.1.1-dev-2db363c.0.2db363c",
     "@endo/cache-map": "^1.1.0",
     "@endo/common": "^1.2.13",
     "@endo/compartment-mapper": "^1.6.3",
@@ -38,7 +38,7 @@
     "jessie.js": "^0.3.4"
   },
   "devDependencies": {
-    "@agoric/cosmic-proto": "0.4.1-dev-3dacdc3.0.3dacdc3",
+    "@agoric/cosmic-proto": "0.4.1-dev-2db363c.0.2db363c",
     "@endo/exo": "^1.5.12",
     "@endo/init": "^1.1.12",
     "@endo/ses-ava": "^1.3.2",
@@ -66,5 +66,5 @@
   "typeCoverage": {
     "atLeast": 92.84
   },
-  "gitHead": "3dacdc33b578ee52258e5771192bf8e57beb603b"
+  "gitHead": "2db363cfdc60b99cc644823e99bced301cf748b5"
 }

package/src/build-cache-types.d.ts

@@ -0,0 +1,33 @@
+export interface LockLifecycleEvent {
+    key: string;
+    lockPath: string;
+    type: 'lock-acquired' | 'lock-released';
+}
+export interface LockWaitingEvent {
+    key: string;
+    lockPath: string;
+    type: 'lock-waiting';
+    waitedMs: number;
+}
+export interface LockBrokenEvent {
+    ageMs?: number;
+    key: string;
+    lockPath: string;
+    ownerPid?: number;
+    reason: 'dead-owner' | 'stale-age';
+    staleLockMs?: number;
+    type: 'lock-broken';
+}
+export type BuildCacheEvent = LockLifecycleEvent | LockWaitingEvent | LockBrokenEvent;
+export interface DirectoryLockPowers {
+    acquireTimeoutMs: number;
+    delayMs: (ms: number) => Promise<unknown>;
+    fs: Pick<typeof import('node:fs/promises'), 'mkdir' | 'readFile' | 'rm' | 'stat' | 'writeFile'>;
+    isPidAlive: (pid: number) => boolean;
+    lockRoot: string;
+    now: () => number;
+    onEvent?: (event: BuildCacheEvent) => void;
+    pid: number;
+    staleLockMs: number;
+}
+//# sourceMappingURL=build-cache-types.d.ts.map

package/src/build-cache-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-cache-types.d.ts","sourceRoot":"","sources":["build-cache-types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,eAAe,GAAG,eAAe,CAAC;CACzC;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,cAAc,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,YAAY,GAAG,WAAW,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,aAAa,CAAC;CACrB;AAED,MAAM,MAAM,eAAe,GACvB,kBAAkB,GAClB,gBAAgB,GAChB,eAAe,CAAC;AAEpB,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1C,EAAE,EAAE,IAAI,CACN,cAAc,kBAAkB,CAAC,EACjC,OAAO,GAAG,UAAU,GAAG,IAAI,GAAG,MAAM,GAAG,WAAW,CACnD,CAAC;IACF,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;CACrB"}

package/src/build-cache-types.js

@@ -0,0 +1,42 @@
+                                     
+              
+                   
+                                          
+ 
+
+                                   
+              
+                   
+                       
+                   
+ 
+
+                                  
+                 
+              
+                   
+                    
+                                     
+                       
+                      
+ 
+
+                             
+                      
+                    
+                    
+
+                                      
+                           
+                                            
+           
+                                      
+                                                      
+    
+                                       
+                   
+                    
+                                             
+              
+                      
+ 

package/src/build-cache.d.ts

@@ -0,0 +1,12 @@
+export function makeDirectoryLock(powers: DirectoryLockPowers): {
+    withLock: (key: string, body: () => Promise<any>) => Promise<any>;
+};
+export function writeFileAtomic({ fs, filePath, data, now, pid }: {
+    fs: Pick<typeof import("node:fs/promises"), "rename" | "writeFile">;
+    filePath: string;
+    data: string;
+    now: () => number;
+    pid: number;
+}): Promise<void>;
+import type { DirectoryLockPowers } from './build-cache-types.js';
+//# sourceMappingURL=build-cache.d.ts.map

package/src/build-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-cache.d.ts","sourceRoot":"","sources":["build-cache.js"],"names":[],"mappings":"AAUO,0CAFI,mBAAmB;oBAkEjB,MAAM,QACN,MAAM,OAAO,CAAC,GAAG,CAAC;EAsF9B;AAgBM,kEAVI;IACN,EAAE,EAAE,IAAI,CAAC,iCAA0B,EAAE,QAAQ,GAAG,WAAW,CAAC,CAAC;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,iBASH;yCAlLsD,wBAAwB"}

package/src/build-cache.js

@@ -0,0 +1,184 @@
+/* eslint-env node */
+import path from 'node:path';
+
+/**
+ * @import {BuildCacheEvent, DirectoryLockPowers} from './build-cache-types.js';
+ */
+
+/**
+ * @param {DirectoryLockPowers} powers
+ */
+export const makeDirectoryLock = powers => {
+  const {
+    fs,
+    delayMs,
+    now,
+    pid,
+    isPidAlive,
+    lockRoot,
+    staleLockMs,
+    acquireTimeoutMs,
+    onEvent = () => {},
+  } = powers;
+  const safeEmit = event => {
+    try {
+      onEvent(event);
+    } catch {
+      // Event sinks must not interfere with cache lock correctness.
+    }
+  };
+
+  /** @param {string} dpath */
+  const mkdirUnlessExists = async dpath => {
+    await null; // avoid accidentally catching synchronous exceptions
+    try {
+      await fs.mkdir(dpath);
+      return true;
+    } catch (err) {
+      const e = /** @type {NodeJS.ErrnoException} */ (err);
+      if (e.code === 'EEXIST') {
+        return false;
+      }
+      throw err;
+    }
+  };
+
+  /** @param {string} fpath */
+  const statUnlessMissing = async fpath => {
+    await null; // avoid accidentally catching synchronous exceptions
+    try {
+      return await fs.stat(fpath);
+    } catch (err) {
+      const e = /** @type {NodeJS.ErrnoException} */ (err);
+      if (e.code === 'ENOENT') {
+        return undefined;
+      }
+      throw err;
+    }
+  };
+
+  /** @param {string} fpath */
+  const readUnlessMissing = async fpath => {
+    await null; // avoid accidentally catching synchronous exceptions
+    try {
+      return await fs.readFile(fpath, 'utf8');
+    } catch (err) {
+      const e = /** @type {NodeJS.ErrnoException} */ (err);
+      if (e.code === 'ENOENT') {
+        return undefined;
+      }
+      throw err;
+    }
+  };
+
+  /**
+   * @param {string} key
+   * @param {() => Promise<any>} body
+   */
+  const withLock = async (key, body) => {
+    const lockPath = path.join(lockRoot, `${encodeURIComponent(key)}.lock`);
+    const ownerPath = path.join(lockPath, 'owner.json');
+    await fs.mkdir(lockRoot, { recursive: true });
+    const started = now();
+
+    const maybeBreakStaleLock = async () => {
+      const ownerText = await readUnlessMissing(ownerPath);
+      if (ownerText) {
+        try {
+          const ownerInfo = JSON.parse(ownerText);
+          if (
+            ownerInfo &&
+            typeof ownerInfo === 'object' &&
+            Number.isInteger(ownerInfo.pid) &&
+            !isPidAlive(ownerInfo.pid)
+          ) {
+            await fs.rm(lockPath, { recursive: true, force: true });
+            safeEmit({
+              type: 'lock-broken',
+              key,
+              lockPath,
+              reason: 'dead-owner',
+              ownerPid: ownerInfo.pid,
+            });
+            return true;
+          }
+        } catch {
+          // rely on age-based lock breaking for malformed owner files
+        }
+      }
+
+      const lockStats = await statUnlessMissing(lockPath);
+      if (!lockStats) {
+        return true;
+      }
+      const ageMs = now() - lockStats.mtimeMs;
+      if (ageMs >= staleLockMs) {
+        await fs.rm(lockPath, { recursive: true, force: true });
+        safeEmit({
+          type: 'lock-broken',
+          key,
+          lockPath,
+          reason: 'stale-age',
+          ageMs,
+          staleLockMs,
+        });
+        return true;
+      }
+
+      return false;
+    };
+
+    for (;;) {
+      if (await mkdirUnlessExists(lockPath)) {
+        await fs.writeFile(
+          ownerPath,
+          JSON.stringify({ pid, createdAt: now() }),
+          'utf8',
+        );
+        safeEmit({ type: 'lock-acquired', key, lockPath });
+        break;
+      }
+      const recovered = await maybeBreakStaleLock();
+      if (recovered) {
+        continue;
+      }
+      const waitedMs = now() - started;
+      safeEmit({ type: 'lock-waiting', key, lockPath, waitedMs });
+      if (waitedMs >= acquireTimeoutMs) {
+        throw Error(`Timed out waiting for cache lock ${lockPath}`);
+      }
+      await delayMs(20);
+    }
+
+    try {
+      return await body();
+    } finally {
+      await fs.rm(lockPath, { recursive: true, force: true });
+      safeEmit({ type: 'lock-released', key, lockPath });
+    }
+  };
+
+  return harden({ withLock });
+};
+harden(makeDirectoryLock);
+
+let atomicWriteSequence = 0;
+
+/**
+ * @param {{
+ *   fs: Pick<import('node:fs/promises'), 'rename' | 'writeFile'>;
+ *   filePath: string;
+ *   data: string;
+ *   now: () => number;
+ *   pid: number;
+ * }} options
+ * @throws {NodeJS.ErrnoException} when a unique temp file cannot be created
+ *   or the atomic rename fails.
+ */
+export const writeFileAtomic = async ({ fs, filePath, data, now, pid }) => {
+  atomicWriteSequence += 1;
+  const tempPath = `${filePath}.${pid}.${now()}.${atomicWriteSequence}.tmp`;
+  await fs.writeFile(tempPath, data, { flag: 'wx' });
+  await fs.rename(tempPath, filePath);
+};
+harden(writeFileAtomic);

package/src/types-index.d.ts

@@ -1 +1,2 @@
 export type * from './types.js';
+export type * from './build-cache-types.js';