@andersbakken/fisk 5.0.4 → 5.0.7

package/daemon/fisk-daemon.js

@@ -58,88 +58,191 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 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: "
+// Fingerprinting strategy:
+//
+// A compiler's "identity" for distributed-compile purposes is the set of
+// behaviours that determine what code the frontend accepts and what the
+// backend produces. It is NOT the bytes of the driver executable, because
+// GCC and Clang bake absolute install paths into the driver at build time
+// (STANDARD_EXEC_PREFIX / GCC_INSTALL_PREFIX / CLANG_RESOURCE_DIR /
+// DEFAULT_SYSROOT / ...). Two machines that installed the same conan
+// package for llvm end up with byte-different driver binaries whose paths
+// point into per-machine conan caches, but the compilers are functionally
+// identical. A file hash would say they are different; the scheduler would
+// then be unable to match clients to builders.
+//
+// Instead, we hash the compiler's answers to a small set of probes that
+// (a) are switch-independent, (b) do not embed absolute paths, and
+// (c) fully determine frontend behaviour:
+//
+//   -dumpmachine                    default target triple
+//   -dumpversion                    version number
+//   -x c   -E -dM /dev/null         all builtin macros for C
+//   -x c++ -E -dM /dev/null         all builtin macros for C++
+//
+// The macro dumps include __clang_version__ / __GNUC__ / __GNUC_MINOR__ /
+// __GNUC_PATCHLEVEL__ / __VERSION__ / target width macros / feature-test
+// macros. Those strings are frozen at compiler-build time, not install
+// time, so they are identical across machines that installed the same
+// compiler package.
+const PROBE_TIMEOUT_MS = 10000;
+const PROBE_MAX_BUFFER = 4 * 1024 * 1024;
+const PROBES = [
+    { label: "dumpmachine", args: ["-dumpmachine"], required: true },
+    { label: "dumpversion", args: ["-dumpversion"], required: true },
+    { label: "dumpfullversion", args: ["-dumpfullversion"], required: false },
+    { label: "builtins-c", args: ["-x", "c", "-E", "-dM", "/dev/null"], required: true },
+    { label: "builtins-cxx", args: ["-x", "c++", "-E", "-dM", "/dev/null"], required: true }
 ];
-// 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);
+function runProbe(exec, probe) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { stdout, stderr } = yield execFileAsync(exec, [...probe.args], {
+                timeout: PROBE_TIMEOUT_MS,
+                maxBuffer: PROBE_MAX_BUFFER
+            });
+            return `${stdout}${stderr}`;
+        }
+        catch (err) {
+            if (probe.required) {
+                throw new Error(`Probe '${probe.label}' failed for ${exec}: ${err instanceof Error ? err.message : String(err)}`);
             }
+            return null;
         }
