@jsii/kernel 1.86.1 → 1.87.0

package/lib/disk-cache/disk-cache.d.ts

@@ -13,12 +13,32 @@ export declare class Entry {
     constructor(path: string);
     get atime(): Date;
     get pathExists(): boolean;
+    /**
+     * Whether the directory has been completely written
+     *
+     * The presence of the marker file is a signal that we can skip trying to lock the directory.
+     */
+    get isComplete(): boolean;
+    /**
+     * Retrieve an entry from the cache
+     *
+     * If the entry doesn't exist yet, use 'cb' to produce the file contents.
+     */
+    retrieve(cb: (path: string) => void): {
+        path: string;
+        cache: 'hit' | 'miss';
+    };
     lock<T>(cb: (entry: LockedEntry) => T): T;
     read(file: string): Buffer | undefined;
 }
 export interface LockedEntry {
     delete(): void;
     write(name: string, data: Buffer): void;
-    touch(): void;
+    /**
+     * Mark the entry has having been completed
+     *
+     * The modification time of this file is used for cleanup.
+     */
+    markComplete(): void;
 }
 //# sourceMappingURL=disk-cache.d.ts.map

package/lib/disk-cache/disk-cache.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _DiskCache_instances, _a, _DiskCache_CACHE, _DiskCache_root, _DiskCache_entries, _Entry_instances, _Entry_lockFile_get, _Entry_markerFile_get;
+var _DiskCache_instances, _a, _DiskCache_CACHE, _DiskCache_root, _DiskCache_entries, _Entry_instances, _Entry_lockFile_get, _Entry_markerFile_get, _Entry_touchMarkerFile;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entry = exports.DiskCache = void 0;
 const fs_1 = require("fs");
@@ -128,9 +128,56 @@ class Entry {
     get pathExists() {
         return (0, fs_1.existsSync)(this.path);
     }
+    /**
+     * Whether the directory has been completely written
+     *
+     * The presence of the marker file is a signal that we can skip trying to lock the directory.
+     */
+    get isComplete() {
+        return (0, fs_1.existsSync)(__classPrivateFieldGet(this, _Entry_instances, "a", _Entry_markerFile_get));
+    }
+    /**
+     * Retrieve an entry from the cache
+     *
+     * If the entry doesn't exist yet, use 'cb' to produce the file contents.
+     */
+    retrieve(cb) {
+        // If the marker file already exists, update its timestamp and immediately return.
+        // We don't even try to lock.
+        if (this.isComplete) {
+            __classPrivateFieldGet(this, _Entry_instances, "m", _Entry_touchMarkerFile).call(this);
+            return { path: this.path, cache: 'hit' };
+        }
+        let cache = 'miss';
+        this.lock((lock) => {
+            // While we all fought to acquire the lock, someone else might have completed already.
+            if (this.isComplete) {
+                cache = 'hit';
+                return;
+            }
+            // !!!IMPORTANT!!!
+            // Extract directly into the final target directory, as certain antivirus
+            // software configurations on Windows will make a `renameSync` operation
+            // fail with EPERM until the files have been fully analyzed.
+            (0, fs_1.mkdirSync)(this.path, { recursive: true });
+            try {
+                cb(this.path);
+            }
+            catch (error) {
+                (0, fs_1.rmSync)(this.path, { force: true, recursive: true });
+                throw error;
+            }
+            lock.markComplete();
+        });
+        return { path: this.path, cache };
+    }
     lock(cb) {
         (0, fs_1.mkdirSync)((0, path_1.dirname)(this.path), { recursive: true });
-        (0, lockfile_1.lockSync)(__classPrivateFieldGet(this, _Entry_instances, "a", _Entry_lockFile_get), { retries: 12, stale: 5000 });
+        lockSyncWithWait(__classPrivateFieldGet(this, _Entry_instances, "a", _Entry_lockFile_get), {
+            retries: 12,
+            // Extracting the largest tarball takes ~5s
+            stale: 10000,
+        });
         let disposed = false;
         try {
             return cb({
@@ -147,19 +194,11 @@ class Entry {
                     (0, fs_1.mkdirSync)((0, path_1.dirname)((0, path_1.join)(this.path, name)), { recursive: true });
                     (0, fs_1.writeFileSync)((0, path_1.join)(this.path, name), content);
                 },
-                touch: () => {
+                markComplete: () => {
                     if (disposed) {
                         throw new Error(`Cannot touch ${this.path} once the lock block was returned!`);
                     }
-                    if (this.pathExists) {
-                        if ((0, fs_1.existsSync)(__classPrivateFieldGet(this, _Entry_instances, "a", _Entry_markerFile_get))) {
-                            const now = new Date();
-                            (0, fs_1.utimesSync)(__classPrivateFieldGet(this, _Entry_instances, "a", _Entry_markerFile_get), now, now);
-                        }
-                        else {
-                            (0, fs_1.writeFileSync)(__classPrivateFieldGet(this, _Entry_instances, "a", _Entry_markerFile_get), '');
-                        }
-                    }
+                    __classPrivateFieldGet(this, _Entry_instances, "m", _Entry_touchMarkerFile).call(this);
                 },
             });
         }
@@ -185,6 +224,19 @@ _Entry_instances = new WeakSet(), _Entry_lockFile_get = function _Entry_lockFile
     return `${this.path}.lock`;
 }, _Entry_markerFile_get = function _Entry_markerFile_get() {
     return (0, path_1.join)(this.path, MARKER_FILE_NAME);
+}, _Entry_touchMarkerFile = function _Entry_touchMarkerFile() {
+    if (this.pathExists) {
+        try {
+            const now = new Date();
+            (0, fs_1.utimesSync)(__classPrivateFieldGet(this, _Entry_instances, "a", _Entry_markerFile_get), now, now);
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                throw e;
+            }
+            (0, fs_1.writeFileSync)(__classPrivateFieldGet(this, _Entry_instances, "a", _Entry_markerFile_get), '');
+        }
+    }
 };
 function* directoriesUnder(root, recursive = false, ignoreErrors = true) {
     for (const file of (0, fs_1.readdirSync)(root)) {
@@ -205,4 +257,45 @@ function* directoriesUnder(root, recursive = false, ignoreErrors = true) {
         }
     }
 }
+/**
+ * We must use 'lockSync', but that doesn't support waiting (because waiting is only supported for async APIs)
+ * so we have to build our own looping locker with waits
+ */
+function lockSyncWithWait(path, options) {
+    var _b;
+    let retries = (_b = options.retries) !== null && _b !== void 0 ? _b : 0;
+    let sleep = 100;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            (0, lockfile_1.lockSync)(path, {
+                retries: 0,
+                stale: options.stale,
+            });
+            return;
+        }
+        catch (e) {
+            if (retries === 0) {
+                throw e;
+            }
+            retries--;
+            if (e.code === 'EEXIST') {
+                // Most common case, needs longest sleep. Randomize the herd.
+                sleepSync(Math.floor(Math.random() * sleep));
+                sleep *= 1.5;
+            }
+            else {
+                sleepSync(5);
+            }
+        }
+    }
+}
+/**
+ * Abuse Atomics.wait() to come up with a sync sleep
+ *
+ * We must use a sync sleep because all of jsii is sync.
+ */
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
 //# sourceMappingURL=disk-cache.js.map

