@andersbakken/fisk 4.0.71 → 5.0.0

package/daemon/fisk-daemon.js

@@ -1,30 +1,194 @@
 #!/usr/bin/env node
 'use strict';
 
-var EventEmitter = require('events');
+var crypto = require('crypto');
+var child_process = require('child_process');
 var require$$1 = require('fs');
+var require$$4 = require('util');
+var path$h = require('path');
+var EventEmitter = require('events');
 var require$$0 = require('constants');
 var require$$0$1 = require('stream');
-var require$$4 = require('util');
 var assert$1 = require('assert');
-var path$h = require('path');
 var os$1 = require('os');
 var net = require('net');
 var require$$1$1 = require('module');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
 var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
+var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path$h);
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
 var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
-var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
 var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert$1);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path$h);
 var os__default = /*#__PURE__*/_interopDefaultLegacy(os$1);
 var net__default = /*#__PURE__*/_interopDefaultLegacy(net);
 var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+const execFileAsync = require$$4.promisify(child_process.execFile);
+// Prefixes removed from a compiler's `-v` output before hashing / parsing.
+// Must match filter() in src/client/Client.cpp (lines 234-257).
+const FILTER_PREFIXES = [
+    "COLLECT_",
+    "InstalledDir: ",
+    "Found candidate GCC installation: ",
+    "Selected GCC installation: "
+];
+// Remove any line that starts with one of the filter prefixes.
+// Equivalent to the C++ filter() loop that removes needle from line-starts only.
+function filterOutput(output) {
+    let result = output;
+    for (const needle of FILTER_PREFIXES) {
+        const lines = result.split("\n");
+        const kept = [];
+        for (const line of lines) {
+            if (!line.startsWith(needle)) {
+                kept.push(line);
+            }
+        }
+        result = kept.join("\n");
+    }
+    return result;
+}
+// Emulate sscanf cascade "%d.%d.%d" -> "%d.%d" -> "%d".
+function parseVersion(suffix) {
+    const three = /^(\d+)\.(\d+)\.(\d+)/.exec(suffix);
+    if (three) {
+        return {
+            major: parseInt(three[1], 10),
+            minor: parseInt(three[2], 10),
+            patch: parseInt(three[3], 10)
+        };
+    }
+    const two = /^(\d+)\.(\d+)/.exec(suffix);
+    if (two) {
+        return { major: parseInt(two[1], 10), minor: parseInt(two[2], 10), patch: 0 };
+    }
+    const one = /^(\d+)/.exec(suffix);
+    if (one) {
+        return { major: parseInt(one[1], 10), minor: 0, patch: 0 };
+    }
+    return { major: 0, minor: 0, patch: 0 };
+}
+// Byte-for-byte port of createCompilerInfo() in src/client/Client.cpp (lines 290-341).
+function createCompilerInfo(exec, versionInfo) {
+    let type = "unknown";
+    let input = "";
+    let version = { major: 0, minor: 0, patch: 0 };
+    let foundVersion = false;
+    const lines = versionInfo.split("\n");
+    for (const line of lines) {
+        if (line.startsWith("gcc version ")) {
+            type = "gcc";
+            const suffix = line.substring(12);
+            input += suffix;
+            version = parseVersion(suffix);
+            foundVersion = true;
+        }
+        else if (line.startsWith("clang version ")) {
+            type = "clang";
+            const suffix = line.substring(14);
+            input += suffix;
+            version = parseVersion(suffix);
+            foundVersion = true;
+        }
+        else if (line.startsWith("Target: ")) {
+            const suffix = line.substring(8);
+            input += suffix;
+        }
+    }
+    if (!foundVersion) {
+        const lower = exec.toLowerCase();
+        if (lower.indexOf("clang") !== -1) {
+            type = "clang";
+        }
+        else if (lower.indexOf("gcc") !== -1) {
+            type = "gcc";
+        }
+    }
+    const hash = crypto.createHash("sha1").update(input).digest("hex").toUpperCase();
+    return { hash, input, type, version };
+}
+class CompilerInfoCache {
+    constructor() {
+        this.cache = new Map();
+        this.pending = new Map();
+    }
+    get(compilerPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof compilerPath !== "string" || compilerPath.length === 0) {
+                throw new Error("CompilerInfoCache.get: compilerPath must be a non-empty string");
+            }
+            const absPath = path__default["default"].resolve(compilerPath);
+            const stat = yield require$$1.promises.stat(absPath);
+            const key = `${absPath}:${stat.mtimeMs}`;
+            const cached = this.cache.get(key);
+            if (cached) {
+                return cached;
+            }
+            const inflight = this.pending.get(key);
+            if (inflight) {
+                return inflight;
+            }
+            const compute = CompilerInfoCache.compute(absPath).then((info) => {
+                this.cache.set(key, info);
+                return info;
+            });
+            this.pending.set(key, compute);
+            // Clean up the pending map on both success and failure so a failed
+            // lookup doesn't wedge the key forever. We attach a no-op catch on
+            // the cleanup chain because the original rejection is already
+            // surfaced through the returned `compute` promise.
+            compute
+                .finally(() => {
+                this.pending.delete(key);
+            })
+                .catch(() => {
+                /* rejection observed by caller via the returned `compute` */
+            });
+            return compute;
+        });
+    }
+    static compute(absPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { stdout, stderr } = yield execFileAsync(absPath, ["-v"], {
+                timeout: 30000,
+                maxBuffer: 4 * 1024 * 1024
+            });
+            const combined = `${stdout}${stderr}`;
+            const filtered = filterOutput(combined);
+            return createCompilerInfo(absPath, filtered);
+        });
+    }
+}
+
 const Constants = {
     // client codes
     get AcquireCppSlot() {
@@ -4199,6 +4363,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;
+const compilerInfoCache = new CompilerInfoCache();
 const slotSubscribers = [];
 function slotsInfo() {
     return {
@@ -4277,6 +4442,7 @@ server.on("compile", (compile) => {
     });
     let requestedCppSlot = false;
     let requestedLocalSlot = false;
+    let compileClosed = false;
     compile.on("acquireCppSlot", () => {
         if (debug) {
             console.log("acquireCppSlot");
@@ -4320,27 +4486,58 @@ server.on("compile", (compile) => {
             compileSlots.release(compile.id);
         }
     });
-    compile.on("acquireSlot", () => {
+    compile.on("acquireSlot", (msg) => {
         if (debug) {
-            console.log("acquireSlot");
+            console.log("acquireSlot", msg);
         }
-        if (canAcquireLocalSlot() && localSlots.tryAcquire(compile.id, { pid: compile.pid })) {
-            if (debug) {
-                console.log("acquireSlot -> local slot granted");
+        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) => {
+                const message = err instanceof Error ? err.message : String(err);
+                if (debug) {
+                    console.log("acquireSlot -> compilerInfoCache failed", compilerPath, message);
+                }
+                return { info: null, error: message };
+            })
+            : Promise.resolve({ info: null, error: "acquireSlot missing compiler path" });
+        infoResult
+            .then(({ info, error }) => {
+            if (compileClosed) {
+                return;
             }
-            requestedLocalSlot = true;
-            compile.send(Constants.LocalSlotAcquired);
-        }
-        else {
-            if (debug) {
-                console.log("acquireSlot -> falling back to cpp slot");
+            const respond = (slot) => {
+                const response = {
+                    type: "slotAcquired",
+                    slot,
+                    compilerInfo: info
+                };
+                if (error) {
+                    response.error = error;
+                }
+                compile.send(response);
+            };
+            if (canAcquireLocalSlot() && localSlots.tryAcquire(compile.id, { pid: compile.pid })) {
+                if (debug) {
+                    console.log("acquireSlot -> local slot granted");
+                }
+                requestedLocalSlot = true;
+                respond("local");
             }
-            assert__default["default"](!requestedCppSlot);
-            requestedCppSlot = true;
-            cppSlots.acquire(compile.id, { pid: compile.pid }, () => {
-                compile.send(Constants.CppSlotAcquired);
-            });
-        }
+            else {
+                if (debug) {
+                    console.log("acquireSlot -> falling back to cpp slot");
+                }
+                assert__default["default"](!requestedCppSlot);
+                requestedCppSlot = true;
+                cppSlots.acquire(compile.id, { pid: compile.pid }, () => {
+                    respond("cpp");
+                });
+            }
+        })
+            .catch((err) => {
+            // Defensive: the process-wide unhandledRejection handler calls process.exit().
+            console.error("acquireSlot handler failed unexpectedly", err);
+        });
     });
     compile.on("releaseLocalSlot", () => {
         if (debug) {
@@ -4356,6 +4553,7 @@ server.on("compile", (compile) => {
         if (debug) {
             console.error("Got error from fiskc", compile.id, compile.pid, err);
         }
+        compileClosed = true;
         if (requestedCppSlot) {
             requestedCppSlot = false;
             cppSlots.release(compile.id);
@@ -4373,6 +4571,7 @@ server.on("compile", (compile) => {
         if (debug) {
             console.log("got end from", compile.id, compile.pid);
         }
+        compileClosed = true;
         if (requestedCppSlot) {
             requestedCppSlot = false;
             cppSlots.release(compile.id);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@andersbakken/fisk",
-    "version": "4.0.71",
+    "version": "5.0.0",
     "description": "Fisk, a distributed compile system",
     "scripts": {
         "lint": "eslint . --ext .ts",
@@ -33,7 +33,7 @@
     ],
     "dependencies": {
         "@andersbakken/blessed": "^0.1.82",
-        "@andersbakken/fisk-native": "^20.0.0",
+        "@andersbakken/fisk-native": "^21.0.0",
         "@jhanssen/options": "^10.0.0",
         "axios": "^0.21.1",
         "bufferutil": "^4.0.7",