@andersbakken/fisk 5.0.7 → 5.0.11

package/builder/VM_runtime.js

@@ -3027,8 +3027,20 @@ var output = {
 
 var fs = libExports;
 
+// Padded canonical prefixes for DWARF path patching. The fisk client scans
+// compiled objects for these byte patterns and overwrites them in-place with
+// the real paths. Because the replacement is always shorter, a NUL terminator
+// followed by NUL fill fits inside the original region. This works on both ELF
+// objects and LTO bitcode.
+//
+// The length is PATH_MAX so any path the client could legally hand us fits
+// without truncation.
+// Keep in sync with FISK_PAD_LENGTH in src/client/FiskPathPatcher.cpp.
+const FISK_PAD_LENGTH = 4096;
+const FISK_NAME_PAD = "/fisk-name" + "_".repeat(FISK_PAD_LENGTH - "/fisk-name".length);
+const FISK_CDIR_PAD = "/fisk-cdir" + "_".repeat(FISK_PAD_LENGTH - "/fisk-cdir".length);
 class Compile extends EventEmitter__default["default"] {
-    constructor(args, argv0, dir, debug) {
+    constructor(args, argv0, dir, debug, sourceFileName, paddedPaths) {
         super();
         if (!args || !args.length || !dir || !argv0) {
             console.error(argv0, args, dir);
@@ -3141,7 +3153,10 @@ class Compile extends EventEmitter__default["default"] {
                             throw new Error("More than one source file");
                         }
                         sourcePath = args[i];
-                        args[i] = path__default["default"].join(dir, "sourcefile");
+                        if (!sourceFileName) {
+                            sourceFileName = path__default["default"].basename(sourcePath);
+                        }
+                        args[i] = path__default["default"].join(dir, sourceFileName);
                     }
                     break;
             }
@@ -3149,6 +3164,27 @@ class Compile extends EventEmitter__default["default"] {
         if (!sourcePath) {
             throw new Error("No sourcefile");
         }
+        const sourceFileInDir = path__default["default"].join(dir, sourceFileName || path__default["default"].basename(sourcePath));
+        if (paddedPaths) {
+            // -grecord-command-line embeds our own argv verbatim into
+            // DW_AT_producer, which would (a) add two PATH_MAX pads to every CU
+            // and (b) leave the builder's /compiles path in the producer, where
+            // the client's byte scan would hit the embedded pad and NUL-truncate
+            // the rest of the recorded command line. The recorded line would be
+            // the builder's rewritten argv anyway -- not the client's -- so drop
+            // it rather than record something both wrong and mangled.
+            for (let i = args.length - 1; i >= 0; --i) {
+                if (args[i] === "-grecord-command-line" || args[i] === "-frecord-command-line") {
+                    args.splice(i, 1);
+                }
+            }
+            args.push("-gno-record-command-line");
+            // The more specific source-file rule must come last: both clang and
+            // gcc let a later -fdebug-prefix-map win over an earlier one, and
+            // the directory rule is a prefix of the source-file rule.
+            args.push(`-fdebug-prefix-map=${dir}=${FISK_CDIR_PAD}`);
+            args.push(`-fdebug-prefix-map=${sourceFileInDir}=${FISK_NAME_PAD}`);
+        }
         if (!hasDashX) {
             switch (path__default["default"].extname(sourcePath)) {
                 case ".C":
@@ -3216,7 +3252,14 @@ class Compile extends EventEmitter__default["default"] {
         if (!fs.existsSync("/usr/bin/as")) {
             this.emit("stderr", "as doesn't exist");
         }
-        console.log(`Compiling source file: ${sourcePath}\n${[compiler, ...args].join(" ")}`);
+        console.log(`Compiling source file: ${sourcePath}\n${[compiler, ...args]
+            .map((x) => {
+            if (x.startsWith("-fdebug-prefix-map=")) {
+                x = x.replace(/_+$/, "___");
+            }
+            return x;
+        })
+            .join(" ")}`);
         // const env = Object.assign({ TMPDIR: dir, TEMPDIR: dir, TEMP: dir }, process.env);
         const proc = child_process__default["default"].spawn(compiler, args, {
             /*env: env, */ cwd: dir // , maxBuffer: 1024 * 1024 * 16
@@ -3239,8 +3282,9 @@ class Compile extends EventEmitter__default["default"] {
             let addDirError;
             const addDir = (directory, prefix) => {
                 try {
+                    const sourceBaseName = sourceFileName || path__default["default"].basename(sourcePath);
                     fs.readdirSync(directory).forEach((file) => {
-                        if (file === "sourcefile") {
+                        if (file === sourceBaseName) {
                             return;
                         }
                         try {
@@ -3727,7 +3771,7 @@ process.on("message", (msg) => {
                 if (argv.debug) {
                     console.log("Creating new compile", msg.commandLine, msg.argv0, msg.dir);
                 }
-                const compile = new Compile(msg.commandLine, msg.argv0, msg.dir, argv.debug);
+                const compile = new Compile(msg.commandLine, msg.argv0, msg.dir, argv.debug, msg.sourceFileName, msg.paddedPaths);
                 // console.log("running thing", msg.commandLine);
                 compile.on("stdout", (data) => {
                     send({ type: "compileStdOut", id: msg.id, data: data });

package/builder/fisk-builder.js

@@ -8171,6 +8171,7 @@ class Job extends EventEmitter__default["default"] {
         this.sha1 = data.sha1;
         this.id = data.id;
         this.builderIp = data.builderIp;
+        this.paddedPaths = data.paddedPaths;
         this.supportsCompressedResponse = data.supportsCompressedResponse;
     }
     get readyState() {
@@ -54954,6 +54955,7 @@ class Server extends EventEmitter__default["default"] {
                     sourcePath: String(req.headers["x-fisk-sourcefile"]),
                     user: String(req.headers["x-fisk-user"]),
                     supportsCompressedResponse: req.headers["x-fisk-supports-compressed-response"] === "true",
+                    paddedPaths: req.headers["x-fisk-padded-paths"] === "true",
                     ws
                 });
                 break;
@@ -55049,16 +55051,18 @@ class Server extends EventEmitter__default["default"] {
 }
 
 class CompileJob extends EventEmitter__default["default"] {
-    constructor(commandLine, argv0, id, vm) {
+    constructor(commandLine, argv0, id, vm, sourcePath, paddedPaths) {
         super();
         this.commandLine = commandLine;
         this.argv0 = argv0;
         this.id = id;
         this.vm = vm;
+        this.paddedPaths = paddedPaths;
         this.dir = path__default["default"].join(vm.root, "compiles", String(this.id));
         this.vmDir = path__default["default"].join("/", "compiles", String(this.id));
+        this.sourceFileName = sourcePath ? path__default["default"].basename(sourcePath) : "sourcefile";
         fs$3.mkdirpSync(this.dir);
-        this.fd = fs$3.openSync(path__default["default"].join(this.dir, "sourcefile"), "w");
+        this.fd = fs$3.openSync(path__default["default"].join(this.dir, this.sourceFileName), "w");
         this.cppSize = 0;
         this.startCompile = undefined;
     }
@@ -55084,7 +55088,7 @@ class CompileJob extends EventEmitter__default["default"] {
         this.startCompile = Date.now();
         fs$3.closeSync(this.fd);
         this.fd = undefined;
-        this.vm.child.send({ type: "compile", commandLine: this.commandLine, argv0: this.argv0, id: this.id, dir: this.vmDir }, this.sendCallback.bind(this));
+        this.vm.child.send({ type: "compile", commandLine: this.commandLine, argv0: this.argv0, id: this.id, dir: this.vmDir, sourceFileName: this.sourceFileName, paddedPaths: this.paddedPaths }, this.sendCallback.bind(this));
     }
     cancel() {
         this.vm.child.send({ type: "cancel", id: this.id }, this.sendCallback.bind(this));
@@ -55195,8 +55199,8 @@ class VM extends EventEmitter__default["default"] {
             }
         });
     }
-    startCompile(commandLine, argv0, id) {
-        const compile = new CompileJob(commandLine, argv0, id, this);
+    startCompile(commandLine, argv0, id, sourcePath, paddedPaths) {
+        const compile = new CompileJob(commandLine, argv0, id, this, sourcePath, paddedPaths);
         this.compiles[compile.id] = compile;
         // console.log("startCompile " + compile.id);
         return compile;
@@ -55207,7 +55211,7 @@ class VM extends EventEmitter__default["default"] {
 }
 
 const Version = 5;
-const ObjectCacheFormatVersion = 2;
+const ObjectCacheFormatVersion = 5;
 function cacheDir(option) {
     let dir = option("cache-dir");
     if (!dir) {
@@ -60918,7 +60922,7 @@ server.on("job", (job) => {
             console.log("Starting job", j.id, jobJob.sourcePath, "for", jobJob.ip, jobJob.name, "wait", jobJob.wait);
             assert__default["default"](jobJob.commandLine, "Must have commandLine");
             assert__default["default"](jobJob.argv0, "Must have argv0");
-            j.op = vm.startCompile(jobJob.commandLine, jobJob.argv0, jobJob.id);
+            j.op = vm.startCompile(jobJob.commandLine, jobJob.argv0, jobJob.id, jobJob.sourcePath, jobJob.paddedPaths);
             if (j.buffer) {
                 j.op.feed(j.buffer);
                 j.buffer = undefined;
@@ -60984,6 +60988,8 @@ server.on("job", (job) => {
                     success: event.success,
                     exitCode: event.exitCode,
                     sha1: jobJob.sha1,
+                    sourcePath: path__default["default"].join(j.op.vmDir, j.op.sourceFileName),
+                    originalSourcePath: jobJob.sourcePath,
                     stderr: j.stderr,
                     stdout: j.stdout
                 };
@@ -61008,7 +61014,6 @@ server.on("job", (job) => {
                                 uncompressedSize: item.uncompressed.byteLength
                             };
                         }) });
-                    cacheResponse.sourcePath = jobJob.sourcePath;
                     cacheResponse.commandLine = jobJob.commandLine;
                     cacheResponse.environment = jobJob.hash;
                     objectCache.add(cacheResponse, contents);

package/daemon/fisk-daemon.js

@@ -3762,7 +3762,7 @@ class Slots extends EventEmitter__default["default"] {
 }
 
 const Version = 5;
-const ObjectCacheFormatVersion = 2;
+const ObjectCacheFormatVersion = 5;
 function cacheDir(option) {
     let dir = option("cache-dir");
     if (!dir) {
@@ -4511,7 +4511,7 @@ const option = createOptions({
 const common = common$1(option);
 const debug = option("debug");
 process.on("unhandledRejection", (reason, p) => {
-    console.log("Unhandled Rejection at: Promise", p, "reason:", reason === null || reason === void 0 ? void 0 : reason.stack);
+    console.error("Unhandled Rejection at: Promise", p, "reason:", reason === null || reason === void 0 ? void 0 : reason.stack);
     process.exit();
     // if (client)
     //     client.send('log', { message: `Unhandled Rejection at: Promise ${p}, reason: ${reason.stack}` });
@@ -4535,6 +4535,7 @@ const compileSlots = new Slots(option.int("slots", Math.max(os__default["default
 const localSlotCount = option.int("local-slots", 0);
 const localSlots = new Slots(localSlotCount, "local", debug);
 const localSlotsMaxLoad = option("local-slots-max-load") || 0;
+console.log(`cpp slots: ${cppSlots.capacity}, compile slots: ${compileSlots.capacity}, local slots: ${localSlots.capacity}, local max load: ${localSlotsMaxLoad}`);
 const compilerInfoCache = new CompilerInfoCache();
 const slotSubscribers = [];
 function slotsInfo() {
@@ -4659,9 +4660,7 @@ server.on("compile", (compile) => {
         }
     });
     compile.on("acquireSlot", (msg) => {
-        if (debug) {
-            console.log("acquireSlot", msg);
-        }
+        console.log("acquireSlot", msg);
         const compilerPath = msg && typeof msg.compiler === "string" && msg.compiler.length > 0 ? msg.compiler : null;
         const infoResult = compilerPath
             ? compilerInfoCache.get(compilerPath).then((info) => ({ info, error: null }), (err) => {
@@ -4688,7 +4687,7 @@ server.on("compile", (compile) => {
                 }
                 compile.send(response);
             };
-            if (canAcquireLocalSlot() && localSlots.tryAcquire(compile.id, { pid: compile.pid })) {
+            if (!(msg === null || msg === void 0 ? void 0 : msg["no-local"]) && canAcquireLocalSlot() && localSlots.tryAcquire(compile.id, { pid: compile.pid })) {
                 if (debug) {
                     console.log("acquireSlot -> local slot granted");
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@andersbakken/fisk",
-    "version": "5.0.7",
+    "version": "5.0.11",
     "description": "Fisk, a distributed compile system",
     "scripts": {
         "lint": "eslint . --ext .ts",

package/scheduler/fisk-scheduler.js

@@ -56418,7 +56418,7 @@ class Server extends require$$0__default$2["default"] {
 }
 
 const Version = 5;
-const ObjectCacheFormatVersion = 2;
+const ObjectCacheFormatVersion = 5;
 function cacheDir(option) {
     let dir = option("cache-dir");
     if (!dir) {
@@ -57979,6 +57979,9 @@ Options:
   --max-file-descriptors=N     File descriptor limit
   --ping-interval=MS           WebSocket ping interval
   --monitor-log=PATH           Log file for monitor events
+  --event-loop-lag-interval=MS Event loop lag sample interval (0 disables)
+  --event-loop-lag-threshold=MS  Log a stall at or above this lag
+  --event-loop-lag-summary-interval=MS  Lag summary interval (0 disables)
   --env-dir=PATH               Directory for compiler environments
   --ui=PATH                    Path to scheduler UI static files
   --cache-dir=PATH             Cache directory (default: ~/.cache/fisk/scheduler)
@@ -57997,6 +58000,41 @@ let nextCommandId = 0;
 const server = new Server(option, common.Version);
 const clientMinimumVersion = "5.0.6";
 const serverStartTime = Date.now();
+// A stalled event loop stops calling accept(), the listen backlog fills and the
+// kernel then silently drops SYNs, which clients see as a connect timeout rather
+// than a refusal. It leaves no trace by the time anyone runs ss(8), so record it
+// here with timestamps that can be correlated against client-side timeouts.
+const intervalMs = option.int("event-loop-lag-interval", 100);
+const thresholdMs = option.int("event-loop-lag-threshold", 250);
+const summaryIntervalMs = option.int("event-loop-lag-summary-interval", 60000);
+if (intervalMs > 0) {
+    let maxLag = 0;
+    let stalls = 0;
+    let expected = Date.now() + intervalMs;
+    const tick = () => {
+        const now = Date.now();
+        const lag = now - expected;
+        if (lag > maxLag) {
+            maxLag = lag;
+        }
+        if (lag >= thresholdMs) {
+            ++stalls;
+            console.log(`event-loop-lag stall ${lag}ms at ${new Date(now).toISOString()}`);
+        }
+        // Schedule off "now" rather than accumulating on expected, otherwise a
+        // single long stall reports as a stall on every subsequent tick.
+        expected = now + intervalMs;
+        setTimeout(tick, intervalMs).unref();
+    };
+    setTimeout(tick, intervalMs).unref();
+    if (summaryIntervalMs > 0) {
+        setInterval(() => {
+            console.log(`event-loop-lag summary max=${maxLag}ms stalls=${stalls} over last ${summaryIntervalMs}ms (threshold ${thresholdMs}ms)`);
+            maxLag = 0;
+            stalls = 0;
+        }, summaryIntervalMs).unref();
+    }
+}
 process.on("unhandledRejection", (reason, p) => {
     console.error("Unhandled Rejection at: Promise", p, "reason:", reason === null || reason === void 0 ? void 0 : reason.stack);
     addLogFile({ source: "no source file", ip: "self", contents: `reason: ${reason.stack} promise` });