package/lib/link.d.ts

@@ -1,9 +1,14 @@
 /**
- * Creates directories containing hard links if possible, and falls back on
- * copy otherwise.
+ * Link existing to destination directory
  *
- * @param existing    is the original file or directory to link.
- * @param destination is the new file or directory to create.
+ * - If Node has been started with a module resolution strategy that does not
+ *   resolve symlinks (so peerDependencies can be found), use symlinking.
+ *   Symlinking may fail on Windows for non-Admin users.
+ * - If not symlinking the entire directory, crawl the directory tree and
+ *   hardlink all files (if possible), copying them if not.
+ *
+ * @param existingRoot    is the original file or directory to link.
+ * @param destinationRoot is the new file or directory to create.
  */
-export declare function link(existing: string, destination: string): void;
+export declare function link(existingRoot: string, destinationRoot: string): void;
 //# sourceMappingURL=link.d.ts.map

package/lib/link.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.link = void 0;
 const fs_1 = require("fs");
+const os = require("os");
 const path_1 = require("path");
 /**
  * If `node` is started with `--preserve-symlinks`, the module loaded will
@@ -10,31 +11,49 @@ const path_1 = require("path");
  */
 const PRESERVE_SYMLINKS = process.execArgv.includes('--preserve-symlinks');
 /**
- * Creates directories containing hard links if possible, and falls back on
- * copy otherwise.
+ * Link existing to destination directory
  *
- * @param existing    is the original file or directory to link.
- * @param destination is the new file or directory to create.
+ * - If Node has been started with a module resolution strategy that does not
+ *   resolve symlinks (so peerDependencies can be found), use symlinking.
+ *   Symlinking may fail on Windows for non-Admin users.
+ * - If not symlinking the entire directory, crawl the directory tree and
+ *   hardlink all files (if possible), copying them if not.
+ *
+ * @param existingRoot    is the original file or directory to link.
+ * @param destinationRoot is the new file or directory to create.
  */