-        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);
+// Emulate the C++ sscanf cascade "%d.%d.%d" -> "%d.%d" -> "%d".
+function parseVersion(text) {
+    const three = /^(\d+)\.(\d+)\.(\d+)/.exec(text);
     if (three) {
-        return {
-            major: parseInt(three[1], 10),
-            minor: parseInt(three[2], 10),
-            patch: parseInt(three[3], 10)
-        };
+        return { major: parseInt(three[1], 10), minor: parseInt(three[2], 10), patch: parseInt(three[3], 10) };
     }
-    const two = /^(\d+)\.(\d+)/.exec(suffix);
+    const two = /^(\d+)\.(\d+)/.exec(text);
     if (two) {
         return { major: parseInt(two[1], 10), minor: parseInt(two[2], 10), patch: 0 };
     }
-    const one = /^(\d+)/.exec(suffix);
+    const one = /^(\d+)/.exec(text);
     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;
+function detectTypeFromMacros(macros) {
+    // clang defines __clang__ even under GCC compatibility mode.
+    if (/^#define __clang__ /m.test(macros)) {
+        return "clang";
+    }
+    // GCC defines __GNUC__ but so does clang; require __GNUC__ *without* __clang__.
+    if (/^#define __GNUC__ /m.test(macros)) {
+        return "gcc";
+    }
+    return "unknown";
+}
+function macroValue(macros, name) {
+    const m = new RegExp(`^#define ${name} (.*)$`, "m").exec(macros);
+    return m ? m[1].trim() : null;
+}
+function stripQuotes(s) {
+    if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+        return s.substring(1, s.length - 1);
+    }
+    return s;
+}
+// Extract a version tuple from the compiler's own macros. This is stable
+// across install locations because these macros are frozen at compiler
+// build time.
+function versionFromMacros(macros, type) {
+    if (type === "clang") {
+        const v = macroValue(macros, "__clang_version__");
+        if (v) {
+            return parseVersion(stripQuotes(v));
         }
-        else if (line.startsWith("Target: ")) {
-            const suffix = line.substring(8);
-            input += suffix;
+        const major = macroValue(macros, "__clang_major__");
+        const minor = macroValue(macros, "__clang_minor__");
+        const patch = macroValue(macros, "__clang_patchlevel__");
+        if (major !== null) {
+            return {
+                major: parseInt(major, 10) || 0,
+                minor: minor !== null ? parseInt(minor, 10) || 0 : 0,
+                patch: patch !== null ? parseInt(patch, 10) || 0 : 0
+            };
         }
     }
-    if (!foundVersion) {
-        const lower = exec.toLowerCase();
-        if (lower.indexOf("clang") !== -1) {
-            type = "clang";
-        }
-        else if (lower.indexOf("gcc") !== -1) {
-            type = "gcc";
+    if (type === "gcc") {
+        const major = macroValue(macros, "__GNUC__");
+        const minor = macroValue(macros, "__GNUC_MINOR__");
+        const patch = macroValue(macros, "__GNUC_PATCHLEVEL__");
+        if (major !== null) {
+            return {
+                major: parseInt(major, 10) || 0,
+                minor: minor !== null ? parseInt(minor, 10) || 0 : 0,
+                patch: patch !== null ? parseInt(patch, 10) || 0 : 0
+            };
         }
     }
-    const hash = crypto.createHash("sha1").update(input).digest("hex").toUpperCase();
-    return { hash, input, type, version };
+    return { major: 0, minor: 0, patch: 0 };
+}
+function gatherProbes(exec) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield Promise.all(PROBES.map((p) => runProbe(exec, p)));
+        const [dumpmachine, dumpversion, dumpfullversion, builtinsC, builtinsCxx] = results;
+        // The required probes cannot be null because runProbe would have thrown.
+        return {
+            dumpmachine: (dumpmachine !== null && dumpmachine !== void 0 ? dumpmachine : "").trim(),
+            dumpversion: (dumpversion !== null && dumpversion !== void 0 ? dumpversion : "").trim(),
+            dumpfullversion: dumpfullversion === null ? null : dumpfullversion.trim(),
+            builtinsC: builtinsC !== null && builtinsC !== void 0 ? builtinsC : "",
+            builtinsCxx: builtinsCxx !== null && builtinsCxx !== void 0 ? builtinsCxx : ""
+        };
+    });
+}
+// Build the canonical fingerprint blob whose SHA becomes the compiler hash.
+// Fields are separated by NUL to avoid ambiguity if any probe output
+// contains our field label as a substring. Field labels are included so
+// that adding a new probe in a later version deterministically changes the
+// hash for the same compiler (the label acts as a schema version bump).
+function canonicalFingerprint(p) {
+    var _a;
+    const parts = [
+        "fisk-compiler-fingerprint-v1",
+        "dumpmachine",
+        p.dumpmachine,
+        "dumpversion",
+        p.dumpversion,
+        "dumpfullversion",
+        (_a = p.dumpfullversion) !== null && _a !== void 0 ? _a : "",
+        "builtins-c",
+        p.builtinsC,
+        "builtins-cxx",
+        p.builtinsCxx
+    ];
+    return Buffer.from(parts.join("\0"), "utf8");
+}
+function createCompilerInfo(exec) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const probes = yield gatherProbes(exec);
+        const type = detectTypeFromMacros(probes.builtinsC);
+        const versionFromMac = versionFromMacros(probes.builtinsC, type);
+        const version = versionFromMac.major !== 0
+            ? versionFromMac
+            : parseVersion((_a = probes.dumpfullversion) !== null && _a !== void 0 ? _a : probes.dumpversion);
+        const blob = canonicalFingerprint(probes);
+        const hash = crypto.createHash("sha1").update(blob).digest("hex").toUpperCase();
+        // `input` is retained for debug/traceability: it lets a human see what
+        // went into the hash without needing to re-probe the compiler. Keep it
+        // small: just the identifying strings, not the full macro dumps.
+        const input = [
+            `type=${type}`,
+            `target=${probes.dumpmachine}`,
+            `version=${version.major}.${version.minor}.${version.patch}`,
+            `dumpversion=${probes.dumpversion}`,
+            probes.dumpfullversion ? `dumpfullversion=${probes.dumpfullversion}` : ""
+        ]
+            .filter((s) => s.length > 0)
+            .join("\n");
+        return { hash, input, type, version };
+    });
 }
 class CompilerInfoCache {
     constructor() {
@@ -151,7 +254,9 @@ class CompilerInfoCache {
             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);
+            // Resolve symlinks so that /usr/bin/clang and /usr/bin/clang-18
+            // (when the former is a symlink to the latter) share a cache entry.
+            const absPath = yield require$$1.promises.realpath(path__default["default"].resolve(compilerPath));
             const stat = yield require$$1.promises.stat(absPath);
             const key = `${absPath}:${stat.mtimeMs}`;
             const cached = this.cache.get(key);
@@ -168,28 +273,20 @@ class CompilerInfoCache {
             });
             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.
+            // lookup doesn't wedge the key forever.
             compute
                 .finally(() => {
                 this.pending.delete(key);
             })
                 .catch(() => {
-                /* rejection observed by caller via the returned `compute` */
+                /* rejection observed by caller via the returned promise */
             });
             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);
+            return createCompilerInfo(absPath);
         });
     }
 }

package/package.json

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

package/scheduler/fisk-scheduler.js

@@ -57995,7 +57995,7 @@ const option = options({
 const common = common$1(option);
 let nextCommandId = 0;
 const server = new Server(option, common.Version);
-const clientMinimumVersion = "4.0.69";
+const clientMinimumVersion = "5.0.6";
 const serverStartTime = Date.now();
 process.on("unhandledRejection", (reason, p) => {
     console.error("Unhandled Rejection at: Promise", p, "reason:", reason === null || reason === void 0 ? void 0 : reason.stack);