-function link(existing, destination) {
+function link(existingRoot, destinationRoot) {
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(destinationRoot), { recursive: true });
     if (PRESERVE_SYMLINKS) {
-        (0, fs_1.mkdirSync)((0, path_1.dirname)(destination), { recursive: true });
-        (0, fs_1.symlinkSync)(existing, destination);
-        return;
-    }
-    const stat = (0, fs_1.statSync)(existing);
-    if (!stat.isDirectory()) {
         try {
-            (0, fs_1.linkSync)(existing, destination);
+            (0, fs_1.symlinkSync)(existingRoot, destinationRoot);
+            return;
         }
-        catch {
-            (0, fs_1.copyFileSync)(existing, destination);
+        catch (e) {
+            // On Windows, non-Admin users aren't allowed to create symlinks. In that case, fall back to the copying workflow.
+            const winNoSymlink = e.code === 'EPERM' && os.platform() === 'win32';
+            if (!winNoSymlink) {
+                throw e;
+            }
         }
-        return;
     }
-    (0, fs_1.mkdirSync)(destination, { recursive: true });
-    for (const file of (0, fs_1.readdirSync)(existing)) {
-        link((0, path_1.join)(existing, file), (0, path_1.join)(destination, file));
+    // Fall back to the slow method
+    recurse(existingRoot, destinationRoot);
+    function recurse(existing, destination) {
+        const stat = (0, fs_1.statSync)(existing);
+        if (!stat.isDirectory()) {
+            try {
+                (0, fs_1.linkSync)(existing, destination);
+            }
+            catch {
+                (0, fs_1.copyFileSync)(existing, destination);
+            }
+            return;
+        }
+        (0, fs_1.mkdirSync)(destination, { recursive: true });
+        for (const file of (0, fs_1.readdirSync)(existing)) {
+            recurse((0, path_1.join)(existing, file), (0, path_1.join)(destination, file));
+        }
     }
 }
 exports.link = link;

package/lib/tar-cache/index.js

@@ -28,38 +28,27 @@ function extract(file, outDir, options, ...comments) {
     }
 }
 exports.extract = extract;
+/**
+ * Extract the tarball into a cached directory, symlink that directory into the target location
+ */
 function extractViaCache(file, outDir, options = {}, ...comments) {
     var _a;
     const cacheRoot = (_a = process.env.JSII_RUNTIME_PACKAGE_CACHE_ROOT) !== null && _a !== void 0 ? _a : (0, default_cache_root_1.defaultCacheRoot)();
     const dirCache = disk_cache_1.DiskCache.inDirectory(cacheRoot);
     const entry = dirCache.entryFor(file, ...comments);
-    const { path, cache } = entry.lock((lock) => {
-        let cache = 'hit';
-        if (!entry.pathExists) {
-            // !!!IMPORTANT!!!
-            // Extract directly into the final target directory, as certain antivirus
-            // software configurations on Windows will make a `renameSync` operation
-            // fail with EPERM until the files have been fully analyzed.
-            (0, fs_1.mkdirSync)(entry.path, { recursive: true });
-            try {
-                untarInto({
-                    ...options,
-                    cwd: entry.path,
-                    file,
-                });
-            }
-            catch (error) {
-                (0, fs_1.rmSync)(entry.path, { force: true, recursive: true });
-                throw error;
-            }
-            cache = 'miss';
-        }
-        lock.touch();
-        return { path: entry.path, cache };
+    const { path, cache } = entry.retrieve((path) => {
+        untarInto({
+            ...options,
+            cwd: path,
+            file,
+        });
     });
     (0, link_1.link)(path, outDir);
     return { cache };
 }
+/**
+ * Extract directory into the target location
+ */
 function extractToOutDir(file, cwd, options = {}) {
     // The output directory must already exist...
     (0, fs_1.mkdirSync)(cwd, { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsii/kernel",
-  "version": "1.86.1",
+  "version": "1.87.0",
   "description": "kernel for jsii execution environment",
   "license": "Apache-2.0",
   "author": {
@@ -31,19 +31,19 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/spec": "^1.86.1",
+    "@jsii/spec": "^1.87.0",
     "fs-extra": "^10.1.0",
     "lockfile": "^1.0.4",
     "tar": "^6.1.15"
   },
   "devDependencies": {
-    "@scope/jsii-calc-base": "^1.86.1",
-    "@scope/jsii-calc-lib": "^1.86.1",
+    "@scope/jsii-calc-base": "^1.87.0",
+    "@scope/jsii-calc-lib": "^1.87.0",
     "@types/fs-extra": "^9.0.13",
     "@types/lockfile": "^1.0.2",
     "@types/tar": "^6.1.5",
     "jest-expect-message": "^1.1.3",
-    "jsii-build-tools": "^1.86.1",
+    "jsii-build-tools": "^1.87.0",
     "jsii-calc": "^3.20.120"
   }
 }